Added untested comm impl

orchid-base/src/interner.rs

@@ -1,20 +1,99 @@
 use std::borrow::Borrow;
+use std::fmt::{Debug, Display};
 use std::future::Future;
-use std::hash::BuildHasher as _;
+use std::hash::{BuildHasher as _, Hash};
 use std::num::NonZeroU64;
 use std::ops::Deref;
 use std::rc::Rc;
 use std::sync::atomic;
 use std::{fmt, hash};
 
+use futures::future::LocalBoxFuture;
 use futures::lock::Mutex;
 use hashbrown::{HashMap, HashSet};
 use itertools::Itertools as _;
 use orchid_api_traits::Request;
+use some_executor::task_local;
 
 use crate::api;
 use crate::reqnot::{DynRequester, Requester};
 
+pub trait IStrHandle: AsRef<str> {}
+pub trait IStrvHandle: AsRef<[IStr]> {}
+
+#[derive(Clone)]
+pub struct IStr(pub api::TStr, pub Rc<dyn IStrHandle>);
+impl Deref for IStr {
+	type Target = str;
+	fn deref(&self) -> &Self::Target { self.1.as_ref().as_ref() }
+}
+impl Eq for IStr {}
+impl PartialEq for IStr {
+	fn eq(&self, other: &Self) -> bool { self.0 == other.0 }
+}
+impl Hash for IStr {
+	fn hash<H: hash::Hasher>(&self, state: &mut H) { self.0.hash(state) }
+}
+impl Display for IStr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.deref()) }
+}
+impl Debug for IStr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "IStr({self}") }
+}
+#[derive(Clone)]
+pub struct IStrv(pub api::TStrv, pub Rc<dyn IStrvHandle>);
+impl Deref for IStrv {
+	type Target = [IStr];
+	fn deref(&self) -> &Self::Target { self.1.as_ref().as_ref() }
+}
+impl Eq for IStrv {}
+impl PartialEq for IStrv {
+	fn eq(&self, other: &Self) -> bool { self.0 == other.0 }
+}
+impl Hash for IStrv {
+	fn hash<H: hash::Hasher>(&self, state: &mut H) { self.0.0.hash(state) }
+}
+impl Display for IStrv {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let mut iter = self.deref().iter();
+		match iter.next() {
+			None => return Ok(()),
+			Some(s) => write!(f, "{s}")?,
+		}
+		for s in iter {
+			write!(f, "::{s}")?
+		}
+		Ok(())
+	}
+}
+impl Debug for IStrv {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "IStrv({self})") }
+}
+
+pub trait InternerSrv {
+	fn is(&self, v: &str) -> LocalBoxFuture<'static, IStr>;
+	fn es(&self, t: api::TStr) -> LocalBoxFuture<'static, IStr>;
+	fn iv(&self, v: &[IStr]) -> LocalBoxFuture<'static, IStrv>;
+	fn ev(&self, t: api::TStrv) -> LocalBoxFuture<'static, IStrv>;
+}
+
+task_local! {
+	static INTERNER: Rc<dyn InternerSrv>;
+}
+
+pub async fn with_interner<F: Future>(val: Rc<dyn InternerSrv>, fut: F) -> F::Output {
+	INTERNER.scope(val, fut).await
+}
+
+fn get_interner() -> Rc<dyn InternerSrv> {
+	INTERNER.with(|i| i.expect("Interner not initialized").clone())
+}
+
+pub async fn is(v: &str) -> IStr { get_interner().is(v).await }
+pub async fn iv(v: &[IStr]) -> IStrv { get_interner().iv(v).await }
+pub async fn es(v: api::TStr) -> IStr { get_interner().es(v).await }
+pub async fn ev(v: api::TStrv) -> IStrv { get_interner().ev(v).await }
+
 /// Clippy crashes while verifying `Tok: Sized` without this and I cba to create
 /// a minimal example
 #[derive(Clone)]
@@ -255,12 +334,7 @@ impl Interner {
 		M::Interned::bimap(&mut *self.0.interners.lock().await).insert(token.clone());
 		token
 	}
-	pub async fn sweep_replica(&self) -> api::Retained {
-		assert!(self.0.master.is_some(), "Not a replica");
-		let mut g = self.0.interners.lock().await;
-		api::Retained { strings: g.strings.sweep_replica(), vecs: g.vecs.sweep_replica() }
-	}
-	pub async fn sweep_master(&self, retained: api::Retained) {
+	pub async fn sweep_master(&self, retained: api::Sweeped) {
 		assert!(self.0.master.is_none(), "Not master");
 		let mut g = self.0.interners.lock().await;
 		g.strings.sweep_master(retained.strings.into_iter().collect());
@@ -275,7 +349,7 @@ impl fmt::Debug for Interner {
 
 static ID: atomic::AtomicU64 = atomic::AtomicU64::new(1);
 
-pub fn merge_retained(into: &mut api::Retained, from: &api::Retained) {
+pub fn merge_retained(into: &mut api::Sweeped, from: &api::Sweeped) {
 	into.strings = into.strings.iter().chain(&from.strings).copied().unique().collect();
 	into.vecs = into.vecs.iter().chain(&from.vecs).copied().unique().collect();
 }