bkp

orchid-extension/src/atom_owned.rs

@@ -1,11 +1,19 @@
-use std::{any::{type_name, Any}, borrow::Cow, io::{Read, Write}, num::NonZeroU64};
+use std::any::{type_name, Any, TypeId};
+use std::borrow::Cow;
+use std::io::{Read, Write};
+use std::marker::PhantomData;
+use std::num::NonZeroU64;
 
-use orchid_api::{atom::LocalAtom, expr::ExprTicket};
+use orchid_api::atom::LocalAtom;
+use orchid_api::expr::ExprTicket;
 use orchid_api_traits::{Decode, Encode};
 use orchid_base::id_store::{IdRecord, IdStore};
-use typeid::ConstTypeId;
 
-use crate::{atom::{AtomCard, AtomFactory, AtomInfo, Atomic, AtomicFeaturesImpl, AtomicVariant, ErrorNotCallable}, expr::{bot, ExprHandle, GenExpr}, system::{atom_info_for, SysCtx}};
+use crate::atom::{
+  AtomCard, AtomDynfo, AtomFactory, Atomic, AtomicFeaturesImpl, AtomicVariant, ErrorNotCallable,
+};
+use crate::expr::{bot, ExprHandle, GenExpr};
+use crate::system::{atom_info_for, SysCtx};
 
 pub struct OwnedVariant;
 impl AtomicVariant for OwnedVariant {}
@@ -19,26 +27,37 @@ impl<A: OwnedAtom + Atomic<Variant = OwnedVariant>> AtomicFeaturesImpl<OwnedVari
       LocalAtom { drop: true, data }
     })
   }
-  fn _info() -> &'static AtomInfo {
-    fn with_atom<U>(mut b: &[u8], f: impl FnOnce(IdRecord<'_, Box<dyn DynOwnedAtom>>) -> U) -> U {
-      f(OBJ_STORE.get(NonZeroU64::decode(&mut b)).expect("Received invalid atom ID"))
-    }
-    &const {
-      AtomInfo {
-        tid: ConstTypeId::of::<Self>(),
-        decode: |mut b| Box::new(<Self as Atomic>::Data::decode(&mut b)),
-        call: |b, ctx, arg| with_atom(b, |a| a.remove().dyn_call(ctx, arg)),
-        call_ref: |b, ctx, arg| with_atom(b, |a| a.dyn_call_ref(ctx, arg)),
-        same: |b1, ctx, b2| with_atom(b1, |a1| with_atom(b2, |a2| a1.dyn_same(ctx, &**a2))),
-        handle_req: |b, ctx, req, rep| with_atom(b, |a| a.dyn_handle_req(ctx, req, rep)),
-        drop: |b, ctx| with_atom(b, |a| a.remove().dyn_free(ctx)),
-      }
-    }
+  type _Info = OwnedAtomDynfo<A>;
+  const _INFO: &'static Self::_Info = &OwnedAtomDynfo(PhantomData);
+}
+
+fn with_atom<U>(mut b: &[u8], f: impl FnOnce(IdRecord<'_, Box<dyn DynOwnedAtom>>) -> U) -> U {
+  f(OBJ_STORE.get(NonZeroU64::decode(&mut b)).expect("Received invalid atom ID"))
+}
+
+pub struct OwnedAtomDynfo<T: OwnedAtom>(PhantomData<T>);
+impl<T: OwnedAtom> AtomDynfo for OwnedAtomDynfo<T> {
+  fn tid(&self) -> TypeId { TypeId::of::<T>() }
+  fn decode(&self, data: &[u8]) -> Box<dyn Any> {
+    Box::new(<T as AtomCard>::Data::decode(&mut &data[..]))
   }
+  fn call(&self, buf: &[u8], ctx: SysCtx, arg: ExprTicket) -> GenExpr {
+    with_atom(buf, |a| a.remove().dyn_call(ctx, arg))
+  }
+  fn call_ref(&self, buf: &[u8], ctx: SysCtx, arg: ExprTicket) -> GenExpr {
+    with_atom(buf, |a| a.dyn_call_ref(ctx, arg))
+  }
+  fn same(&self, buf: &[u8], ctx: SysCtx, buf2: &[u8]) -> bool {
+    with_atom(buf, |a1| with_atom(buf2, |a2| a1.dyn_same(ctx, &**a2)))
+  }
+  fn handle_req(&self, buf: &[u8], ctx: SysCtx, req: &mut dyn Read, rep: &mut dyn Write) {
+    with_atom(buf, |a| a.dyn_handle_req(ctx, req, rep))
+  }
+  fn drop(&self, buf: &[u8], ctx: SysCtx) { with_atom(buf, |a| a.remove().dyn_free(ctx)) }
 }
 
 /// Atoms that have a [Drop]
-pub trait OwnedAtom: AtomCard + Send + Sync + Any + Clone + 'static {
+pub trait OwnedAtom: Atomic<Variant = OwnedVariant> + Send + Sync + Any + Clone + 'static {
   fn val(&self) -> Cow<'_, Self::Data>;
   #[allow(unused_variables)]
   fn call_ref(&self, arg: ExprHandle) -> GenExpr { bot(ErrorNotCallable) }
@@ -61,7 +80,7 @@ pub trait OwnedAtom: AtomCard + Send + Sync + Any + Clone + 'static {
   fn free(self, ctx: SysCtx) {}
 }
 pub trait DynOwnedAtom: Send + Sync + 'static {
-  fn atom_tid(&self) -> ConstTypeId;
+  fn atom_tid(&self) -> TypeId;
   fn as_any_ref(&self) -> &dyn Any;
   fn encode(&self, buffer: &mut dyn Write);
   fn dyn_call_ref(&self, ctx: SysCtx, arg: ExprTicket) -> GenExpr;
@@ -71,7 +90,7 @@ pub trait DynOwnedAtom: Send + Sync + 'static {
   fn dyn_free(self: Box<Self>, ctx: SysCtx);
 }
 impl<T: OwnedAtom> DynOwnedAtom for T {
-  fn atom_tid(&self) -> ConstTypeId { ConstTypeId::of::<T>() }
+  fn atom_tid(&self) -> TypeId { TypeId::of::<T>() }
   fn as_any_ref(&self) -> &dyn Any { self }
   fn encode(&self, buffer: &mut dyn Write) { self.val().as_ref().encode(buffer) }
   fn dyn_call_ref(&self, ctx: SysCtx, arg: ExprTicket) -> GenExpr {
@@ -81,7 +100,7 @@ impl<T: OwnedAtom> DynOwnedAtom for T {
     self.call(ExprHandle::from_args(ctx, arg))
   }
   fn dyn_same(&self, ctx: SysCtx, other: &dyn DynOwnedAtom) -> bool {
-    if ConstTypeId::of::<Self>() != other.as_any_ref().type_id() {
+    if TypeId::of::<Self>() != other.as_any_ref().type_id() {
       return false;
     }
     let other_self = other.as_any_ref().downcast_ref().expect("The type_ids are the same");
@@ -93,4 +112,4 @@ impl<T: OwnedAtom> DynOwnedAtom for T {
   fn dyn_free(self: Box<Self>, ctx: SysCtx) { self.free(ctx) }
 }
 
-pub(crate) static OBJ_STORE: IdStore<Box<dyn DynOwnedAtom>> = IdStore::new();
+pub(crate) static OBJ_STORE: IdStore<Box<dyn DynOwnedAtom>> = IdStore::new();