Struct Filter 

pub struct Filter<F, T, const BATCH: usize> { /* private fields */ }

A Listener which transforms or discards messages before passing them on to another Listener.

Construct this by calling Listener::filter(); see its documentation for more information.

Generic parameters

• F is the type of the filter function to use.
• T is the type of the listener to pass filtered messages to.
• BATCH is the maximum number of filtered messages to gather before passing them on. It is used as the size of a stack-allocated array, so should be chosen with the size of the message type in mind.

Implementations

impl<F, T> Filter<F, T, 1>

pub fn with_stack_buffer<const BATCH: usize>(self) -> Filter<F, T, BATCH>

Request that the filter accumulate output messages into a batch.

This causes each receive operation to allocate an array [MO; BATCH] on the stack, where MO is the output message type produced by F. Therefore, the buffer size should be chosen keeping the size of MO in mind. Also, the amount of buffer used cannot exceed the size of the input batch, so it is not useful to choose a buffer size larger than the expected batch size.

If MO is a zero-sized type, then the buffer is always unbounded, so with_stack_buffer() has no effect and is unnecessary in that case.

Trait Implementations

impl<F: Clone, T: Clone, const BATCH: usize> Clone for Filter<F, T, BATCH>

fn clone(&self) -> Filter<F, T, BATCH>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F, T: Debug, const BATCH: usize> Debug for Filter<F, T, BATCH>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<MI, MO, F, T, const BATCH: usize> FromListener<Filter<F, T, BATCH>, MI> for Filter<F, T, BATCH>

where F: Fn(&MI) -> Option<MO> + Send + Sync, T: Listener<MO>,

fn from_listener(listener: Filter<F, T, BATCH>) -> Self

No-op conversion returning the listener unchanged.

impl<MI, MO, F, T, const BATCH: usize> Listener<MI> for Filter<F, T, BATCH>

where F: Fn(&MI) -> Option<MO> + Send + Sync, T: Listener<MO>,

fn receive(&self, messages: &[MI]) -> bool

Process and store the given series of messages.

fn filter<MI, F>(self, function: F) -> Filter<F, Self, 1>

where Self: Sized, F: for<'a> Fn(&'a MI) -> Option<M>,

Wraps self so to apply a map/filter function (similar to Iterator::filter_map()) to incoming messages, to discard uninteresting messages and transform interesting ones.

fn gate(self) -> (Gate, GateListener<Self>)

where Self: Sized,

Wraps self to pass messages only until the returned Gate, and any clones of it, are dropped.

impl<F, T: Pointer, const BATCH: usize> Pointer for Filter<F, T, BATCH>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Produces the same output as the listener this filter wraps.