From f1b4e7b88e048524ca3ed133446ebb6328a03543 Mon Sep 17 00:00:00 2001 From: timofey Date: Fri, 28 Jul 2023 19:40:30 +0000 Subject: [PATCH] `FactoryBase` --- src/rcore.rs | 19 +++++++++++-------- src/rstd/atomic.rs | 2 +- src/rstd/atomic/atomic_object.rs | 4 +++- src/rstd/cast.rs | 2 +- src/rstd/collections/stack.rs | 4 +++- src/rstd/collections/tree.rs | 8 ++++++-- src/rstd/inlining.rs | 5 ++--- src/rstd/inlining/static_pair.rs | 8 ++++++-- src/rstd/nullable.rs | 4 +++- src/rstd/point.rs | 4 +++- src/rstd/typeless.rs | 4 +++- 11 files changed, 42 insertions(+), 22 deletions(-) diff --git a/src/rcore.rs b/src/rcore.rs index 4cc9eef..2b8a2c3 100644 --- a/src/rcore.rs +++ b/src/rcore.rs @@ -67,19 +67,22 @@ pub trait Mentionable<'a, Ctx: Context<'a>>: 'a + Serializable { 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 type ParseResult<'a, Ctx, F> = Result, ParseError<'a, Ctx, F>>; /// [`ParseResult`] associated with a [`Mentionable`] (instead of a [`Factory`]). pub type ParseResultA<'a, Ctx, A> = Result>; -/// Trait representing deserialisation rules for [Mentionable]s. -/// Crucial for [`crate::rstd::typeless`]. -pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone { +/// [Factory] base. +pub trait FactoryBase<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone { /// Type of the associated objects. type Mtbl: Mentionable<'a, Ctx, Fctr = Self>; /// Type of an error that [`Factory::deserialize`] can fail with. type ParseError: 'a + Error; +} +/// Trait representing deserialisation rules for [Mentionable]s. +/// Crucial for [`crate::rstd::typeless`]. +pub trait Factory<'a, Ctx: Context<'a>>: FactoryBase<'a, Ctx> { /// See [`Deserializer`], [`Resolver`]. fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self>; /// Called by finite stream parsers if there's any data left. @@ -87,12 +90,12 @@ pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone { } /// [`Mentionable`] associated with the [`Factory`]. Mostly useful for `type` definitions. -pub type Mtbl<'a, Ctx, F> = >::Mtbl; +pub type Mtbl<'a, Ctx, F> = >::Mtbl; -/// [`Factory::ParseError`]. Mostly useful for `type` definitions. -pub type ParseError<'a, Ctx, F> = >::ParseError; +/// [`FactoryBase::ParseError`]. Mostly useful for `type` definitions. +pub type ParseError<'a, Ctx, F> = >::ParseError; -/// [`Factory::ParseError`] associated with the [`Mentionable`]. +/// [`FactoryBase::ParseError`] associated with the [`Mentionable`]. /// Mostly useful for `type` definitions. pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>; diff --git a/src/rstd/atomic.rs b/src/rstd/atomic.rs index a5cfe1c..89fbfa9 100644 --- a/src/rstd/atomic.rs +++ b/src/rstd/atomic.rs @@ -19,7 +19,7 @@ pub type AParseResult = Result::AParseError>; /// while limiting [`Mentionable::points_typed`] (and corresponding [`Mentionable::topology`]) /// to an empty sequence. pub trait Atomic: 'static + Send + Sync + Send + Clone + Serializable { - /// Equivalent of [`Factory::ParseError`]. + /// Equivalent of [`FactoryBase::ParseError`]. type AParseError: Error; /// Static equivalent of [`Factory::deserialize`]. fn a_deserialize(inlining: impl Inlining) -> AParseResult; diff --git a/src/rstd/atomic/atomic_object.rs b/src/rstd/atomic/atomic_object.rs index f55f913..1c30cc2 100644 --- a/src/rstd/atomic/atomic_object.rs +++ b/src/rstd/atomic/atomic_object.rs @@ -67,11 +67,13 @@ impl Clone for AtomicFactory { } } -impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory { +impl<'a, Ctx: Context<'a>, A: Atomic> FactoryBase<'a, Ctx> for AtomicFactory { type Mtbl = AtomicObject; type ParseError = A::AParseError; +} +impl<'a, Ctx: Context<'a>, A: Atomic> Factory<'a, Ctx> for AtomicFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { Ok(A::a_deserialize(inctx)?.into()) } diff --git a/src/rstd/cast.rs b/src/rstd/cast.rs index d4822fe..44d0107 100644 --- a/src/rstd/cast.rs +++ b/src/rstd/cast.rs @@ -15,7 +15,7 @@ struct CastResolver<'a, Ctx: Context<'a>> { } /// Used to represent errors that might arise during resolution/parsion. -/// Is expected to be classified as [`Context::LookupError`] rather than [`Factory::ParseError`]. +/// Is expected to be classified as [`Context::LookupError`] rather than [`FactoryBase::ParseError`]. /// [`CastError::AddressIndexOutOfBounds`] and [`CastError::AddressPointMismatch`] /// variants generally shouldn't happen. #[derive(Debug)] diff --git a/src/rstd/collections/stack.rs b/src/rstd/collections/stack.rs index ca886a2..aca1ee3 100644 --- a/src/rstd/collections/stack.rs +++ b/src/rstd/collections/stack.rs @@ -87,11 +87,13 @@ impl StackNodeFactory { } } -impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for StackNodeFactory { +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryBase<'a, Ctx> for StackNodeFactory { type Mtbl = StackNode<'a, Ctx, F::Mtbl>; type ParseError = StackParseError>; +} +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for StackNodeFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { let (rest, inctx) = self.parse_point(inctx)?; let element = self diff --git a/src/rstd/collections/tree.rs b/src/rstd/collections/tree.rs index 186dc6e..82cd444 100644 --- a/src/rstd/collections/tree.rs +++ b/src/rstd/collections/tree.rs @@ -131,11 +131,13 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for Tre } } -impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NodeFactory { +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryBase<'a, Ctx> for NodeFactory { type Mtbl = Node<'a, Ctx, F::Mtbl>; type ParseError = TreeParseError; +} +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NodeFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { let tree_factory = TreeFactory(NullableFactory::new(self.clone())); let (l, inctx) = tree_factory.ideserialize(inctx)?; @@ -153,11 +155,13 @@ impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NodeFactory } } -impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for TreeFactory { +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryBase<'a, Ctx> for TreeFactory { type Mtbl = Tree<'a, Ctx, F::Mtbl>; type ParseError = TreeParseError; +} +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for TreeFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { self.ideserialize(inctx).seal() } diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs index 168c426..43c8598 100644 --- a/src/rstd/inlining.rs +++ b/src/rstd/inlining.rs @@ -10,8 +10,7 @@ use super::{ *, }; -pub type IParseResult<'a, Ctx, F, I> = - Result<(Mtbl<'a, Ctx, F>, I), >::ParseError>; +pub type IParseResult<'a, Ctx, F, I> = Result<(Mtbl<'a, Ctx, F>, I), ParseError<'a, Ctx, F>>; /// This factory should return an error on EOF. pub trait InlineableFactory<'a, Ctx: Context<'a>>: Factory<'a, Ctx> { @@ -126,7 +125,7 @@ impl Display for SizeError { impl Error for SizeError {} -/// Wrapper for [`SizeError`]/[`Factory::ParseError`]. +/// Wrapper for [`SizeError`]/[`FactoryBase::ParseError`]. #[derive(Debug)] pub enum CheckedParseError { Parse(P), diff --git a/src/rstd/inlining/static_pair.rs b/src/rstd/inlining/static_pair.rs index f913320..36dfb4d 100644 --- a/src/rstd/inlining/static_pair.rs +++ b/src/rstd/inlining/static_pair.rs @@ -41,7 +41,7 @@ pub trait StaticPair<'a, Ctx: Context<'a>>: type FA: Factory<'a, Ctx, Mtbl = Self::A> + InlineableFactory<'a, Ctx>; /// Second element's factory. type FB: Factory<'a, Ctx, Mtbl = Self::B>; - /// See [Factory::ParseError]. + /// See [`FactoryBase::ParseError`]. type ParseError: 'a + Error; /// Borrow both elements' factories. @@ -124,13 +124,17 @@ impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> Clone for StaticPairFactory< } } -impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> Factory<'a, Ctx> +impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> FactoryBase<'a, Ctx> for StaticPairFactory<'a, Ctx, SP> { type Mtbl = StaticPairObject; type ParseError = SP::ParseError; +} +impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> Factory<'a, Ctx> + for StaticPairFactory<'a, Ctx, SP> +{ fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { let (fa, fb) = SP::factories(&self.factory_data); let (a, inctx) = fa diff --git a/src/rstd/nullable.rs b/src/rstd/nullable.rs index 0e6b459..86d2836 100644 --- a/src/rstd/nullable.rs +++ b/src/rstd/nullable.rs @@ -50,11 +50,13 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for Nul } } -impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NullableFactory { +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryBase<'a, Ctx> for NullableFactory { type Mtbl = Nullable<'a, Ctx, F::Mtbl>; type ParseError = PointParseError; +} +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for NullableFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { self.ideserialize(inctx).seal() } diff --git a/src/rstd/point.rs b/src/rstd/point.rs index f5c731b..f7014c2 100644 --- a/src/rstd/point.rs +++ b/src/rstd/point.rs @@ -68,11 +68,13 @@ impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> AsRef<[u8]> for Point<'a, Ct } } -impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for PointFactory { +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> FactoryBase<'a, Ctx> for PointFactory { type Mtbl = Point<'a, Ctx, F::Mtbl>; type ParseError = PointParseError; +} +impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for PointFactory { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { let (point, _) = inctx.icnext_point(self.inner(), |slice| PointParseError::from(slice))?; Ok(point) diff --git a/src/rstd/typeless.rs b/src/rstd/typeless.rs index b63bb41..2e42981 100644 --- a/src/rstd/typeless.rs +++ b/src/rstd/typeless.rs @@ -87,11 +87,13 @@ impl<'a> Display for TypelessError<'a> { impl<'a> Error for TypelessError<'a> {} -impl<'a, Ctx: Context<'a>> Factory<'a, Ctx> for TypelessFactory<'a, Ctx> { +impl<'a, Ctx: Context<'a>> FactoryBase<'a, Ctx> for TypelessFactory<'a, Ctx> { type Mtbl = TypelessMentionable<'a, Ctx>; type ParseError = TypelessError<'a>; +} +impl<'a, Ctx: Context<'a>> Factory<'a, Ctx> for TypelessFactory<'a, Ctx> { fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self> { self.t_deserialize.de(inctx.demote()).map_err(TypelessError) }