resolver by reference

src/rcore.rs

@@ -72,7 +72,7 @@ pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self>;
     /// Called by finite stream parsers if there's any data left.
@@ -86,11 +86,11 @@ pub type ParseError<'a, Ctx, F> = <F as Factory<'a, Ctx>>::ParseError;
 pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>;
 
 /// Extension trait for factories.
-pub trait ExtFactory<'a, Ctx: Context<'a>>: Factory<'a, Ctx> {
+pub trait FactoryExt<'a, Ctx: Context<'a>>: Factory<'a, Ctx> {
     /// Parse the object from a slice.
     fn parse_slice(
         &self,
         slice: &[u8],
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
     ) -> ParseResult<'a, Ctx, Self>;
 }

src/rcore/addresses.rs

@@ -43,7 +43,7 @@ impl Addresses {
 fn _parse_slice<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
     factory: &A::Fctr,
     slice: &[u8],
-    resolver: Rc<dyn Resolver<'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())?;
@@ -55,11 +55,11 @@ fn _parse_slice<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
     }
 }
 
-impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> ExtFactory<'a, Ctx> for F {
+impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryExt<'a, Ctx> for F {
     fn parse_slice(
         &self,
         slice: &[u8],
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
     ) -> ParseResult<'a, Ctx, Self> {
         _parse_slice::<Ctx, F::Mtbl>(self, slice, resolver)
     }

src/rcore/resolver_origin.rs

@@ -34,7 +34,7 @@ fn _resolve_origin<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>(
             let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
             let mentionable = origin
                 .r_factory
-                .parse_slice(&src, resolver)
+                .parse_slice(&src, &resolver)
                 .map_err(ResolutionError::Parse)?;
             Ok(Rc::new(mentionable))
         })

src/rcore/slice_deserializer.rs

@@ -2,7 +2,7 @@ use std::cmp::min;
 
 use super::*;
 
-/// [Deserializer] for slices. Used in [`ExtFactory::parse_slice`] and [`crate::rstd::atomic::ExtAtomic::parse_slice`].
+/// [Deserializer] for slices. Used in [`FactoryExt::parse_slice`] and [`crate::rstd::atomic::ExtAtomic::parse_slice`].
 pub struct SliceDeserializer<'a> {
     slice: &'a [u8],
     pos: usize,

src/rstd/atomic.rs

@@ -37,12 +37,10 @@ fn _parse_slice<A: Atomic>(slice: &[u8]) -> Result<A, A::AParseError> {
 
 /// Extension trait to provide method-like utilities associated with [Atomic]s.
 pub trait ExtAtomic: Atomic {
-    /// Static equivalent of [`ExtFactory::parse_slice`].
+    /// Static equivalent of [`FactoryExt::parse_slice`].
-    fn parse_slice(slice: &[u8]) -> Result<Self, Self::AParseError>;
-}
-
-impl<A: Atomic> ExtAtomic for A {
     fn parse_slice(slice: &[u8]) -> Result<Self, Self::AParseError> {
         _parse_slice(slice)
     }
 }
+
+impl<A: Atomic> ExtAtomic for A {}

src/rstd/atomic/atomic_object.rs

@@ -75,7 +75,7 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory<A> {
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        _resolver: Rc<dyn Resolver<'a, Ctx>>,
+        _resolver: &Rc<dyn Resolver<'a, Ctx>>,
         _addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
         Ok(A::a_deserialize(deserializer)?.into())
@@ -87,18 +87,15 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory<A> {
 }
 
 /// Extension trait to provide method-like utilities associated with [AtomicObject]s.
-pub trait ExtAtomicObject: Atomic {
+pub trait AtomicObjectExt: Atomic {
     /// Shorthand for getting specific [`AtomicFactory`].
-    fn f() -> AtomicFactory<Self>;
-    /// Shorthand for getting specific [`AtomicObject`].
-    fn m(self) -> AtomicObject<Self>;
-}
-
-impl<A: Atomic> ExtAtomicObject for A {
     fn f() -> AtomicFactory<Self> {
         AtomicFactory::new()
     }
+    /// Shorthand for getting specific [`AtomicObject`].
     fn m(self) -> AtomicObject<Self> {
         self.into()
     }
 }
+
+impl<A: Atomic> AtomicObjectExt for A {}

src/rstd/cast.rs

@@ -162,7 +162,7 @@ where
     ) -> CastResult<'a, Ctx, A> {
         factory.parse_slice(
             &self.bytes(),
-            map_resolver(CastResolver::rc(self.points_vec())),
+            &map_resolver(CastResolver::rc(self.points_vec())),
         )
     }
 

src/rstd/collections/stack.rs

@@ -77,14 +77,12 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for StackNodeFa
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
-        let rest = match NullableFactory::new(self.clone()).deserialize(
+        let rest =
-            deserializer,
+            match NullableFactory::new(self.clone()).deserialize(deserializer, resolver, addresses)
-            resolver.clone(),
+            {
-            addresses,
-        ) {
                 Ok(rest) => rest,
                 Err(ppe) => {
                     return Err(StackParseError::Point(ppe));

src/rstd/collections/tree.rs

@@ -138,15 +138,15 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NodeFactory
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        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.clone(), addresses)?;
+        let l = tree_factory.deserialize(deserializer, resolver, addresses)?;
-        let r = tree_factory.deserialize(deserializer, resolver.clone(), addresses)?;
+        let r = tree_factory.deserialize(deserializer, resolver, addresses)?;
         let key = self
             .0
-            .deserialize(deserializer, resolver.clone(), addresses)
+            .deserialize(deserializer, resolver, addresses)
             .map_err(TreeParseError::Key)?;
         Ok(Node { l, r, key })
     }
@@ -168,7 +168,7 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for TreeFactory
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
         let node = self.0.deserialize(deserializer, resolver, addresses)?;

src/rstd/inlining.rs

@@ -146,22 +146,7 @@ pub trait CheckedParse<'a, Ctx: Context<'a>>: FixedSizeFactory<'a, Ctx> {
     fn deserialize_checked(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
-        addresses: &mut Addresses,
-    ) -> CheckedParseResult<'a, Ctx, Self>;
-}
-
-/// Extension trait for factories that ensures fixed size write.
-pub trait CheckedSerialize<'a, Ctx: Context<'a>>: Serializable + FixedSizeObject<'a, Ctx> {
-    /// Verify proper write length using [`Serializer::tell`].
-    fn serialize_checked(&self, serializer: &mut dyn Serializer) -> Result<(), SizeError>;
-}
-
-impl<'a, Ctx: Context<'a>, F: FixedSizeFactory<'a, Ctx>> CheckedParse<'a, Ctx> for F {
-    fn deserialize_checked(
-        &self,
-        deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> CheckedParseResult<'a, Ctx, Self> {
         let expected_size = self.size();
@@ -180,9 +165,9 @@ impl<'a, Ctx: Context<'a>, F: FixedSizeFactory<'a, Ctx>> CheckedParse<'a, Ctx> f
     }
 }
 
-impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + FixedSizeObject<'a, Ctx>>
+/// Extension trait for factories that ensures fixed size write.
-    CheckedSerialize<'a, Ctx> for A
+pub trait CheckedSerialize<'a, Ctx: Context<'a>>: Serializable + FixedSizeObject<'a, Ctx> {
-{
+    /// Verify proper write length using [`Serializer::tell`].
     fn serialize_checked(&self, serializer: &mut dyn Serializer) -> Result<(), SizeError> {
         let expected_size = self.size();
         let start = serializer.tell();
@@ -200,6 +185,13 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + FixedSizeObject<'a, Ctx>>
     }
 }
 
+impl<'a, Ctx: Context<'a>, F: FixedSizeFactory<'a, Ctx>> CheckedParse<'a, Ctx> for F {}
+
+impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + FixedSizeObject<'a, Ctx>>
+    CheckedSerialize<'a, Ctx> for A
+{
+}
+
 /// Trait useful for objects which aren't influenced by
 /// whether some other type (for example, a generic parameter type)
 /// is fixed-size or not.

src/rstd/inlining/static_pair.rs

@@ -134,11 +134,11 @@ impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> Factory<'a, Ctx>
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        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.clone(), addresses) {
+        let a: SP::A = match fa.deserialize(deserializer, resolver, addresses) {
             Ok(a) => a,
             Err(error) => return Err(SP::from_error_a(&self.factory_data, error)),
         };

src/rstd/nullable.rs

@@ -58,7 +58,7 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NullableFac
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: std::rc::Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
         let factory = self.factory.clone();
@@ -66,7 +66,7 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NullableFac
         Ok(if address.point == HASH_ZEROS {
             Nullable::Null(factory)
         } else {
-            Nullable::NotNull(Point::from_address(address, factory, resolver))
+            Nullable::NotNull(Point::from_address(address, factory, resolver.clone()))
         })
     }
 

src/rstd/point.rs

@@ -70,10 +70,10 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for PointFactor
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
-        Ok(addresses.next_point(deserializer, resolver, self.factory.clone())?)
+        Ok(addresses.next_point(deserializer, resolver.clone(), self.factory.clone())?)
     }
 
     fn extend(&self, _mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self> {

src/rstd/typeless.rs

@@ -20,7 +20,7 @@ trait Tde<'a, Ctx: Context<'a>>: 'a + Send + Sync {
     fn de(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> TypelessParsed<'a, Ctx>;
 }
@@ -98,7 +98,7 @@ impl<'a, Ctx: Context<'a>> Factory<'a, Ctx> for TypelessFactory<'a, Ctx> {
     fn deserialize(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> ParseResult<'a, Ctx, Self> {
         match self.t_deserialize.de(deserializer, resolver, addresses) {
@@ -140,7 +140,7 @@ where
     fn de(
         &self,
         deserializer: &mut dyn Deserializer,
-        resolver: Rc<dyn Resolver<'a, Ctx>>,
+        resolver: &Rc<dyn Resolver<'a, Ctx>>,
         addresses: &mut Addresses,
     ) -> TypelessParsed<'a, Ctx> {
         self.deserialize(deserializer, resolver, addresses)