Struct reactive_mutiny::ogre_std::ogre_queues::log_topics::mmap_meta::MMapMetaFixedSubscriber

pub struct MMapMetaFixedSubscriber<'a, SlotType: 'a> { /* private fields */ }

A subscriber that follows a “fixed” tail – used on followers of “old” events, as opposed to MMapMetaDynamicSubscriber, which may yield “new” events as well

Trait Implementations

impl<'a, SlotType: 'a + Debug> MetaSubscriber<'a, SlotType> for MMapMetaFixedSubscriber<'a, SlotType>

fn consume<GetterReturnType: 'a, GetterFn: FnOnce(&'a SlotType) -> GetterReturnType, ReportEmptyFn: Fn() -> bool, ReportLenAfterDequeueingFn: FnOnce(i32)>( &self, getter_fn: GetterFn, report_empty_fn: ReportEmptyFn, report_len_after_dequeueing_fn: ReportLenAfterDequeueingFn, ) -> Option<GetterReturnType>

Zero-copy dequeue method with the following characteristics:

fn consume_leaking(&'a self) -> Option<(&'a SlotType, u32)>

Advanced method to “consume” the next element from the pool, returning a reference to the data.
The slot in which the data sits won’t be put back into the pool (for reuse) until [release_leaked()] is called.
Please notice that misuse of this method may bring the underlying container into an unusable state, as it may run out of slots for new elements to be published in.
IMPLEMENTORS: #[inline(always)]

fn release_leaked_ref(&'a self, _slot: &'a SlotType)

Put the slot returned by [consume_leaking()] back into the pool, so it may be reused.
See the mentioned method for more info. IMPLEMENTORS: #[inline(always)]

fn release_leaked_id(&'a self, _slot_id: u32)

The same as [release_leaked_ref()], but slightly more efficient IMPLEMENTORS: #[inline(always)]

fn remaining_elements_count(&self) -> usize

Returns the same information as [MetaPublisher::available_elements_count()] for implementors that doesn’t allow several subscribers; For those that allow it (that is, use the “Listener Pattern”), returns how much elements are left for consumption IMPLEMENTORS: #[inline(always)]

unsafe fn peek_remaining(&self) -> Vec<&SlotType>

Safety