got api working ish, I need to clean this code up a lot

src/parsing.rs

@@ -1,60 +1,82 @@
 use std::collections::HashMap;
 use crate::character;
+use crate::api;
+use crate::mpsc::*;
+use std::{thread};
+use std::sync::{Arc,Mutex};
+use std::time::Duration;
 
 mod strings;
 
 // Parse the tokens in a file
 // Returns success or an error string
-pub fn token_parse(
+pub async fn token_parse(
 	tokens: &Vec<&str>,
-	mut characters: &mut HashMap::<String, character::Character>
-) -> ( Result<(),&'static str> )
+	mut characters: &mut HashMap::<String, character::Character>,
+	data_to_send: Arc<Mutex<api::Data_to_send>>,
+	rx: &Receiver<u8>,
+) -> Result<(),String>
 {
 	let mut index: usize = 0;
 	// Run an infinite loop
 	loop
 	{
-		match tokens.get(index) {
-			Some(token) => {
-				// The instructions are related to characters
-				if token.chars().next().unwrap() == '@'
-				{
-					let character_name: String = token.chars().skip(1).collect();
-					// If the character doesn't exist, then create it
-					if ! characters.contains_key(&character_name)
-					{
-						let new_character = character::Character::new(character_name.clone());
-						characters.insert(character_name.clone(),new_character);
-					}
-					println!("Doing something with a character: {}", character_name);
-					// The index is incremented to after the character's instructions
-					index += match character_parse(index+1, &tokens, character_name, &mut characters)
-					{
-						Ok(increment) => increment,
-						Err(error) => return Err(error),
-					}
-				}
-				// Miscelleneous instructions
-				if token.to_lowercase() == "end"
-				{
-					return Ok(());
+		match rx.try_recv()
+		{
+			Ok(_) =>
+			{
+				match tokens.get(index) {
+					Some(token) => {
+						// The instructions are related to characters
+						if token.chars().next().unwrap() == '@'
+						{
+							let character_name: String = token.chars().skip(1).collect();
+							// If the character doesn't exist, then create it
+							if ! characters.contains_key(&character_name)
+							{
+								let new_character = character::Character::new(character_name.clone());
+								characters.insert(character_name.clone(),new_character);
+							}
+							println!("Doing something with a character: {}", character_name);
+							// The index is incremented to after the character's instructions
+							index += match character_parse(index+1, &tokens, character_name, &mut characters, &data_to_send, &rx).await
+							{
+								Ok(increment) => {
+									increment
+								},
+								Err(error) => return Err(error),
+							}
+						}
+						// Miscelleneous instructions
+						if token.to_lowercase() == "end"
+						{
+							return Ok(()) // quit
+						}
+					},
+					None => return Err(String::from("File reached termination point")),
 				}
 				index += 1;
 			},
-			None => return Err("File reached termination point")
+			Err(_) => thread::sleep(Duration::from_millis(4000)),
 		}
 	}
 }
-
 // Parsing character related instructions
-fn character_parse(index: usize, tokens: &Vec<&str>, character_name: String, characters: &mut HashMap::<String, character::Character>) ->
-( Result<usize,&'static str> )
+async fn character_parse
+(
+	index: usize,
+	tokens: &Vec<&str>,
+	character_name: String,
+	characters: &mut HashMap::<String, character::Character>,
+	data_to_send: &Arc<Mutex<api::Data_to_send>>,
+	rx: &Receiver<u8>,
+) -> Result<usize,String>
 {
 	let mut sum_index: usize = index;
 	loop
 	{
-		
-		match tokens.get(sum_index)
+		// Ensure the index is valid (the index is not beyond the vector)
+		let _ = match tokens.get(sum_index)
 		{
 			Some(token) => {
 				match token.to_lowercase().as_str()
@@ -68,18 +90,21 @@ fn character_parse(index: usize, tokens: &Vec<&str>, character_name: String, cha
 							Some(output_string) =>
 							{
 								println!("{}", output_string);
-								return Ok(sum_index - index);
+								let mut data = data_to_send.lock().unwrap();
+								data.action_type = String::from("output");
+								data.content = output_string;
+								data.character = character_name.clone();
 							},
-							None => return Err("Unable to read string"),
+							None => return Err(String::from("Unable to read string")),
 						}
 					},
 					// Catch all condition, if the instruction is unrecognised as a
 					// character command
-					&_ => return Err("Invalid command"),
+					_ => return Err(String::from("Invalid command")),
 				}
 			},
-			None => return Err("File reached termination point")
-		}
+			None => return Err(String::from("File reached termination point"))
+		};
 		sum_index += 1;
 	}
 }