From cf5390fbec4b2b9357a5a95f6161fdc7095b2a8c Mon Sep 17 00:00:00 2001
From: timofey <tim@ongoteam.yaconnect.com>
Date: Fri, 28 Jul 2023 21:30:20 +0000
Subject: [PATCH] reorganise atomic bounds

---
 src/rstd/atomic/atomic_object.rs | 22 +++++++++++-----------
 src/rstd/inlining.rs             | 14 ++++++++++----
 2 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/src/rstd/atomic/atomic_object.rs b/src/rstd/atomic/atomic_object.rs
index c45a579..1a9ec47 100644
--- a/src/rstd/atomic/atomic_object.rs
+++ b/src/rstd/atomic/atomic_object.rs
@@ -6,23 +6,23 @@ use super::*;
 
 /// Generic implementation of a [Mentionable] for [Atomic]s.
 #[derive(Clone)]
-pub struct AtomicObject<A: Atomic> {
+pub struct AtomicObject<A: AtomicBase> {
     atomic: A,
 }
 
-impl<A: Atomic> From<A> for AtomicObject<A> {
+impl<A: AtomicBase> From<A> for AtomicObject<A> {
     fn from(value: A) -> Self {
         Self { atomic: value }
     }
 }
 
-impl<A: Atomic> AsRef<A> for AtomicObject<A> {
+impl<A: AtomicBase> AsRef<A> for AtomicObject<A> {
     fn as_ref(&self) -> &A {
         &self.atomic
     }
 }
 
-impl<A: Atomic> Deref for AtomicObject<A> {
+impl<A: AtomicBase> Deref for AtomicObject<A> {
     type Target = A;
 
     fn deref(&self) -> &Self::Target {
@@ -30,7 +30,7 @@ impl<A: Atomic> Deref for AtomicObject<A> {
     }
 }
 
-impl<A: Atomic> Serializable for AtomicObject<A> {
+impl<A: AtomicBase> Serializable for AtomicObject<A> {
     fn serialize(&self, serializer: &mut dyn Serializer) {
         self.atomic.serialize(serializer)
     }
@@ -51,17 +51,17 @@ impl<'a, Ctx: Context<'a>, A: Atomic> Mentionable<'a, Ctx> for AtomicObject<A> {
 }
 
 /// Generic implementation of a [Factory] for [Atomic]s.
-pub struct AtomicFactory<A: Atomic> {
+pub struct AtomicFactory<A> {
     _pd: PhantomData<A>,
 }
 
-impl<A: Atomic> AtomicFactory<A> {
+impl<A> AtomicFactory<A> {
     fn new() -> Self {
         AtomicFactory { _pd: PhantomData }
     }
 }
 
-impl<A: Atomic> Clone for AtomicFactory<A> {
+impl<A: AtomicBase> Clone for AtomicFactory<A> {
     fn clone(&self) -> Self {
         Self::new()
     }
@@ -73,7 +73,7 @@ impl<'a, Ctx: Context<'a>, A: Atomic> FactoryBase<'a, Ctx> for AtomicFactory<A>
     type ParseError = A::AParseError;
 }
 
-impl<A: Atomic> ParseMode for AtomicFactory<A> {
+impl<A> ParseMode for AtomicFactory<A> {
     type Mode = RegularMode;
 }
 
@@ -88,7 +88,7 @@ impl<'a, Ctx: Context<'a>, A: Atomic> RegularFactory<'a, Ctx> for AtomicFactory<
 }
 
 /// Extension trait to provide method-like utilities associated with [AtomicObject]s.
-pub trait AtomicObjectExt: Atomic {
+pub trait AtomicObjectExt: AtomicBase {
     /// Shorthand for getting specific [`AtomicFactory`].
     fn f() -> AtomicFactory<Self> {
         AtomicFactory::new()
@@ -99,4 +99,4 @@ pub trait AtomicObjectExt: Atomic {
     }
 }
 
-impl<A: Atomic> AtomicObjectExt for A {}
+impl<A: AtomicBase> AtomicObjectExt for A {}
diff --git a/src/rstd/inlining.rs b/src/rstd/inlining.rs
index 0e1772e..bfb6e8c 100644
--- a/src/rstd/inlining.rs
+++ b/src/rstd/inlining.rs
@@ -48,7 +48,7 @@ pub trait ConstSizeObject<'a, Ctx: Context<'a>>: FixedSizeObject<'a, Ctx> {
 pub type ADParseResult<A, D> = Result<(A, D), AParseError<A>>;
 
 /// Atomic analogue of [`InlineableFactory`]/[`InlineableObject`].
-pub trait InlineableAtomic: Atomic {
+pub trait InlineableAtomic: AtomicBase {
     fn a_extension_error(tail: &[u8]) -> Self::AParseError;
 
     fn a_ideserialize<D: Inlining>(inlining: D) -> ADParseResult<Self, D>;
@@ -63,7 +63,9 @@ pub trait ConstSizeAtomic: InlineableAtomic {
     const SIZE: usize;
 }
 
-impl<'a, Ctx: Context<'a>, A: InlineableAtomic> InlineableFactory<'a, Ctx> for AtomicFactory<A> {
+impl<'a, Ctx: Context<'a>, A: InlineableAtomic + Atomic> InlineableFactory<'a, Ctx>
+    for AtomicFactory<A>
+{
     fn extension_error(&self, tail: &[u8]) -> Self::ParseError {
         A::a_extension_error(tail)
     }
@@ -74,13 +76,17 @@ impl<'a, Ctx: Context<'a>, A: InlineableAtomic> InlineableFactory<'a, Ctx> for A
     }
 }
 
-impl<'a, Ctx: Context<'a>, A: ConstSizeAtomic> FixedSizeFactory<'a, Ctx> for AtomicFactory<A> {
+impl<'a, Ctx: Context<'a>, A: ConstSizeAtomic + Atomic> FixedSizeFactory<'a, Ctx>
+    for AtomicFactory<A>
+{
     fn size(&self) -> usize {
         A::SIZE
     }
 }
 
-impl<'a, Ctx: Context<'a>, A: ConstSizeAtomic> ConstSizeFactory<'a, Ctx> for AtomicFactory<A> {
+impl<'a, Ctx: Context<'a>, A: ConstSizeAtomic + Atomic> ConstSizeFactory<'a, Ctx>
+    for AtomicFactory<A>
+{
     const SIZE: usize = A::SIZE;
 }