PTV/radn-rs
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

resolver by reference

Browse Source
This commit is contained in:
AF 2023-06-28 14:29:39 +00:00
parent 0fdf7532dc
commit 422275bbeb
14 changed files with 51 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/rcore.rs
View File

@ -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>;
}

6
src/rcore/addresses.rs
View File

@ -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)
}

2
src/rcore/resolver_origin.rs
View File

@ -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))
})

2
src/rcore/slice_deserializer.rs
View File

@ -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,

8
src/rstd/atomic.rs
View File

@ -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`].
fn parse_slice(slice: &[u8]) -> Result<Self, Self::AParseError>;
}
impl<A: Atomic> ExtAtomic for A {
/// Static equivalent of [`FactoryExt::parse_slice`].
fn parse_slice(slice: &[u8]) -> Result<Self, Self::AParseError> {
_parse_slice(slice)
}
}
impl<A: Atomic> ExtAtomic for A {}

13
src/rstd/atomic/atomic_object.rs
View File

@ -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 {}

2
src/rstd/cast.rs
View File

@ -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())),
)
}

20
src/rstd/collections/stack.rs
View File

@ -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<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(
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)

10
src/rstd/collections/tree.rs
View File

@ -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 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<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)?;

30
src/rstd/inlining.rs
View File

@ -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>>,
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>>,
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>>
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.

4
src/rstd/inlining/static_pair.rs
View File

@ -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)),
};

4
src/rstd/nullable.rs
View File

@ -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()))
})
}

4
src/rstd/point.rs
View File

@ -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> {

6
src/rstd/typeless.rs
View File

@ -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)