Skip to content

Commit

Permalink
Refactor consumers via macros
Browse files Browse the repository at this point in the history
  • Loading branch information
@AljoschaMeyer
AljoschaMeyer committed Jul 20, 2024
1 parent 4f8bbf4 commit 7ef6d1c
Show file tree
Hide file tree
Showing 11 changed files with 446 additions and 664 deletions.
2 changes: 2 additions & 0 deletions src/common/consumer.rs
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,5 @@
#[macro_use] mod macros;

mod into_slice;
pub use into_slice::IntoSlice_ as IntoSlice;

Expand Down
245 changes: 4 additions & 241 deletions src/common/consumer/into_slice.rs
View file
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
use core::convert::{AsMut, AsRef};
use core::fmt::Debug;
use core::mem::MaybeUninit;

use wrapper::Wrapper;
Expand All @@ -11,218 +12,11 @@ use crate::local_nb::{
use crate::maybe_uninit_slice_mut;
use crate::sync::{BufferedConsumer, BulkConsumer, Consumer};

// Macro syntax for handling generic parameters: https://stackoverflow.com/a/61189128

macro_rules! invarianted_consumer_outer_type {
($(#[$doc:meta])* $outer:ident $inner:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? ) => {
$(#[$doc])*
pub struct $outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?(crate::common::consumer::Invariant<$inner $(< $( $lt ),+ >)?>);
}
}

macro_rules! invarianted_consumer_impl_debug {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? ) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
core::fmt::Debug
for $outer
$(< $( $lt ),+ >)?
{
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
self.0.fmt(f)
}
}
}
}

macro_rules! invarianted_consumer_impl_as_ref {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?; $t:ty) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
core::convert::AsRef<$t>
for $outer
$(< $( $lt ),+ >)?
{
fn as_ref(&self) -> &$t {
self.0.as_ref().as_ref()
}
}
}
}

macro_rules! invarianted_consumer_impl_as_mut {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?; $t:ty) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
core::convert::AsMut<$t>
for $outer
$(< $( $lt ),+ >)?
{
fn as_mut(&mut self) -> &mut $t {
self.0.as_mut().as_mut()
}
}
}
}

macro_rules! invarianted_consumer_impl_wrapper {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?; $t:ty) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
wrapper::Wrapper<$t>
for $outer
$(< $( $lt ),+ >)?
{
fn into_inner(self) -> $t {
self.0.into_inner().into_inner()
}
}
}
}

macro_rules! invarianted_consumer_impl_consumer {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $(#[$doc_item:meta])? Item $t_item:ty; $(#[$doc_final:meta])? Final $t_final:ty; $(#[$doc_error:meta])? Error $t_error:ty) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::sync::Consumer
for $outer
$(< $( $lt ),+ >)?
{
$(#[$doc_item])*
type Item = $t_item;
$(#[$doc_final])*
type Final = $t_final;
$(#[$doc_error])*
type Error = $t_error;

fn consume(&mut self, item: T) -> Result<(), Self::Error> {
Consumer::consume(&mut self.0, item)
}

fn close(&mut self, fin: Self::Final) -> Result<(), Self::Error> {
Consumer::close(&mut self.0, fin)
}
}
}
}

macro_rules! invarianted_consumer_impl_buffered_consumer {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::sync::BufferedConsumer
for $outer
$(< $( $lt ),+ >)?
{
fn flush(&mut self) -> Result<(), Self::Error> {
BufferedConsumer::flush(&mut self.0)
}
}
}
}

macro_rules! invarianted_consumer_impl_bulk_consumer {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::sync::BulkConsumer
for $outer
$(< $( $lt ),+ >)?
{
fn expose_slots(&mut self) -> Result<&mut [MaybeUninit<Self::Item>], Self::Error> {
BulkConsumer::expose_slots(&mut self.0)
}

unsafe fn consume_slots(&mut self, amount: usize) -> Result<(), Self::Error> {
BulkConsumer::consume_slots(&mut self.0, amount)
}
}
}
}

macro_rules! invarianted_consumer_impl_consumer_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $(#[$doc_item:meta])? Item $t_item:ty; $(#[$doc_final:meta])? Final $t_final:ty; $(#[$doc_error:meta])? Error $t_error:ty) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::local_nb::Consumer
for $outer
$(< $( $lt ),+ >)?
{
$(#[$doc_item])*
type Item = $t_item;
$(#[$doc_final])*
type Final = $t_final;
$(#[$doc_error])*
type Error = $t_error;

async fn consume(&mut self, item: Self::Item) -> Result<(), Self::Error> {
ConsumerLocalNb::consume(&mut self.0, item).await
}

async fn close(&mut self, f: Self::Final) -> Result<(), Self::Error> {
ConsumerLocalNb::close(&mut self.0, f).await
}
}
}
}

macro_rules! invarianted_consumer_impl_buffered_consumer_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::local_nb::BufferedConsumer
for $outer
$(< $( $lt ),+ >)?
{
async fn flush(&mut self) -> Result<(), Self::Error> {
BufferedConsumerLocalNb::flush(&mut self.0).await
}
}
}
}

macro_rules! invarianted_consumer_impl_bulk_consumer_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
crate::local_nb::BulkConsumer
for $outer
$(< $( $lt ),+ >)?
{
async fn expose_slots<'b>(
&'b mut self,
) -> Result<&'b mut [MaybeUninit<Self::Item>], Self::Error>
where
Self::Item: 'b,
{
BulkConsumerLocalNb::expose_slots(&mut self.0).await
}

async unsafe fn consume_slots(&mut self, amount: usize) -> Result<(), Self::Error> {
BulkConsumerLocalNb::consume_slots(&mut self.0, amount).await
}
}
}
}

macro_rules! invarianted_consumer_impl_consumer_sync_and_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? $(#[$doc_item:meta])? Item $t_item:ty; $(#[$doc_final:meta])? Final $t_final:ty; $(#[$doc_error:meta])? Error $t_error:ty) => {
invarianted_consumer_impl_consumer!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $(#[$doc_item])? Item $t_item; $(#[$doc_final])? Final $t_final; $(#[$doc_error])? Error $t_error);
invarianted_consumer_impl_consumer_local_nb!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $(#[$doc_item])? Item $t_item; $(#[$doc_final])? Final $t_final; $(#[$doc_error])? Error $t_error);
}
}

macro_rules! invarianted_consumer_impl_buffered_consumer_sync_and_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
invarianted_consumer_impl_buffered_consumer!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?);
invarianted_consumer_impl_buffered_consumer_local_nb!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?);
}
}

macro_rules! invarianted_consumer_impl_bulk_consumer_sync_and_local_nb {
($outer:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)?) => {
invarianted_consumer_impl_bulk_consumer!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?);
invarianted_consumer_impl_bulk_consumer_local_nb!($outer $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?);
}
}


invarianted_consumer_outer_type!(
/// Consumes data into a mutable slice.
IntoSlice_ IntoSlice <'a, T>
);

use core::fmt::Debug;
invarianted_consumer_impl_debug!(IntoSlice_<'a, T: Debug>);

invarianted_consumer_impl_as_ref!(IntoSlice_<'a, T>; [T]);
Expand Down Expand Up @@ -337,40 +131,9 @@ impl<'a, T: Copy> BulkConsumer for IntoSlice<'a, T> {
}
}

impl<'a, T> ConsumerLocalNb for IntoSlice<'a, T> {
type Item = T;
type Final = ();
type Error = ();

async fn consume(&mut self, item: Self::Item) -> Result<(), Self::Error> {
Consumer::consume(self, item)
}

async fn close(&mut self, f: Self::Final) -> Result<(), Self::Error> {
Consumer::close(self, f)
}
}

impl<'a, T> BufferedConsumerLocalNb for IntoSlice<'a, T> {
async fn flush(&mut self) -> Result<(), Self::Error> {
BufferedConsumer::flush(self)
}
}

impl<'a, T: Copy> BulkConsumerLocalNb for IntoSlice<'a, T> {
async fn expose_slots<'b>(
&'b mut self,
) -> Result<&'b mut [MaybeUninit<Self::Item>], Self::Error>
where
Self::Item: 'b,
{
BulkConsumer::expose_slots(self)
}

async unsafe fn consume_slots(&mut self, amount: usize) -> Result<(), Self::Error> {
BulkConsumer::consume_slots(self, amount)
}
}
sync_consumer_as_local_nb!(IntoSlice<'a, T>);
sync_buffered_consumer_as_local_nb!(IntoSlice<'a, T>);
sync_bulk_consumer_as_local_nb!(IntoSlice<'a, T: Copy>);

// #[cfg(test)]
// mod tests {
Expand Down
Loading

0 comments on commit 7ef6d1c

Please sign in to comment.