QInliningAtomic -> CInliningAtomic

src/rstd/atomic/array.rs

@@ -42,12 +42,12 @@ impl<const N: usize> ImplMode for [u8; N] {
     type Mode = InliningMode;
 }
 
-impl<const N: usize> QInliningAtomic for [u8; N] {
-    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
+impl<const N: usize> CInliningAtomic for [u8; N] {
+    fn ca_extension_error(tail: &[u8]) -> Self::AParseError {
         ArrayParseError::ExtraData(tail.len())
     }
 
-    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn ca_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 QInliningAtomic for u64 {
-    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
+impl CInliningAtomic for u64 {
+    fn ca_extension_error(tail: &[u8]) -> Self::AParseError {
         IntParseError::ExtraData(tail.len())
     }
 
-    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn ca_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 QInliningAtomic for bool {
-    fn qa_extension_error(tail: &[u8]) -> Self::AParseError {
+impl CInliningAtomic for bool {
+    fn ca_extension_error(tail: &[u8]) -> Self::AParseError {
         BooleanParseError::ExtraData(tail.len())
     }
 
-    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D> {
+    fn ca_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

@@ -72,10 +72,10 @@ 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;
+pub trait CInliningAtomic: AtomicBase + ImplMode<Mode = InliningMode> {
+    fn ca_extension_error(tail: &[u8]) -> Self::AParseError;
 
-    fn qa_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D>;
+    fn ca_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D>;
 }
 
 /// Atomic analogue of [`InliningFactory`]/[`InliningObject`].

src/rstd/inlining/modes.rs

@@ -84,14 +84,14 @@ impl<'a, Ctx: Context<'a>, F: CInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ct
     }
 }
 
-impl<A: QInliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
+impl<A: CInliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
     type A = A;
 
     fn pma_deserialize<I: Inlining>(inlining: I) -> AModeResultM<Self::A, I> {
-        A::qa_ideserialize(inlining)
+        A::ca_ideserialize(inlining)
     }
 
     fn pma_extend(_atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
-        A::qa_extension_error(tail)
+        A::ca_extension_error(tail)
     }
 }