diff --git a/src/rcore.rs b/src/rcore.rs index 130a624..e4d634e 100644 --- a/src/rcore.rs +++ b/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>, + resolver: &Rc>, 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> = >::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>, + resolver: &Rc>, ) -> ParseResult<'a, Ctx, Self>; } diff --git a/src/rcore/addresses.rs b/src/rcore/addresses.rs index 31aac60..b91b295 100644 --- a/src/rcore/addresses.rs +++ b/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>, + resolver: &Rc>, ) -> 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>, + resolver: &Rc>, ) -> ParseResult<'a, Ctx, Self> { _parse_slice::(self, slice, resolver) } diff --git a/src/rcore/resolver_origin.rs b/src/rcore/resolver_origin.rs index 5d4b347..4e25650 100644 --- a/src/rcore/resolver_origin.rs +++ b/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)) }) diff --git a/src/rcore/slice_deserializer.rs b/src/rcore/slice_deserializer.rs index 572e536..88d8575 100644 --- a/src/rcore/slice_deserializer.rs +++ b/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, diff --git a/src/rstd/atomic.rs b/src/rstd/atomic.rs index 673e1c8..fc156e6 100644 --- a/src/rstd/atomic.rs +++ b/src/rstd/atomic.rs @@ -37,12 +37,10 @@ fn _parse_slice(slice: &[u8]) -> Result { /// Extension trait to provide method-like utilities associated with [Atomic]s. pub trait ExtAtomic: Atomic { - /// Static equivalent of [`ExtFactory::parse_slice`]. - fn parse_slice(slice: &[u8]) -> Result; -} - -impl ExtAtomic for A { + /// Static equivalent of [`FactoryExt::parse_slice`]. fn parse_slice(slice: &[u8]) -> Result { _parse_slice(slice) } } + +impl ExtAtomic for A {} diff --git a/src/rstd/atomic/atomic_object.rs b/src/rstd/atomic/atomic_object.rs index f2a37ad..aa7e92d 100644 --- a/src/rstd/atomic/atomic_object.rs +++ b/src/rstd/atomic/atomic_object.rs @@ -75,7 +75,7 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory { fn deserialize( &self, deserializer: &mut dyn Deserializer, - _resolver: Rc>, + _resolver: &Rc>, _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 { } /// 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; - /// Shorthand for getting specific [`AtomicObject`]. - fn m(self) -> AtomicObject; -} - -impl ExtAtomicObject for A { fn f() -> AtomicFactory { AtomicFactory::new() } + /// Shorthand for getting specific [`AtomicObject`]. fn m(self) -> AtomicObject { self.into() } } + +impl AtomicObjectExt for A {} diff --git a/src/rstd/cast.rs b/src/rstd/cast.rs index 6fc443f..3bc5dff 100644 --- a/src/rstd/cast.rs +++ b/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())), ) } diff --git a/src/rstd/collections/stack.rs b/src/rstd/collections/stack.rs index 30f7209..1a06a5c 100644 --- a/src/rstd/collections/stack.rs +++ b/src/rstd/collections/stack.rs @@ -77,19 +77,17 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for StackNodeFa fn deserialize( &self, deserializer: &mut dyn Deserializer, - resolver: Rc>, + resolver: &Rc>, addresses: &mut Addresses, ) -> ParseResult<'a, Ctx, Self> { - let rest = match NullableFactory::new(self.clone()).deserialize( - deserializer, - resolver.clone(), - addresses, - ) { - Ok(rest) => rest, - Err(ppe) => { - return Err(StackParseError::Point(ppe)); - } - }; + let rest = + match NullableFactory::new(self.clone()).deserialize(deserializer, resolver, addresses) + { + Ok(rest) => rest, + Err(ppe) => { + return Err(StackParseError::Point(ppe)); + } + }; let element = match self .element_factory .deserialize(deserializer, resolver, addresses) diff --git a/src/rstd/collections/tree.rs b/src/rstd/collections/tree.rs index b628aaa..66d1ae6 100644 --- a/src/rstd/collections/tree.rs +++ b/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>, + resolver: &Rc>, 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 r = tree_factory.deserialize(deserializer, resolver.clone(), addresses)?; + let l = tree_factory.deserialize(deserializer, resolver, 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>, + resolver: &Rc>, addresses: &mut Addresses, ) -> ParseResult<'a, Ctx, Self> { let node = self.0.deserialize(deserializer, resolver, addresses)?; diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs index e5c8908..52df06e 100644 --- a/src/rstd/inlining.rs +++ b/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>, - 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>, + resolver: &Rc>, 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>> - CheckedSerialize<'a, Ctx> for A -{ +/// 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> { 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. diff --git a/src/rstd/inlining/static_pair.rs b/src/rstd/inlining/static_pair.rs index 11da2cc..8a92c0f 100644 --- a/src/rstd/inlining/static_pair.rs +++ b/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>, + resolver: &Rc>, 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)), }; diff --git a/src/rstd/nullable.rs b/src/rstd/nullable.rs index 69435ed..1d2da59 100644 --- a/src/rstd/nullable.rs +++ b/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>, + resolver: &Rc>, 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())) }) } diff --git a/src/rstd/point.rs b/src/rstd/point.rs index 31c7426..90df0c9 100644 --- a/src/rstd/point.rs +++ b/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>, + resolver: &Rc>, 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> { diff --git a/src/rstd/typeless.rs b/src/rstd/typeless.rs index 4d37d79..d1804f5 100644 --- a/src/rstd/typeless.rs +++ b/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>, + resolver: &Rc>, 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>, + resolver: &Rc>, 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>, + resolver: &Rc>, addresses: &mut Addresses, ) -> TypelessParsed<'a, Ctx> { self.deserialize(deserializer, resolver, addresses)