From 451dc8595896d5617a4134daf05b5b477723ceb6 Mon Sep 17 00:00:00 2001 From: Alexey Gerasev Date: Thu, 17 Aug 2023 14:04:41 +0700 Subject: [PATCH] Remove Delegate --- src/halves/direct.rs | 77 +++++++++++++++++++++++++++------------ src/traits/consumer.rs | 77 +-------------------------------------- src/traits/observer.rs | 54 --------------------------- src/traits/producer.rs | 53 +-------------------------- src/traits/ring_buffer.rs | 35 +----------------- 5 files changed, 56 insertions(+), 240 deletions(-) diff --git a/src/halves/direct.rs b/src/halves/direct.rs index 91cc2bc..908a015 100644 --- a/src/halves/direct.rs +++ b/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 ToRbRef for Cons { } } -impl DelegateObserver for Obs { - type Delegate = R::Target; - fn delegate(&self) -> &Self::Delegate { - self.rb.deref() +impl Observer for Obs { + type Item = ::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], &mut [core::mem::MaybeUninit]) { + self.rb().unsafe_slices(start, end) } } -impl DelegateObserver for Prod { - type Delegate = R::Target; - fn delegate(&self) -> &Self::Delegate { - self.rb.deref() +impl Observer for Prod { + type Item = ::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], &mut [core::mem::MaybeUninit]) { + self.rb().unsafe_slices(start, end) } } -impl DelegateObserver for Cons { - type Delegate = R::Target; - fn delegate(&self) -> &Self::Delegate { - self.rb.deref() +impl Observer for Cons { + type Item = ::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], &mut [core::mem::MaybeUninit]) { + self.rb().unsafe_slices(start, end) } } diff --git a/src/traits/consumer.rs b/src/traits/consumer.rs index 35e3af9..a809789 100644 --- a/src/traits/consumer.rs +++ b/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, /// *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>>; - -pub trait DelegateConsumer: DelegateObserver -where - Self::Delegate: Consumer, -{ -} -impl 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], &[core::mem::MaybeUninit]) { - self.delegate().occupied_slices() - } - - #[inline] - unsafe fn occupied_slices_mut(&mut self) -> (&mut [core::mem::MaybeUninit], &mut [core::mem::MaybeUninit]) { - 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.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() - } -} diff --git a/src/traits/observer.rs b/src/traits/observer.rs index 7bc0f9f..18723e7 100644 --- a/src/traits/observer.rs +++ b/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 Observer for D { - type Item = ::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], &mut [core::mem::MaybeUninit]) { - 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; diff --git a/src/traits/producer.rs b/src/traits/producer.rs index 770d251..6458873 100644 --- a/src/traits/producer.rs +++ b/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 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], &[core::mem::MaybeUninit]) { - self.delegate().vacant_slices() - } - - #[inline] - fn vacant_slices_mut(&mut self) -> (&mut [core::mem::MaybeUninit], &mut [core::mem::MaybeUninit]) { - 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>(&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) - } -} diff --git a/src/traits/ring_buffer.rs b/src/traits/ring_buffer.rs index aaf729c..aac9f74 100644 --- a/src/traits/ring_buffer.rs +++ b/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 RingBuffer for D -where - D::Delegate: RingBuffer, -{ - #[inline] - fn push_overwrite(&mut self, elem: Self::Item) -> Option { - self.delegate_mut().push_overwrite(elem) - } - - #[inline] - fn push_iter_overwrite>(&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) - } -}