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

DeCtx

Browse Source
This commit is contained in:
AF 2023-06-28 15:03:09 +00:00
parent 422275bbeb
commit d3d36d973d
10 changed files with 88 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/rcore.rs
View File

@ -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(
&self,
deserializer: &mut dyn Deserializer,
resolver: &Rc<dyn Resolver<'a, Ctx>>,
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>;
}

6
src/rcore/addresses.rs
View File

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

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

@ -72,13 +72,8 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory<A> {
type ParseError = A::AParseError;
fn deserialize(
&self,
deserializer: &mut dyn Deserializer,
_resolver: &Rc<dyn Resolver<'a, Ctx>>,
_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> {

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

@ -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(
&self,
deserializer: &mut dyn Deserializer,
resolver: &Rc<dyn Resolver<'a, Ctx>>,
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));

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

@ -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(
&self,
deserializer: &mut dyn Deserializer,
resolver: &Rc<dyn Resolver<'a, Ctx>>,
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<F::ParseError>;
fn deserialize(
&self,
deserializer: &mut dyn 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)?;
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)

10
src/rstd/inlining.rs
View File

@ -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<dyn Resolver<'a, Ctx>>,
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)

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

@ -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<dyn Resolver<'a, Ctx>>,
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)),
};

11
src/rstd/nullable.rs
View File

@ -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<dyn Resolver<'a, Ctx>>,
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()))
})
}

10
src/rstd/point.rs
View File

@ -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<dyn Resolver<'a, Ctx>>,
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())?)
}

25
src/rstd/typeless.rs
View File

@ -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(
&self,
deserializer: &mut dyn Deserializer,
resolver: &Rc<dyn Resolver<'a, Ctx>>,
addresses: &mut Addresses,
) -> TypelessParsed<'a, Ctx>;
fn de(&self, dectx: &mut dyn DeCtx<'a, Ctx>) -> 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(
&self,
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) {
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<dyn Resolver<'a, Ctx>>,
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<dyn 'a + Error>)
.map(Rc::new)
.map(TypelessMentionable::from_typed)