oneringbuf 0.7.0

A lock-free single-producer, single-consumer (SPSC) ring buffer with in-place mutability, asynchronous support, and virtual memory optimisation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Module containing sync and async iterators.

pub mod async_iterators;
mod iterator_trait;
pub(crate) mod sync_iterators;

#[cfg(any(feature = "async", doc))]
pub use async_iterators::{
    cons_iter::AsyncConsIter, detached::AsyncDetached, prod_iter::AsyncProdIter,
    work_iter::AsyncWorkIter,
};

pub use sync_iterators::{
    cons_iter::ConsIter, detached::Detached, prod_iter::ProdIter, work_iter::WorkIter,
};

use core::ptr;
pub use iterator_trait::ORBIterator;

pub(crate) use iterator_trait::iter_macros::*;

#[inline]
pub(crate) fn copy_from_slice_unchecked<T: Copy>(src: &[T], dst: &mut [T]) {
    unsafe {
        ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), src.len());
    }
}

pub(crate) mod util_macros {
    macro_rules! muncher {
        (,) => { , };
        (&mut $T:ident $(,$tail:tt)*) => { &mut $T, muncher!($($tail)*) };
        (&$T:ident $(,$tail:tt)*) => { &$T, muncher!($($tail)*) };
        (&mut $T:tt $(,$tail:tt)*) => { &mut $T, muncher!($($tail)*) };
        (&$T:tt $(,$tail:tt)*) => { &$T, muncher!($($tail)*) };
        ($T:ty) => { $T };
        ($T:tt<$($gen: tt)*> $(,$tail:tt)*) => { $T<$($gen)*>, muncher!($($tail)*) };
    }

    macro_rules! delegate {
        ($Inner: tt $(($inline: tt))?, $v: vis fn $fn_name: ident $(<$lt: lifetime>)? (&$($lt_self: lifetime)? self$(, $arg: ident $(: $arg_t: ty)?)*)
        $(-> $($ret_g: tt)*)?) => {
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            $(#[$inline])?
            $v fn $fn_name $(<$lt>)? (& $($lt_self)? self$(, $arg $(: $arg_t)?)*) $(-> muncher!{ $($ret_g)* })? {
                self.inner().$fn_name($($arg)*)
            }
        };
        ($Inner: tt $(($inline: tt))?, $v: vis unsafe fn $fn_name: ident $(<$lt: lifetime>)? (&$($lt_self: lifetime)? self$(, $arg: ident $(: $arg_t: ty)?)*)
        $(-> $($ret_g: tt)*)?) => {
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            /// # Safety
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            $(#[$inline])?
            $v unsafe fn $fn_name $(<$lt>)? (& $($lt_self)? self$(, $arg $(: $arg_t)?)*) $(-> muncher!{ $($ret_g)* })? {
                self.inner().$fn_name($($arg)*)
            }
        };

        ($Inner: tt $(($inline: tt))?, $v: vis fn $fn_name: ident $(<$lt: lifetime>)? (&$($lt_self: lifetime)? $(($m: tt))? self $(, $arg: ident $(: $arg_t: ty)?)*)
        $(-> $($ret_g: tt)*)?) => {
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            $(#[$inline])?
            $v fn $fn_name $(<$lt>)? (& $($lt_self)? $($m)? self$(, $arg $(: $arg_t)?)*) $(-> muncher!{ $($ret_g)* })? {
                self.inner_mut().$fn_name($($arg)*)
            }
        };
        ($Inner: tt $(($inline: tt))?, $v: vis unsafe fn $fn_name: ident $(<$lt: lifetime>)? (&$($lt_self: lifetime)? $(($m: tt))? self $(, $arg: ident $(: $arg_t: ty)?)*)
        $(-> $($ret_g: tt)*)?) => {
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            /// # Safety
            #[doc = concat!("Same as [`", stringify!($Inner), "::", stringify!($fn_name), "`].")]
            $(#[$inline])?
            $v unsafe fn $fn_name $(<$lt>)? (& $($lt_self)? $($m)? self$(, $arg $(: $arg_t)?)*) $(-> muncher!{ $($ret_g)* })? {
                unsafe { self.inner_mut().$fn_name($($arg)*) }
            }
        };
    }

    pub(crate) use {delegate, muncher};
}