Struct reactive_mutiny::uni::channels::movable::full_sync::FullSync

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

This channel uses the fastest of the queues FullSyncMove, which are the fastest for general purpose use and for most hardware but requires that elements are copied, 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 Unis using all available channels FullSync, [OgreAtomicQueue] and, possibly, even [OgreMmapLog].
See also [uni::channels::ogre_full_sync_mpmc_queue].
Refresher: the backing queue requires “BUFFER_SIZE” to be a power of 2

Trait Implementations

impl<'a, ItemType: Send + Sync + Debug + 'a, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelCommon<'a, ItemType, 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

fn flush<'life0, 'async_trait>( &'life0 self, timeout: Duration ) -> Pin<Box<dyn Future<Output = u32> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

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 gracefully_end_stream<'life0, 'async_trait>( &'life0 self, stream_id: u32, timeout: Duration ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

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.

fn gracefully_end_all_streams<'life0, 'async_trait>( &'life0 self, timeout: Duration ) -> Pin<Box<dyn Future<Output = u32> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

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 + Debug + Send + Sync, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelConsumer<'a, ItemType> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn consume(&self, _stream_id: u32) -> Option<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 + 'a, const BUFFER_SIZE: usize, const MAX_STREAMS: usize> ChannelProducer<'a, ItemType, ItemType> for FullSync<'a, ItemType, BUFFER_SIZE, MAX_STREAMS>

fn try_send<F: FnOnce(&mut ItemType)>(&self, setter: F) -> bool

Calls setter, passing a slot so the payload may be filled, then sends the event through this channel asynchronously.
– returns false if the buffer was full and the item wasn’t sent; true otherwise.
IMPLEMENTORS: #[inline(always)]

fn try_send_movable(&self, item: ItemType) -> bool

Similar to [try_send()], but accepts the penalty that the compiler may impose of copying / moving the data around, in opposition to set it only once, in its resting place – useful to send cloned items and other objects with a custom drop IMPLEMENTORS: #[inline(always)] TODO 2023-05-17: consider restricting this entry for types that require dropping, and the zero-copy versions for those who don’t

fn send<F: FnOnce(&mut ItemType)>(&self, _setter: F)

Sends an event through this channel, after calling setter to fill the payload.
If the channel is full, this function may wait until sending it is possible.
IMPLEMENTORS: #[inline(always]

fn send_derived(&self, _derived_item: &DerivedItemType)

For channels that stores the DerivedItemType instead of the ItemType, this method may be useful – for instance: the Stream consumes Arc (the derived item type) and the channel is for Strings. With this method one may send an Arc directly.
The default implementation, though, is made for types that don’t have a derived item type.
IMPLEMENTORS: #[inline(always)]

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

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

Returns a Stream (and its stream_id) able to receive elements sent through this channel.
If called more than once, each Stream will receive a different element – “consumer pattern”.
Currently panics if called more times than allowed by [Uni]’s MAX_STREAMS

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