feat: both sync and async instance, sync feat

Cargo.toml

@@ -29,3 +29,4 @@ tonic-build = "0.9"
 default = ["proto", "global"]
 proto   = ["dep:prost"]
 global  = ["dep:lazy_static"]
+sync    = []

src/client.rs

@@ -42,6 +42,7 @@ impl Client {
 	}
 
 	pub fn leave_workspace(&mut self) {
+		// TODO need to stop tasks?
 		self.workspace = None
 	}
 

src/instance.rs

@@ -1,35 +1,130 @@
-use std::sync::{Arc, Mutex};
-
-use tokio::runtime::Runtime;
-
-use crate::{
-	buffer::controller::BufferController,
-	errors::Error, client::Client, cursor::controller::CursorController,
-};
-
 #[cfg(feature = "global")]
 pub mod global {
+	#[cfg(not(feature = "sync"))]
 	lazy_static::lazy_static! {
-		pub static ref INSTANCE : super::Instance = super::Instance::default();
+		pub static ref INSTANCE : super::a_sync::Instance = super::a_sync::Instance::default();
+	}
+
+	#[cfg(feature = "sync")]
+	lazy_static::lazy_static! {
+		pub static ref INSTANCE : super::sync::Instance = super::sync::Instance::default();
 	}
 }
 
-pub struct Instance {
+#[cfg(not(feature = "sync"))]
+pub mod a_sync {
+	use std::sync::Arc;
+	
+	use tokio::sync::Mutex;
+	
+	use crate::{
+		buffer::controller::BufferController,
+		errors::Error, client::Client, cursor::controller::CursorController,
+	};
+
+	#[derive(Default)]
+	pub struct Instance {
 		client: Mutex<Option<Client>>,
-	runtime: Runtime,
+	}
+	
+	impl Instance {
+		pub async fn connect(&self, addr: &str) -> Result<(), Error> {
+			*self.client.lock().await = Some(Client::new(addr).await?);
+			Ok(())
+		}
+	
+		pub async fn join(&self, session: &str) -> Result<Arc<CursorController>, Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.join(session)
+				.await
+		}
+	
+		pub async fn create(&self, path: &str, content: Option<&str>) -> Result<(), Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.create(path, content)
+				.await
+		}
+	
+		pub async fn attach(&self, path: &str) -> Result<Arc<BufferController>, Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.attach(path)
+				.await
+		}
+	
+		pub async fn get_cursor(&self) -> Result<Arc<CursorController>, Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.get_cursor()
+				.ok_or(Error::InvalidState { msg: "join workspace first".into() })
+		}
+	
+		pub async fn get_buffer(&self, path: &str) -> Result<Arc<BufferController>, Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.get_buffer(path)
+				.ok_or(Error::InvalidState { msg: "join workspace first".into() })
+		}
+	
+		pub async fn leave_workspace(&self) -> Result<(), Error> {
+			self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.leave_workspace();
+			Ok(())
+		}
+	
+		pub async fn disconnect_buffer(&self, path: &str) -> Result<bool, Error> {
+			let res = self.client
+				.lock().await
+				.as_mut()
+				.ok_or(Error::InvalidState { msg: "connect first".into() })?
+				.disconnect_buffer(path);
+			Ok(res)
+		}
+	}
 }
 
-impl Default for Instance {
+#[cfg(feature = "sync")]
+pub mod sync {
+	use std::sync::{Mutex, Arc};
+
+	use tokio::runtime::Runtime;
+
+	use crate::{
+		client::Client, Error,
+		cursor::controller::CursorController,
+		buffer::controller::BufferController
+	};
+
+	pub struct Instance {
+		client: Mutex<Option<Client>>,
+		runtime: Runtime,
+	}
+	
+	impl Default for Instance {
 		fn default() -> Self {
 			Instance {
 				client: Mutex::new(None),
 				runtime: Runtime::new().expect("could not start tokio runtime"),
 			}
 		}
-}
+	}
-
-impl Instance {
 	
+	impl Instance {
 		fn if_client<T>(&self, op: impl FnOnce(&mut Client) -> T) -> Result<T, Error> {
 			if let Some(c) = self.client.lock().expect("client mutex poisoned").as_mut() {
 				Ok(op(c))
@@ -72,4 +167,5 @@ impl Instance {
 		pub fn disconnect_buffer(&self, path: &str) -> Result<bool, Error> {
 			self.if_client(|c| c.disconnect_buffer(path))
 		}
+	}
 }