DeCtx

src/rcore.rs

@@ -60,6 +60,52 @@ pub type Fctr<'a, Ctx, A> = <A as Mentionable<'a, Ctx>>::Fctr;
 /// Shorthand for the type of vaalues returned by [`Factory::deserialize`].
 pub type ParseResult<'a, Ctx, F> = Result<Mtbl<'a, Ctx, F>, <F as Factory<'a, Ctx>>::ParseError>;
 
+pub struct DeCtxT<'a: 'c, 'c, Ctx: Context<'a>> {
+    deserializer: &'c mut dyn Deserializer,
+    resolver: &'c Rc<dyn Resolver<'a, Ctx>>,
+    addresses: &'c mut Addresses,
+}
+
+pub trait DeCtx<'a, Ctx: Context<'a>> {
+    fn deserializer(&mut self) -> &mut dyn Deserializer;
+
+    fn next_address(&mut self) -> Result<Address, &[u8]>;
+
+    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>>;
+
+    fn adr(
+        &mut self,
+    ) -> (
+        &mut Addresses,
+        &mut dyn Deserializer,
+        &Rc<dyn Resolver<'a, Ctx>>,
+    );
+}
+
+impl<'a: 'c, 'c, Ctx: Context<'a>> DeCtx<'a, Ctx> for DeCtxT<'a, 'c, Ctx> {
+    fn deserializer(&mut self) -> &mut dyn Deserializer {
+        self.deserializer
+    }
+
+    fn next_address(&mut self) -> Result<Address, &[u8]> {
+        self.addresses.next(self.deserializer)
+    }
+
+    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>> {
+        self.resolver.clone()
+    }
+
+    fn adr(
+        &mut self,
+    ) -> (
+        &mut Addresses,
+        &mut dyn Deserializer,
+        &Rc<dyn Resolver<'a, Ctx>>,
+    ) {
+        (&mut self.addresses, self.deserializer, self.resolver)
+    }
+}
+
 /// Trait representing deserialisation rules for [Mentionable]s.
 /// Crucial for [`crate::rstd::typeless`].
 pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {
@@ -69,12 +115,7 @@ pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {
     type ParseError: 'a + Error;
 
     /// See [`Deserializer`], [`Resolver`].
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self>;
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self>;
     /// Called by finite stream parsers if there's any data left.
     fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self>;
 }

src/rcore/addresses.rs

@@ -46,7 +46,11 @@ fn _parse_slice<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
     resolver: &Rc<dyn Resolver<'a, Ctx>>,
 ) -> ParseResult<'a, Ctx, A::Fctr> {
     let mut deserializer = SliceDeserializer::from(slice);
-    let mentionable = factory.deserialize(&mut deserializer, resolver, &mut Addresses::start())?;
+    let mentionable = factory.deserialize(&mut DeCtxT {
+        deserializer: &mut deserializer,
+        resolver,
+        addresses: &mut Addresses::start(),
+    })?;
     let tail = deserializer.read_all();
     if tail.is_empty() {
         Ok(mentionable)

src/rstd/atomic/atomic_object.rs

@@ -72,13 +72,8 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory<A> {
 
     type ParseError = A::AParseError;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
+        Ok(A::a_deserialize(dectx.deserializer())?.into())
-        deserializer: &mut dyn Deserializer,
-        _resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        _addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
-        Ok(A::a_deserialize(deserializer)?.into())
     }
 
     fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self> {

src/rstd/collections/stack.rs

@@ -74,24 +74,14 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for StackNodeFa
 
     type ParseError = StackParseError<ParseError<'a, Ctx, F>>;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
+        let rest = match NullableFactory::new(self.clone()).deserialize(dectx) {
-        deserializer: &mut dyn Deserializer,
+            Ok(rest) => rest,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
+            Err(ppe) => {
-        addresses: &mut Addresses,
+                return Err(StackParseError::Point(ppe));
-    ) -> ParseResult<'a, Ctx, Self> {
+            }
-        let rest =
+        };
-            match NullableFactory::new(self.clone()).deserialize(deserializer, resolver, addresses)
+        let element = match self.element_factory.deserialize(dectx) {
-            {
-                Ok(rest) => rest,
-                Err(ppe) => {
-                    return Err(StackParseError::Point(ppe));
-                }
-            };
-        let element = match self
-            .element_factory
-            .deserialize(deserializer, resolver, addresses)
-        {
             Ok(element) => element,
             Err(epe) => {
                 return Err(StackParseError::Element(epe));

src/rstd/collections/tree.rs

@@ -1,6 +1,6 @@
 pub mod context;
 
-use std::{error::Error, fmt::Display, rc::Rc};
+use std::{error::Error, fmt::Display};
 
 use crate::{
     flow::binary::*,
@@ -135,19 +135,11 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NodeFactory
 
     type ParseError = TreeParseError<F::ParseError>;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
         let tree_factory = TreeFactory(NullableFactory::new(self.clone()));
-        let l = tree_factory.deserialize(deserializer, resolver, addresses)?;
+        let l = tree_factory.deserialize(dectx)?;
-        let r = tree_factory.deserialize(deserializer, resolver, addresses)?;
+        let r = tree_factory.deserialize(dectx)?;
-        let key = self
+        let key = self.0.deserialize(dectx).map_err(TreeParseError::Key)?;
-            .0
-            .deserialize(deserializer, resolver, addresses)
-            .map_err(TreeParseError::Key)?;
         Ok(Node { l, r, key })
     }
 
@@ -165,14 +157,9 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for TreeFactory
 
     type ParseError = TreeParseError<F::ParseError>;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
+        let node = self.0.deserialize(dectx)?;
-        deserializer: &mut dyn Deserializer,
+        let height = u64::a_deserialize(dectx.deserializer())?;
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
-        let node = self.0.deserialize(deserializer, resolver, addresses)?;
-        let height = u64::a_deserialize(deserializer)?;
         let tree = Tree { node, height };
         tree.validate_height()?;
         Ok(tree)

src/rstd/inlining.rs

@@ -145,14 +145,12 @@ pub trait CheckedParse<'a, Ctx: Context<'a>>: FixedSizeFactory<'a, Ctx> {
     /// Verify proper read length using [`Deserializer::tell`].
     fn deserialize_checked(
         &self,
-        deserializer: &mut dyn Deserializer,
+        dectx: &mut dyn DeCtx<'a, Ctx>,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
     ) -> CheckedParseResult<'a, Ctx, Self> {
         let expected_size = self.size();
-        let start = deserializer.tell();
+        let start = dectx.deserializer().tell();
-        let result = self.deserialize(deserializer, resolver, addresses)?;
+        let result = self.deserialize(dectx)?;
-        let end = deserializer.tell();
+        let end = dectx.deserializer().tell();
         let received_size = end - start;
         if received_size == expected_size {
             Ok(result)

src/rstd/inlining/static_pair.rs

@@ -131,18 +131,13 @@ impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> Factory<'a, Ctx>
 
     type ParseError = SP::ParseError;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
         let (fa, fb) = SP::factories(&self.factory_data);
-        let a: SP::A = match fa.deserialize(deserializer, resolver, addresses) {
+        let a: SP::A = match fa.deserialize(dectx) {
             Ok(a) => a,
             Err(error) => return Err(SP::from_error_a(&self.factory_data, error)),
         };
-        let b: SP::B = match fb.deserialize(deserializer, resolver, addresses) {
+        let b: SP::B = match fb.deserialize(dectx) {
             Ok(b) => b,
             Err(error) => return Err(SP::from_error_b(&self.factory_data, error)),
         };

src/rstd/nullable.rs

@@ -55,18 +55,13 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NullableFac
 
     type ParseError = PointParseError;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
         let factory = self.factory.clone();
-        let address = addresses.next(deserializer)?;
+        let address = dectx.next_address()?;
         Ok(if address.point == HASH_ZEROS {
             Nullable::Null(factory)
         } else {
-            Nullable::NotNull(Point::from_address(address, factory, resolver.clone()))
+            Nullable::NotNull(Point::from_address(address, factory, dectx.resolver()))
         })
     }
 

src/rstd/point.rs

@@ -1,6 +1,6 @@
 //! Module responsible for making [Point]s [Mentionable].
 
-use std::{error::Error, fmt::Display, rc::Rc};
+use std::{error::Error, fmt::Display};
 
 use crate::rcore::*;
 
@@ -67,12 +67,8 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for PointFactor
 
     type ParseError = PointParseError;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
+        let (addresses, deserializer, resolver) = dectx.adr();
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
         Ok(addresses.next_point(deserializer, resolver.clone(), self.factory.clone())?)
     }
 

src/rstd/typeless.rs

@@ -17,12 +17,7 @@ type TypelessParsed<'a, Ctx> = Result<TypelessMentionable<'a, Ctx>, Box<dyn 'a +
 trait Tde<'a, Ctx: Context<'a>>: 'a + Send + Sync {
     fn clone_box(&self) -> TdeBox<'a, Ctx>;
 
-    fn de(
+    fn de(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> TypelessParsed<'a, Ctx>;
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> TypelessParsed<'a, Ctx>;
 }
 
 type TdeBox<'a, Ctx> = Box<dyn Tde<'a, Ctx>>;
@@ -95,13 +90,8 @@ impl<'a, Ctx: Context<'a>> Factory<'a, Ctx> for TypelessFactory<'a, Ctx> {
 
     type ParseError = TypelessError<'a>;
 
-    fn deserialize(
+    fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> {
-        &self,
+        match self.t_deserialize.de(dectx) {
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> ParseResult<'a, Ctx, Self> {
-        match self.t_deserialize.de(deserializer, resolver, addresses) {
             Ok(mentionable) => Ok(mentionable),
             Err(error) => Err(TypelessError(error)),
         }
@@ -137,13 +127,8 @@ where
         Box::new(self.clone())
     }
 
-    fn de(
+    fn de(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> TypelessParsed<'a, Ctx> {
-        &self,
+        self.deserialize(dectx)
-        deserializer: &mut dyn Deserializer,
-        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> TypelessParsed<'a, Ctx> {
-        self.deserialize(deserializer, resolver, addresses)
             .map_err(|e| Box::new(e) as Box<dyn 'a + Error>)
             .map(Rc::new)
             .map(TypelessMentionable::from_typed)