From d3d36d973d2a780516154b290ace8013144a1b23 Mon Sep 17 00:00:00 2001 From: timofey Date: Wed, 28 Jun 2023 15:03:09 +0000 Subject: [PATCH] DeCtx --- src/rcore.rs | 53 ++++++++++++++++++++++++++++---- src/rcore/addresses.rs | 6 +++- src/rstd/atomic/atomic_object.rs | 9 ++---- src/rstd/collections/stack.rs | 26 +++++----------- src/rstd/collections/tree.rs | 29 +++++------------ src/rstd/inlining.rs | 10 +++--- src/rstd/inlining/static_pair.rs | 11 ++----- src/rstd/nullable.rs | 11 ++----- src/rstd/point.rs | 10 ++---- src/rstd/typeless.rs | 25 +++------------ 10 files changed, 88 insertions(+), 102 deletions(-) diff --git a/src/rcore.rs b/src/rcore.rs index e4d634e..ceb224c 100644 --- a/src/rcore.rs +++ b/src/rcore.rs @@ -60,6 +60,52 @@ pub type Fctr<'a, Ctx, A> = >::Fctr; /// Shorthand for the type of vaalues returned by [`Factory::deserialize`]. pub type ParseResult<'a, Ctx, F> = Result, >::ParseError>; +pub struct DeCtxT<'a: 'c, 'c, Ctx: Context<'a>> { + deserializer: &'c mut dyn Deserializer, + resolver: &'c Rc>, + addresses: &'c mut Addresses, +} + +pub trait DeCtx<'a, Ctx: Context<'a>> { + fn deserializer(&mut self) -> &mut dyn Deserializer; + + fn next_address(&mut self) -> Result; + + fn resolver(&self) -> Rc>; + + fn adr( + &mut self, + ) -> ( + &mut Addresses, + &mut dyn Deserializer, + &Rc>, + ); +} + +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 { + self.addresses.next(self.deserializer) + } + + fn resolver(&self) -> Rc> { + self.resolver.clone() + } + + fn adr( + &mut self, + ) -> ( + &mut Addresses, + &mut dyn Deserializer, + &Rc>, + ) { + (&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( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self>; + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> 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>; } diff --git a/src/rcore/addresses.rs b/src/rcore/addresses.rs index b91b295..4b98e36 100644 --- a/src/rcore/addresses.rs +++ b/src/rcore/addresses.rs @@ -46,7 +46,11 @@ fn _parse_slice<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>>( resolver: &Rc>, ) -> 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) diff --git a/src/rstd/atomic/atomic_object.rs b/src/rstd/atomic/atomic_object.rs index aa7e92d..45d3b36 100644 --- a/src/rstd/atomic/atomic_object.rs +++ b/src/rstd/atomic/atomic_object.rs @@ -72,13 +72,8 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory { type ParseError = A::AParseError; - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - _resolver: &Rc>, - _addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { - Ok(A::a_deserialize(deserializer)?.into()) + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { + Ok(A::a_deserialize(dectx.deserializer())?.into()) } fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self> { diff --git a/src/rstd/collections/stack.rs b/src/rstd/collections/stack.rs index 1a06a5c..3d8cca5 100644 --- a/src/rstd/collections/stack.rs +++ b/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>; - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { - 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) - { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { + let rest = match NullableFactory::new(self.clone()).deserialize(dectx) { + Ok(rest) => rest, + Err(ppe) => { + return Err(StackParseError::Point(ppe)); + } + }; + let element = match self.element_factory.deserialize(dectx) { Ok(element) => element, Err(epe) => { return Err(StackParseError::Element(epe)); diff --git a/src/rstd/collections/tree.rs b/src/rstd/collections/tree.rs index 66d1ae6..34b54c2 100644 --- a/src/rstd/collections/tree.rs +++ b/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; - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { let tree_factory = TreeFactory(NullableFactory::new(self.clone())); - let l = tree_factory.deserialize(deserializer, resolver, addresses)?; - let r = tree_factory.deserialize(deserializer, resolver, addresses)?; - let key = self - .0 - .deserialize(deserializer, resolver, addresses) - .map_err(TreeParseError::Key)?; + let l = tree_factory.deserialize(dectx)?; + let r = tree_factory.deserialize(dectx)?; + let key = self.0.deserialize(dectx).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; - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { - let node = self.0.deserialize(deserializer, resolver, addresses)?; - let height = u64::a_deserialize(deserializer)?; + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { + let node = self.0.deserialize(dectx)?; + let height = u64::a_deserialize(dectx.deserializer())?; let tree = Tree { node, height }; tree.validate_height()?; Ok(tree) diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs index 52df06e..0b1a02c 100644 --- a/src/rstd/inlining.rs +++ b/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, - resolver: &Rc>, - addresses: &mut Addresses, + dectx: &mut dyn DeCtx<'a, Ctx>, ) -> CheckedParseResult<'a, Ctx, Self> { let expected_size = self.size(); - let start = deserializer.tell(); - let result = self.deserialize(deserializer, resolver, addresses)?; - let end = deserializer.tell(); + let start = dectx.deserializer().tell(); + let result = self.deserialize(dectx)?; + let end = dectx.deserializer().tell(); let received_size = end - start; if received_size == expected_size { Ok(result) diff --git a/src/rstd/inlining/static_pair.rs b/src/rstd/inlining/static_pair.rs index 8a92c0f..ef2bdd3 100644 --- a/src/rstd/inlining/static_pair.rs +++ b/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( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> 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)), }; diff --git a/src/rstd/nullable.rs b/src/rstd/nullable.rs index 1d2da59..26832fa 100644 --- a/src/rstd/nullable.rs +++ b/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( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> 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())) }) } diff --git a/src/rstd/point.rs b/src/rstd/point.rs index 90df0c9..f8a8ed6 100644 --- a/src/rstd/point.rs +++ b/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( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { + let (addresses, deserializer, resolver) = dectx.adr(); Ok(addresses.next_point(deserializer, resolver.clone(), self.factory.clone())?) } diff --git a/src/rstd/typeless.rs b/src/rstd/typeless.rs index d1804f5..db559fa 100644 --- a/src/rstd/typeless.rs +++ b/src/rstd/typeless.rs @@ -17,12 +17,7 @@ type TypelessParsed<'a, Ctx> = Result, Box>: 'a + Send + Sync { fn clone_box(&self) -> TdeBox<'a, Ctx>; - fn de( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> TypelessParsed<'a, Ctx>; + fn de(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> TypelessParsed<'a, Ctx>; } type TdeBox<'a, Ctx> = Box>; @@ -95,13 +90,8 @@ impl<'a, Ctx: Context<'a>> Factory<'a, Ctx> for TypelessFactory<'a, Ctx> { type ParseError = TypelessError<'a>; - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> ParseResult<'a, Ctx, Self> { - match self.t_deserialize.de(deserializer, resolver, addresses) { + fn deserialize(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { + match self.t_deserialize.de(dectx) { Ok(mentionable) => Ok(mentionable), Err(error) => Err(TypelessError(error)), } @@ -137,13 +127,8 @@ where Box::new(self.clone()) } - fn de( - &self, - deserializer: &mut dyn Deserializer, - resolver: &Rc>, - addresses: &mut Addresses, - ) -> TypelessParsed<'a, Ctx> { - self.deserialize(deserializer, resolver, addresses) + fn de(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> TypelessParsed<'a, Ctx> { + self.deserialize(dectx) .map_err(|e| Box::new(e) as Box) .map(Rc::new) .map(TypelessMentionable::from_typed)