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

src/api.rs

@@ -0,0 +1,41 @@
+use warp::Filter;
+use std::{
+	thread,
+	sync::{Arc, Mutex},
+};
+use crate::config;
+use serde::{Deserialize, Serialize};
+use crate::mpsc::*;
+use tokio::sync::RwLock;
+use crate::api;
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Data_to_send {
+	pub action_type: String,
+	pub content: String,
+	pub character: String,
+}
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct Data_to_receive {
+	pub response: String,
+}
+
+pub async fn api_process(data_to_send: Arc<Mutex<Data_to_send>>, tx: Sender<u8>)
+{
+	let data_filter = warp::any().map(move || Arc::clone(&data_to_send));
+	let tx_filter = warp::any().map(move || tx.clone());
+	println!("Running server");
+	let route = warp::path("happening")
+		.and(warp::get())
+		.and(data_filter)
+		.and(tx_filter)
+		.map(|state: Arc<Mutex<Data_to_send>>, tx_handle: Sender<u8>| {
+			println!("GET: {:?}", state);
+			let reply = state.as_ref();
+			tx_handle.send(1);
+			warp::reply::json(&reply)
+		}).boxed();
+	warp::serve(route)
+		.run(([127, 0, 0, 1],config::API_PORT))
+		.await;
+}

src/config.rs

@@ -0,0 +1 @@
+pub static API_PORT: u16 = 20264;

src/main.rs

@@ -1,10 +1,38 @@
-use std::fs;
-use std::collections::HashMap;
+use std::
+{
+	fs,
+	thread,
+	collections::HashMap,
+	sync::{Arc, Mutex, mpsc},
+};
+use serde::{Deserialize, Serialize};
+use tokio::runtime::Runtime;
+use tokio::task;
+use warp::Filter;
 
 mod parsing;
 mod character;
+mod config;
+mod api;
 
-fn main() {
+#[tokio::main]
+async fn main() {
+	let (tx,rx) = mpsc::channel();
+	let mut data_to_send = Arc::new(Mutex::new(api::Data_to_send
+	{
+		action_type: "initialise".to_string(),
+		content: "".to_string(),
+		character: "".to_string(),
+	}));
+
+	let data = Arc::clone(&data_to_send);
+	let tx_clone = tx.clone();
+	// Spawn a thread for warp
+	tokio::spawn(
+		async move {
+			api::api_process(data, tx_clone).await;
+	});
+	println!("and continue");
 	let mut characters = HashMap::<String, character::Character>::new();
 	let file_contents: String = fs::read_to_string("stories/story.ha").unwrap();
 	// Split the file contents into tokens
@@ -12,7 +40,9 @@ fn main() {
 		.split_whitespace()
 		.collect();
 	// Run the parsing process
-	match parsing::token_parse(&tokens, &mut characters) {
+	let data_clone = Arc::clone(&data_to_send);
+	match parsing::token_parse(&tokens, &mut characters, data_clone, &rx).await
+	{
 		Ok(()) => println!("Program exited successfully"),
 		Err(error) => println!("{}", error),
 	}

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;
 	}
 }