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>

Considering parallelism, this method might provide access to all elements available for [consume()].
This method is totally not thread safe for ring-buffer based implementations – the moment it returns, all those elements might have already been consumed (furthermore, by the time the references are used, several generations of elements might have already lived and died at those slots). It is, thought, safe for unbounded implementations that never collect published elements, like a log_topic
… So, use this method only when you’re sure the publishing / consumption operations won’t interfere with the results – for this reason, this method is marked as unsafe (it is only safe – and consistent – to call this method if you’re behind a lock guarding against these mentioned scenarios).