Struct FullSync

pub struct FullSync<'a, ItemType: Send + Sync + Debug + Default, const BUFFER_SIZE: usize = 1024, const MAX_STREAMS: usize = 16> { /* private fields */ }

This channel uses the queues FullSyncMove (the highest throughput among all in ‘benches/’), which are the fastest for general purpose use and for most hardware but requires that elements are copied when dequeueing, due to the full sync characteristics of the backing queue, which doesn’t allow enqueueing to happen independently of dequeueing.
Due to that, this channel requires that ItemTypes are Clone, since they will have to be moved around during dequeueing (as there is no way to keep the queue slot allocated during processing), making this channel a typical best fit for small & trivial types.
Please, measure your Multis using all available channels FullSync, [OgreAtomicQueue] and, possibly, even [OgreMmapLog].
See also [multi::channels::ogre_full_sync_mpmc_queue].
Refresher: the backing queue requires BUFFER_SIZE to be a power of 2 – the same applies to MAX_STREAMS, which will also have its own queue

Trait Implementations

impl<'a, ItemType: Send + Sync + Debug + Default + 'a, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelCommon<ItemType, Arc<ItemType>> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn new<IntoString: Into<String>>(streams_manager_name: IntoString) -> Arc<Self>

Creates a new instance of this channel, to be referred to (in logs) as name

async fn flush(&self, timeout: Duration) -> u32

Waits until all pending items are taken from this channel, up until timeout elapses.
Returns the number of still unconsumed items – which is 0 if it was not interrupted by the timeout

fn is_channel_open(&self) -> bool

Tells weather this channel is still enabled to process elements (true before calling the “end stream” / “cancel stream” functions)

async fn gracefully_end_stream(&self, stream_id: u32, timeout: Duration) -> bool

Flushes & signals that the given stream_id should cease its activities when there are no more elements left to process, waiting for the operation to complete for up to timeout.
Returns true if the stream ended within the given timeout or false if it is still processing elements.

async fn gracefully_end_all_streams(&self, timeout: Duration) -> u32

Flushes & signals that all streams should cease their activities when there are no more elements left to process, waiting for the operation to complete for up to timeout.
Returns the number of un-ended streams – which is 0 if it was not interrupted by the timeout

fn cancel_all_streams(&self)

Sends a signal to all streams, urging them to cease their operations.
In opposition to [end_all_streams()], this method does not wait for any confirmation, nor cares if there are remaining elements to be processed.

fn running_streams_count(&self) -> u32

Informs the caller how many active streams are currently managed by this channel IMPLEMENTORS: #[inline(always)]

fn pending_items_count(&self) -> u32

Tells how many events are waiting to be taken out of this channel.
IMPLEMENTORS: #[inline(always)]

fn buffer_size(&self) -> u32

Tells how many events may be produced ahead of the consumers.
IMPLEMENTORS: #[inline(always)]

impl<'a, ItemType: 'a + Send + Sync + Debug + Default, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelConsumer<'a, Arc<ItemType>> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn consume(&self, stream_id: u32) -> Option<Arc<ItemType>>

Delivers the next event, whenever the Stream wants it.
IMPLEMENTORS: use #[inline(always)]

fn keep_stream_running(&self, stream_id: u32) -> bool

Returns false if the Stream has been signaled to end its operations, causing it to report “out-of-elements” as soon as possible.
IMPLEMENTORS: use #[inline(always)]

fn register_stream_waker(&self, stream_id: u32, waker: &Waker)

Shares, to implementors concern, how stream_id may be awaken.
IMPLEMENTORS: use #[inline(always)]

fn drop_resources(&self, stream_id: u32)

Reports no more elements will be required through [provide()].
IMPLEMENTORS: use #[inline(always)]

impl<'a, ItemType: Send + Sync + Debug + Default + 'a, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelMulti<'a, ItemType, Arc<ItemType>> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn create_stream_for_old_events( self: &Arc<Self>, ) -> (MutinyStream<'a, ItemType, Self, Arc<ItemType>>, u32)

where Self: ChannelConsumer<'a, Arc<ItemType>>,

Implemented only for a few [Multi] channels, returns a Stream (and its stream_id) able to receive elements that were sent through this channel before the call to this method.
It is up to each implementor to define how back in the past those events may go, but it is known that mmap log based channels are able to see all past events.
If called more than once, every stream will see all the past events available.
Currently panics if called more times than allowed by [Multi]’s MAX_STREAMS

fn create_stream_for_new_events( self: &Arc<Self>, ) -> (MutinyStream<'a, ItemType, Self, Arc<ItemType>>, u32)

Returns a Stream (and its stream_id) able to receive elements sent through this channel after the call to this method.
If called more than once, each Stream will see all new elements – “listener pattern”.
Currently panics if called more times than allowed by [Multi]’s MAX_STREAMS

fn create_streams_for_old_and_new_events( self: &Arc<Self>, ) -> ((MutinyStream<'a, ItemType, Self, Arc<ItemType>>, u32), (MutinyStream<'a, ItemType, Self, Arc<ItemType>>, u32))

where Self: ChannelConsumer<'a, Arc<ItemType>>,

Implemented only for a few [Multi] channels, returns two Streams (and their stream_ids):

fn create_stream_for_old_and_new_events( self: &Arc<Self>, ) -> (MutinyStream<'a, ItemType, Self, Arc<ItemType>>, u32)

where Self: ChannelConsumer<'a, Arc<ItemType>>,

Implemented only for a few [Multi] channels, returns a single Stream (and its stream_id) able to receive elements that were sent through this channel either before and after the call to this method.
It is up to each implementor to define how back in the past those events may go, but it is known that mmap log based channels are able to see all past events.
Notice that, with this method, there is no way of discriminating where the “old” events end and where the “new” events start.
If called more than once, every stream will see all the past events available, as well as all future events after this method call.
Currently panics if called more times than allowed by [Multi]’s MAX_STREAMS

impl<'a, ItemType: 'a + Send + Sync + Debug + Default, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelProducer<'a, ItemType, Arc<ItemType>> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn send(&self, item: ItemType) -> RetryConsumerResult<(), ItemType, ()>

Similar to Self::send_with(), but for sending the already-built item.
See there for how to deal with the returned type.
IMPLEMENTORS: #[inline(always)]

fn send_with<F: FnOnce(&mut ItemType)>( &self, setter: F, ) -> RetryConsumerResult<(), F, ()>

Calls setter, passing a slot so the payload may be filled there, then sends the event through this channel asynchronously.
The returned type is conversible to Result<(), F> by calling .into() on it, returning Err<setter> when the buffer is full, to allow the caller to try again; otherwise you may add any retrying logic using the keen-retry crate’s API like in:

async fn send_with_async<F: FnOnce(&'a mut ItemType) -> Fut, Fut: Future<Output = &'a mut ItemType>>( &'a self, setter: F, ) -> RetryConsumerResult<(), F, ()>

Similar to [Self::send_with(), but accepts an async setter. This method is useful for sending operations that depend on data acquired by async blocks, allowing select loops (like the following) to be built:

fn send_derived(&self, arc_item: &Arc<ItemType>) -> bool

For channels that stores the DerivedItemType instead of the ItemType, this method may be useful – for instance: if the Stream consumes OgreArc<Type> (the derived item type) and the channel is for Type, with this method one may send an OgreArc directly.
IMPLEMENTORS: #[inline(always)]

fn reserve_slot(&self) -> Option<&'a mut ItemType>

Proxy to crate::prelude::advanced::BoundedOgreAllocator::alloc_ref() from the underlying allocator, allowing caller to fill in the data as they wish – in a non-blocking prone API.
See also [Self::send_reserved()] and [Self::cancel_slot_reserve()].

fn try_send_reserved(&self, _reserved_slot: &mut ItemType) -> bool

Attempts to send an item previously reserved by Self::reserve_slot(). Failure to do so (when false is returned) might be part of the normal channel operation, so retrying is advised. More: some channel implementations are optimized (or even only accept) sending the slots in the same order they were reserved.

fn try_cancel_slot_reserve(&self, _reserved_slot: &mut ItemType) -> bool

Attempts to give up sending an item previously reserved by Self::reserve_slot(), freeing it / setting its resources for reuse. Two important things to note:

impl<'a, ItemType: Send + Sync + Debug + Default + 'a, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> Drop for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn drop(&mut self)

Executes the destructor for this type.

impl<ItemType: 'static + Debug + Send + Sync + Default, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> FullDuplexMultiChannel for FullSync<'static, ItemType, BUFFER_SIZE, MAX_STREAMS>

const MAX_STREAMS: usize = MAX_STREAMS

const BUFFER_SIZE: usize = BUFFER_SIZE

type ItemType = ItemType

type DerivedItemType = Arc<ItemType>