Remove Delegate

src/halves/direct.rs

@@ -1,12 +1,8 @@
 use crate::{
  rb::traits::{RbRef, ToRbRef},
- traits::{
- consumer::Consumer,
- observer::{DelegateObserver, Observe},
- producer::Producer,
- },
+ traits::{consumer::Consumer, observer::Observe, producer::Producer, Observer},
 };
-use core::fmt;
+use core::{fmt, mem::MaybeUninit, num::NonZeroUsize};
 #[cfg(feature = "std")]
 use std::io;
 
@@ -73,33 +69,66 @@ impl<R: RbRef> ToRbRef for Cons<R> {
  }
 }
 
-impl<R: RbRef> DelegateObserver for Obs<R> {
- type Delegate = R::Target;
- fn delegate(&self) -> &Self::Delegate {
- self.rb.deref()
+impl<R: RbRef> Observer for Obs<R> {
+ type Item = <R::Target as Observer>::Item;
+
+ #[inline]
+ fn capacity(&self) -> NonZeroUsize {
+ self.rb().capacity()
+ }
+ #[inline]
+ fn read_index(&self) -> usize {
+ self.rb().read_index()
  }
- fn delegate_mut(&mut self) -> &mut Self::Delegate {
- unreachable!()
+ #[inline]
+ fn write_index(&self) -> usize {
+ self.rb().write_index()
+ }
+ #[inline]
+ unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
+ self.rb().unsafe_slices(start, end)
  }
 }
 
-impl<R: RbRef> DelegateObserver for Prod<R> {
- type Delegate = R::Target;
- fn delegate(&self) -> &Self::Delegate {
- self.rb.deref()
+impl<R: RbRef> Observer for Prod<R> {
+ type Item = <R::Target as Observer>::Item;
+
+ #[inline]
+ fn capacity(&self) -> NonZeroUsize {
+ self.rb().capacity()
  }
- fn delegate_mut(&mut self) -> &mut Self::Delegate {
- unreachable!()
+ #[inline]
+ fn read_index(&self) -> usize {
+ self.rb().read_index()
+ }
+ #[inline]
+ fn write_index(&self) -> usize {
+ self.rb().write_index()
+ }
+ #[inline]
+ unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
+ self.rb().unsafe_slices(start, end)
  }
 }
 
-impl<R: RbRef> DelegateObserver for Cons<R> {
- type Delegate = R::Target;
- fn delegate(&self) -> &Self::Delegate {
- self.rb.deref()
+impl<R: RbRef> Observer for Cons<R> {
+ type Item = <R::Target as Observer>::Item;
+
+ #[inline]
+ fn capacity(&self) -> NonZeroUsize {
+ self.rb().capacity()
  }
- fn delegate_mut(&mut self) -> &mut Self::Delegate {
- unreachable!()
+ #[inline]
+ fn read_index(&self) -> usize {
+ self.rb().read_index()
+ }
+ #[inline]
+ fn write_index(&self) -> usize {
+ self.rb().write_index()
+ }
+ #[inline]
+ unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
+ self.rb().unsafe_slices(start, end)
  }
 }
 

src/traits/consumer.rs

@@ -1,7 +1,4 @@
-use super::{
- observer::{DelegateObserver, Observer},
- utils::modulus,
-};
+use super::{observer::Observer, utils::modulus};
 use crate::utils::{slice_assume_init_mut, slice_assume_init_ref, write_uninit_slice};
 use core::{iter::Chain, mem::MaybeUninit, ptr, slice};
 #[cfg(feature = "std")]
@@ -299,75 +296,3 @@ pub type Iter<'a, C: Consumer> = Chain<slice::Iter<'a, C::Item>, slice::Iter<'a,
 /// *Please do not rely on actual type, it may change in future.*
 #[allow(type_alias_bounds)]
 pub type IterMut<'a, C: Consumer> = Chain<slice::IterMut<'a, C::Item>, slice::IterMut<'a, C::Item>>;
-
-pub trait DelegateConsumer: DelegateObserver
-where
- Self::Delegate: Consumer,
-{
-}
-impl<D: DelegateConsumer> Consumer for D
-where
- D::Delegate: Consumer,
-{
- #[inline]
- unsafe fn set_read_index(&self, value: usize) {
- self.delegate().set_read_index(value)
- }
- #[inline]
- unsafe fn advance_read_index(&self, count: usize) {
- self.delegate().advance_read_index(count)
- }
-
- #[inline]
- fn occupied_slices(&self) -> (&[core::mem::MaybeUninit<Self::Item>], &[core::mem::MaybeUninit<Self::Item>]) {
- self.delegate().occupied_slices()
- }
-
- #[inline]
- unsafe fn occupied_slices_mut(&mut self) -> (&mut [core::mem::MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
- self.delegate_mut().occupied_slices_mut()
- }
-
- #[inline]
- fn as_slices(&self) -> (&[Self::Item], &[Self::Item]) {
- self.delegate().as_slices()
- }
-
- #[inline]
- fn as_mut_slices(&mut self) -> (&mut [Self::Item], &mut [Self::Item]) {
- self.delegate_mut().as_mut_slices()
- }
-
- #[inline]
- fn try_pop(&mut self) -> Option<Self::Item> {
- self.delegate_mut().try_pop()
- }
-
- #[inline]
- fn pop_slice(&mut self, elems: &mut [Self::Item]) -> usize
- where
- Self::Item: Copy,
- {
- self.delegate_mut().pop_slice(elems)
- }
-
- #[inline]
- fn iter(&self) -> Iter<'_, Self> {
- self.delegate().iter()
- }
-
- #[inline]
- fn iter_mut(&mut self) -> IterMut<'_, Self> {
- self.delegate_mut().iter_mut()
- }
-
- #[inline]
- fn skip(&mut self, count: usize) -> usize {
- self.delegate_mut().skip(count)
- }
-
- #[inline]
- fn clear(&mut self) -> usize {
- self.delegate_mut().clear()
- }
-}

src/traits/observer.rs

@@ -47,60 +47,6 @@ pub trait Observer: Sized {
  }
 }
 
-pub trait DelegateObserver {
- type Delegate: Observer;
-
- fn delegate(&self) -> &Self::Delegate;
- fn delegate_mut(&mut self) -> &mut Self::Delegate;
-}
-
-impl<D: DelegateObserver> Observer for D {
- type Item = <D::Delegate as Observer>::Item;
-
- #[inline]
- fn capacity(&self) -> core::num::NonZeroUsize {
- self.delegate().capacity()
- }
-
- #[inline]
- fn read_index(&self) -> usize {
- self.delegate().read_index()
- }
- #[inline]
- fn write_index(&self) -> usize {
- self.delegate().write_index()
- }
-
- #[inline]
- unsafe fn unsafe_slices(
- &self,
- start: usize,
- end: usize,
- ) -> (&mut [core::mem::MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
- self.delegate().unsafe_slices(start, end)
- }
-
- #[inline]
- fn occupied_len(&self) -> usize {
- self.delegate().occupied_len()
- }
-
- #[inline]
- fn vacant_len(&self) -> usize {
- self.delegate().vacant_len()
- }
-
- #[inline]
- fn is_empty(&self) -> bool {
- self.delegate().is_empty()
- }
-
- #[inline]
- fn is_full(&self) -> bool {
- self.delegate().is_full()
- }
-}
-
 pub trait Observe {
  type Obs: Observer;
  fn observe(&self) -> Self::Obs;

src/traits/producer.rs

@@ -1,7 +1,4 @@
-use super::{
- observer::{DelegateObserver, Observer},
- utils::modulus,
-};
+use super::{observer::Observer, utils::modulus};
 #[cfg(feature = "std")]
 use crate::utils::slice_assume_init_mut;
 use crate::utils::write_slice;
@@ -157,51 +154,3 @@ pub trait Producer: Observer {
  }
  }
 }
-
-pub trait DelegateProducer: DelegateObserver
-where
- Self::Delegate: Producer,
-{
-}
-
-impl<D: DelegateProducer> Producer for D
-where
- D::Delegate: Producer,
-{
- #[inline]
- unsafe fn set_write_index(&self, value: usize) {
- self.delegate().set_write_index(value)
- }
- #[inline]
- unsafe fn advance_write_index(&self, count: usize) {
- self.delegate().advance_write_index(count)
- }
-
- #[inline]
- fn vacant_slices(&self) -> (&[core::mem::MaybeUninit<Self::Item>], &[core::mem::MaybeUninit<Self::Item>]) {
- self.delegate().vacant_slices()
- }
-
- #[inline]
- fn vacant_slices_mut(&mut self) -> (&mut [core::mem::MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
- self.delegate_mut().vacant_slices_mut()
- }
-
- #[inline]
- fn try_push(&mut self, elem: Self::Item) -> Result<(), Self::Item> {
- self.delegate_mut().try_push(elem)
- }
-
- #[inline]
- fn push_iter<I: Iterator<Item = Self::Item>>(&mut self, iter: I) -> usize {
- self.delegate_mut().push_iter(iter)
- }
-
- #[inline]
- fn push_slice(&mut self, elems: &[Self::Item]) -> usize
- where
- Self::Item: Copy,
- {
- self.delegate_mut().push_slice(elems)
- }
-}

src/traits/ring_buffer.rs

@@ -1,8 +1,4 @@
-use super::{
- consumer::{Consumer, DelegateConsumer},
- producer::{DelegateProducer, Producer},
- Observer,
-};
+use super::{consumer::Consumer, producer::Producer, Observer};
 
 /// An abstract ring buffer.
 ///
@@ -53,32 +49,3 @@ pub trait RingBuffer: Observer + Consumer + Producer {
  });
  }
 }
-
-pub trait DelegateRingBuffer: DelegateProducer + DelegateConsumer
-where
- Self::Delegate: RingBuffer,
-{
-}
-
-impl<D: DelegateRingBuffer> RingBuffer for D
-where
- D::Delegate: RingBuffer,
-{
- #[inline]
- fn push_overwrite(&mut self, elem: Self::Item) -> Option<Self::Item> {
- self.delegate_mut().push_overwrite(elem)
- }
-
- #[inline]
- fn push_iter_overwrite<I: Iterator<Item = Self::Item>>(&mut self, iter: I) {
- self.delegate_mut().push_iter_overwrite(iter)
- }
-
- #[inline]
- fn push_slice_overwrite(&mut self, elems: &[Self::Item])
- where
- Self::Item: Copy,
- {
- self.delegate_mut().push_slice_overwrite(elems)
- }
-}