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,18 +1,114 @@
-use std::sync::{Arc, Mutex};
+#[cfg(feature = "global")]
+pub mod global {
+	#[cfg(not(feature = "sync"))]
+	lazy_static::lazy_static! {
+		pub static ref INSTANCE : super::a_sync::Instance = super::a_sync::Instance::default();
+	}
 
-use tokio::runtime::Runtime;
+	#[cfg(feature = "sync")]
+	lazy_static::lazy_static! {
+		pub static ref INSTANCE : super::sync::Instance = super::sync::Instance::default();
+	}
+}
+
+#[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,
 	};
 
-#[cfg(feature = "global")]
+	#[derive(Default)]
-pub mod global {
+	pub struct Instance {
-	lazy_static::lazy_static! {
+		client: Mutex<Option<Client>>,
-		pub static ref INSTANCE : super::Instance = super::Instance::default();
+	}
+	
+	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)
 		}
 	}
+}
+
+#[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>>,
@@ -29,7 +125,6 @@ impl Default for 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))
@@ -73,3 +168,4 @@ impl Instance {
 			self.if_client(|c| c.disconnect_buffer(path))
 		}
 	}
+}