Atomic via AtomicModeProxy

src/rstd/atomic.rs

@@ -15,7 +15,7 @@ use crate::rcore::*;
 use super::*;
 
 pub use self::modes::{
-    AExtensionResultM, AExtensionSourceM, AParseResultM, AtomicModeParse, AtomicProxy,
+    AExtensionResultM, AExtensionSourceM, AParseResultM, AtomicModeParse, AtomicModeProxy,
     RegularAtomic,
 };
 

src/rstd/atomic/atomic_object.rs

@@ -36,7 +36,7 @@ impl<A: AtomicBase> Serializable for AtomicObject<A> {
     }
 }
 
-pub trait AoProxy<'a, Ctx: Context<'a>>: AtomicProxy {
+pub trait AoProxy<'a, Ctx: Context<'a>>: AtomicModeProxy {
     type Mtbl: MentionableBase<'a, Ctx, Fctr = Self::Fctr> + MentionableTop<'a, Ctx>;
     type Fctr: FactoryBase<'a, Ctx, Mtbl = Self::Mtbl>;
 

src/rstd/atomic/modes.rs

@@ -1,22 +1,15 @@
 use super::*;
 
-pub trait AtomicProxy {
-    type A: AtomicBase + ParseMode;
-
-    fn pa_deserialize(inlining: impl Inlining) -> AParseResult<Self::A>;
-    fn pa_extend(a: Self::A, tail: &[u8]) -> AParseResult<Self::A>;
-}
-
 impl<A: AtomicBase + WithParseMode> Atomic for A
 where
-    A::WithMode: AtomicProxy<A = Self>,
+    A::WithMode: AtomicModeProxy<A = Self>,
 {
     fn a_deserialize(inlining: impl Inlining) -> AParseResult<Self> {
-        <A::WithMode as AtomicProxy>::pa_deserialize(inlining)
+        <A::Mode as Mode>::seal(Self::ma_deserialize(inlining))
     }
 
     fn a_extend(self, tail: &[u8]) -> AParseResult<Self> {
-        <A::WithMode as AtomicProxy>::pa_extend(self, tail)
+        <A::Mode as Mode>::xseal(Self::ma_extend(self.ma_prepare(), tail))
     }
 }
 
@@ -68,14 +61,18 @@ pub trait RegularAtomic: AtomicBase + ParseMode<Mode = RegularMode> {
     fn ra_extend(self, tail: &[u8]) -> AParseResult<Self>;
 }
 
-impl<A: RegularAtomic> AtomicProxy for WithMode<A, RegularMode> {
+impl<A: RegularAtomic> AtomicModeProxy for WithMode<A, RegularMode> {
     type A = A;
 
-    fn pa_deserialize(inlining: impl Inlining) -> AParseResult<Self::A> {
+    fn pma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self::A, I> {
         A::ra_deserialize(inlining)
     }
 
-    fn pa_extend(a: Self::A, tail: &[u8]) -> AParseResult<Self::A> {
-        a.ra_extend(tail)
+    fn pma_extend(atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
+        atomic.ra_extend(tail)
+    }
+
+    fn pma_prepare(atomic: Self::A) -> AExtensionSourceM<Self::A> {
+        atomic
     }
 }

src/rstd/inlining/modes.rs

@@ -68,14 +68,16 @@ impl<'a, Ctx: Context<'a>, F: InliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx
     fn pmprepare(_mentionable: Mtbl<'a, Ctx, Self::F>) -> ExtensionSourceM<'a, Ctx, Self::F> {}
 }
 
-impl<A: InliningAtomic> AtomicProxy for WithMode<A, InliningMode> {
+impl<A: InliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
     type A = A;
 
-    fn pa_deserialize(inlining: impl Inlining) -> AParseResult<Self::A> {
-        A::a_ideserialize(inlining).seal()
+    fn pma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self::A, I> {
+        A::a_ideserialize(inlining)
     }
 
-    fn pa_extend(_a: Self::A, tail: &[u8]) -> AParseResult<Self::A> {
-        Err(A::a_extension_error(tail))
+    fn pma_extend(_atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
+        A::a_extension_error(tail)
     }
+
+    fn pma_prepare(_atomic: Self::A) -> AExtensionSourceM<Self::A> {}
 }