From 7d07f5ffea13aab3c9b9029088a8f15e8e7c7e44 Mon Sep 17 00:00:00 2001 From: timofey Date: Sat, 29 Jul 2023 20:16:52 +0000 Subject: [PATCH] "inlineable" -> "inlining" --- src/rstd/atomic/array.rs | 2 +- src/rstd/atomic/au64.rs | 2 +- src/rstd/atomic/boolean.rs | 2 +- src/rstd/collections/pair.rs | 2 +- src/rstd/collections/stack.rs | 4 ++-- src/rstd/collections/tree.rs | 2 +- src/rstd/inlining.rs | 30 +++++++++++++++--------------- src/rstd/inlining/modes.rs | 4 ++-- src/rstd/inlining/static_pair.rs | 8 ++++---- src/rstd/nullable.rs | 2 +- src/rstd/point.rs | 2 +- 11 files changed, 30 insertions(+), 30 deletions(-) diff --git a/src/rstd/atomic/array.rs b/src/rstd/atomic/array.rs index e6c0e14..d912c84 100644 --- a/src/rstd/atomic/array.rs +++ b/src/rstd/atomic/array.rs @@ -42,7 +42,7 @@ impl ImplMode for [u8; N] { type Mode = InliningMode; } -impl InlineableAtomic for [u8; N] { +impl InliningAtomic for [u8; N] { fn a_extension_error(tail: &[u8]) -> Self::AParseError { ArrayParseError::ExtraData(tail.len()) } diff --git a/src/rstd/atomic/au64.rs b/src/rstd/atomic/au64.rs index 3be9472..e4b61db 100644 --- a/src/rstd/atomic/au64.rs +++ b/src/rstd/atomic/au64.rs @@ -42,7 +42,7 @@ impl ImplMode for u64 { type Mode = InliningMode; } -impl InlineableAtomic for u64 { +impl InliningAtomic for u64 { fn a_extension_error(tail: &[u8]) -> Self::AParseError { IntParseError::ExtraData(tail.len()) } diff --git a/src/rstd/atomic/boolean.rs b/src/rstd/atomic/boolean.rs index 38fcc8f..45e37b6 100644 --- a/src/rstd/atomic/boolean.rs +++ b/src/rstd/atomic/boolean.rs @@ -49,7 +49,7 @@ impl ImplMode for bool { type Mode = InliningMode; } -impl InlineableAtomic for bool { +impl InliningAtomic for bool { fn a_extension_error(tail: &[u8]) -> Self::AParseError { BooleanParseError::ExtraData(tail.len()) } diff --git a/src/rstd/collections/pair.rs b/src/rstd/collections/pair.rs index 19df825..e1ab377 100644 --- a/src/rstd/collections/pair.rs +++ b/src/rstd/collections/pair.rs @@ -46,7 +46,7 @@ impl Error for PairParseError {} impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx>, B: MentionableBase<'a, Ctx>> StaticPair<'a, Ctx> for (A, B) where - A::Fctr: InlineableFactory<'a, Ctx>, + A::Fctr: InliningFactory<'a, Ctx>, B::Fctr: ParseMode, { type FactoryData = (Self::FA, Self::FB); diff --git a/src/rstd/collections/stack.rs b/src/rstd/collections/stack.rs index b10619c..c3d33f2 100644 --- a/src/rstd/collections/stack.rs +++ b/src/rstd/collections/stack.rs @@ -229,7 +229,7 @@ where } } -impl<'a, Ctx: Context<'a>, F: ImplMode + InlineableFactory<'a, Ctx>> +impl<'a, Ctx: Context<'a>, F: ImplMode + InliningFactory<'a, Ctx>> ExternalPointsProxy<'a, Ctx, Stack<'a, Ctx, Mtbl<'a, Ctx, F>>> for WithMode where F::Mtbl: MentionableTop<'a, Ctx>, @@ -242,7 +242,7 @@ where } } -impl<'a, Ctx: Context<'a>, F: ImplMode + InlineableFactory<'a, Ctx>> InlineableFactory<'a, Ctx> +impl<'a, Ctx: Context<'a>, F: ImplMode + InliningFactory<'a, Ctx>> InliningFactory<'a, Ctx> for StackNodeFactory where F::Mtbl: MentionableTop<'a, Ctx>, diff --git a/src/rstd/collections/tree.rs b/src/rstd/collections/tree.rs index 226076a..423599c 100644 --- a/src/rstd/collections/tree.rs +++ b/src/rstd/collections/tree.rs @@ -172,7 +172,7 @@ impl ImplMode for TreeFactory { type Mode = InliningMode; } -impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> InlineableFactory<'a, Ctx> for TreeFactory { +impl<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>> InliningFactory<'a, Ctx> for TreeFactory { fn extension_error(&self, tail: &[u8]) -> Self::ParseError { u64::a_extension_error(tail).into() } diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs index 8046285..e56b5a3 100644 --- a/src/rstd/inlining.rs +++ b/src/rstd/inlining.rs @@ -15,7 +15,7 @@ pub use self::modes::InliningMode; 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>>: +pub trait InliningFactory<'a, Ctx: Context<'a>>: FactoryBase<'a, Ctx> + ParseMode { fn extension_error(&self, tail: &[u8]) -> Self::ParseError; @@ -24,7 +24,7 @@ pub trait InlineableFactory<'a, Ctx: Context<'a>>: } /// This factory always reads the same amount of bytes or returns error. -pub trait FixedSizeFactory<'a, Ctx: Context<'a>>: InlineableFactory<'a, Ctx> { +pub trait FixedSizeFactory<'a, Ctx: Context<'a>>: InliningFactory<'a, Ctx> { /// For [`ConstSizeFactory`] this must return [`ConstSizeFactory::SIZE`]. fn size(&self) -> usize; } @@ -35,11 +35,11 @@ pub trait ConstSizeFactory<'a, Ctx: Context<'a>>: FixedSizeFactory<'a, Ctx> { const SIZE: usize; } -/// Object analogue of [`InlineableFactory`]. -pub trait InlineableObject<'a, Ctx: Context<'a>>: Mentionable<'a, Ctx> {} +/// Object analogue of [`InliningFactory`]. +pub trait InliningObject<'a, Ctx: Context<'a>>: Mentionable<'a, Ctx> {} /// Object analogue of [`FixedSizeFactory`]. -pub trait FixedSizeObject<'a, Ctx: Context<'a>>: InlineableObject<'a, Ctx> { +pub trait FixedSizeObject<'a, Ctx: Context<'a>>: InliningObject<'a, Ctx> { /// For [`ConstSizeObject`] this must return [`ConstSizeObject::SIZE`]. fn size(&self) -> usize; } @@ -52,8 +52,8 @@ pub trait ConstSizeObject<'a, Ctx: Context<'a>>: FixedSizeObject<'a, Ctx> { pub type ADParseResult = Result<(A, D), AParseError>; -/// Atomic analogue of [`InlineableFactory`]/[`InlineableObject`]. -pub trait InlineableAtomic: AtomicBase + ImplMode { +/// Atomic analogue of [`InliningFactory`]/[`InliningObject`]. +pub trait InliningAtomic: AtomicBase + ImplMode { fn a_extension_error(tail: &[u8]) -> Self::AParseError; fn a_ideserialize(inlining: D) -> ADParseResult; @@ -64,11 +64,11 @@ pub trait InlineableAtomic: AtomicBase + ImplMode { /// Note: `FixedSizeAtomic` doesn't exist because it would /// either be const anyway /// or have a very undesireable implementation. -pub trait ConstSizeAtomic: InlineableAtomic { +pub trait ConstSizeAtomic: InliningAtomic { const SIZE: usize; } -impl<'a, Ctx: Context<'a>, A: InlineableAtomic> InlineableFactory<'a, Ctx> for AtomicFactory +impl<'a, Ctx: Context<'a>, A: InliningAtomic> InliningFactory<'a, Ctx> for AtomicFactory where ::WithMode: AoProxy<'a, Ctx, Fctr = Self, A = A>, { @@ -101,8 +101,8 @@ where const SIZE: usize = A::SIZE; } -impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> InlineableObject<'a, Ctx> for A where - A::Fctr: InlineableFactory<'a, Ctx> +impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> InliningObject<'a, Ctx> for A where + A::Fctr: InliningFactory<'a, Ctx> { } @@ -224,8 +224,8 @@ pub trait AlwaysFixedSize { fn _size(&self) -> usize; } -impl<'a, Ctx: Context<'a>, F: AlwaysFixedSize + InlineableFactory<'a, Ctx>> - FixedSizeFactory<'a, Ctx> for F +impl<'a, Ctx: Context<'a>, F: AlwaysFixedSize + InliningFactory<'a, Ctx>> FixedSizeFactory<'a, Ctx> + for F { fn size(&self) -> usize { self._size() @@ -243,8 +243,8 @@ impl AlwaysFixedSize for F { } } -impl<'a, Ctx: Context<'a>, F: AlwaysConstSize + InlineableFactory<'a, Ctx>> - ConstSizeFactory<'a, Ctx> for F +impl<'a, Ctx: Context<'a>, F: AlwaysConstSize + InliningFactory<'a, Ctx>> ConstSizeFactory<'a, Ctx> + for F { const SIZE: usize = Self::_SIZE; } diff --git a/src/rstd/inlining/modes.rs b/src/rstd/inlining/modes.rs index cd8e5ec..03e4caa 100644 --- a/src/rstd/inlining/modes.rs +++ b/src/rstd/inlining/modes.rs @@ -48,7 +48,7 @@ impl Mode for InliningMode { } } -impl<'a, Ctx: Context<'a>, F: InlineableFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx> +impl<'a, Ctx: Context<'a>, F: InliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx> for WithMode { type F = F; @@ -68,7 +68,7 @@ impl<'a, Ctx: Context<'a>, F: InlineableFactory<'a, Ctx>> FactoryModeProxy<'a, C fn pmprepare(_mentionable: Mtbl<'a, Ctx, Self::F>) -> ExtensionSourceM<'a, Ctx, Self::F> {} } -impl AtomicProxy for WithMode { +impl AtomicProxy for WithMode { type A = A; fn pa_deserialize(inlining: impl Inlining) -> AParseResult { diff --git a/src/rstd/inlining/static_pair.rs b/src/rstd/inlining/static_pair.rs index 78cc3e8..626f0c5 100644 --- a/src/rstd/inlining/static_pair.rs +++ b/src/rstd/inlining/static_pair.rs @@ -27,7 +27,7 @@ pub trait StaticPairSerializable { /// for clarity and [`StaticPair`]'s simpler implementation /// at the cost of having to specify two extra fields. /// -/// Note: [`StaticPair::FA`] requires [`InlineableFactory`] be implemented. +/// Note: [`StaticPair::FA`] requires [`InliningFactory`] be implemented. pub trait StaticPair<'a, Ctx: Context<'a>>: 'a + StaticPairSerializable { @@ -38,7 +38,7 @@ pub trait StaticPair<'a, Ctx: Context<'a>>: /// Second element's type. Must equal [`StaticPairSerializable::SB`]. type B: MentionableBase<'a, Ctx, Fctr = Self::FB>; /// First element's factory. - type FA: FactoryBase<'a, Ctx, Mtbl = Self::A> + InlineableFactory<'a, Ctx>; + type FA: FactoryBase<'a, Ctx, Mtbl = Self::A> + InliningFactory<'a, Ctx>; /// Second element's factory. type FB: FactoryBase<'a, Ctx, Mtbl = Self::B> + ParseMode; /// See [`FactoryBase::ParseError`]. @@ -172,10 +172,10 @@ where } } -impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> InlineableFactory<'a, Ctx> +impl<'a, Ctx: Context<'a>, SP: StaticPair<'a, Ctx>> InliningFactory<'a, Ctx> for StaticPairFactory<'a, Ctx, SP> where - SP::FB: InlineableFactory<'a, Ctx>, + SP::FB: InliningFactory<'a, Ctx>, { fn extension_error(&self, tail: &[u8]) -> Self::ParseError { let (_, fb) = SP::factories(&self.factory_data); diff --git a/src/rstd/nullable.rs b/src/rstd/nullable.rs index 43e31e4..0316943 100644 --- a/src/rstd/nullable.rs +++ b/src/rstd/nullable.rs @@ -107,7 +107,7 @@ impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx>> Clone for Nullable<'a, C } } -impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> InlineableFactory<'a, Ctx> +impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> InliningFactory<'a, Ctx> for NullableFactory { fn extension_error(&self, tail: &[u8]) -> Self::ParseError { diff --git a/src/rstd/point.rs b/src/rstd/point.rs index ae7af8e..10fefee 100644 --- a/src/rstd/point.rs +++ b/src/rstd/point.rs @@ -83,7 +83,7 @@ impl ParseMode for PointFactory { type Mode = InliningMode; } -impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> InlineableFactory<'a, Ctx> for PointFactory { +impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> InliningFactory<'a, Ctx> for PointFactory { fn extension_error(&self, tail: &[u8]) -> Self::ParseError { PointParseError::WrongLength(HASH_SIZE + tail.len()) }