QInliningAtomic

src/rstd/atomic/array.rs

@@ -42,12 +42,12 @@ impl<const N: usize> ImplMode for [u8; N] {
     type Mode = InliningMode;
 }
 
-impl<const N: usize> InliningAtomic for [u8; N] {
-    fn a_extension_error(tail: &[u8]) -> Self::AParseError {
+impl<const N: usize> QInliningAtomic for [u8; N] {
+    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
         ArrayParseError::ExtraData(tail.len())
     }
 
-    fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
         inlining.iread_n_const::<N>(|slice| ArrayParseError::from(slice))
     }
 }

src/rstd/atomic/au64.rs

@@ -42,12 +42,12 @@ impl ImplMode for u64 {
     type Mode = InliningMode;
 }
 
-impl InliningAtomic for u64 {
-    fn a_extension_error(tail: &[u8]) -> Self::AParseError {
+impl QInliningAtomic for u64 {
+    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
         IntParseError::ExtraData(tail.len())
     }
 
-    fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
         let (x, inlining) = inlining.iread_n_const::<8>(|slice| IntParseError::from(slice))?;
         Ok((u64::from_le_bytes(x), inlining))
     }

src/rstd/atomic/boolean.rs

@@ -49,12 +49,12 @@ impl ImplMode for bool {
     type Mode = InliningMode;
 }
 
-impl InliningAtomic for bool {
-    fn a_extension_error(tail: &[u8]) -> Self::AParseError {
+impl QInliningAtomic for bool {
+    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
         BooleanParseError::ExtraData(tail.len())
     }
 
-    fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
         let (byte, inlining) =
             inlining.iread_n_const::<1>(|slice| BooleanParseError::from(slice))?;
         match byte[0] {

src/rstd/inlining.rs

@@ -52,6 +52,12 @@ pub trait ConstSizeObject<'a, Ctx: Context<'a>>: FixedSizeObject<'a, Ctx> {
 
 pub type ADParseResult<A, D> = Result<(A, D), AParseError<A>>;
 
+pub trait QInliningAtomic: AtomicBase + ImplMode<Mode = InliningMode> {
+    fn qa_extension_error(tail: &[u8]) -> Self::AParseError;
+
+    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D>;
+}
+
 /// Atomic analogue of [`InliningFactory`]/[`InliningObject`].
 pub trait InliningAtomic: AtomicBase + ParseMode<Mode = InliningMode> {
     fn a_extension_error(tail: &[u8]) -> Self::AParseError;
@@ -59,6 +65,16 @@ pub trait InliningAtomic: AtomicBase + ParseMode<Mode = InliningMode> {
     fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D>;
 }
 
+impl<A: AtomicModeParse + ParseMode<Mode = InliningMode>> InliningAtomic for A {
+    fn a_extension_error(tail: &[u8]) -> Self::AParseError {
+        A::ma_extend((), tail)
+    }
+
+    fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+        A::ma_deserialize(inlining)
+    }
+}
+
 /// Atomic analogue of [`ConstSizeFactory`]/[`ConstSizeObject`].
 ///
 /// Note: `FixedSizeAtomic` doesn't exist because it would

src/rstd/inlining/modes.rs

@@ -68,15 +68,15 @@ impl<'a, Ctx: Context<'a>, F: InliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx
     fn pmprepare(_mentionable: Mtbl<'a, Ctx, Self::F>) -> ExtensionSourceM<'a, Ctx, Self::F> {}
 }
 
-impl<A: InliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
+impl<A: QInliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
     type A = A;
 
     fn pma_deserialize<I: Inlining>(inlining: I) -> AParseResultM<Self::A, I> {
-        A::a_ideserialize(inlining)
+        A::qa_ideserialize(inlining)
     }
 
     fn pma_extend(_atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
-        A::a_extension_error(tail)
+        A::qa_extension_error(tail)
     }
 
     fn pma_prepare(_atomic: Self::A) -> AExtensionSourceM<Self::A> {}