Struct FilterMap

pub struct FilterMap<A, F, G> { /* private fields */ }

An Adapter that passes each item through an optional function and passes the Some values on.

Trait Implementations

impl<F, G, A, B> Adapter for FilterMap<A, F, G>

where F: Fn(A) -> Option<B> + Send, B: Send + 'static, G: Adapter<Item = B> + Send, A: Send,

type Item = A

async fn notify(&mut self, a: Self::Item)

where Self::Item: 'static,

Forward the given item to an asynchronous consumer, possibly converting the type or possibly dropping the item if it cannot be converted.

fn clone_notify(&mut self, a: &Self::Item) -> impl Future<Output = ()> + Send

where Self::Item: Clone + 'static,

Clone the referenced item and then forward it to an asynchonous consumer. The clone operation can is avoid in the Placeholder implementation.

fn merge<T>(self, other: T) -> impl Adapter<Item = Self::Item>

where T: Adapter<Item = Self::Item>, Self: Sized + Send, Self::Item: Send + Clone,

Combine this with another adapter. The notify call is delegated to both adapters.

fn with_filter_map<A>( self, func: impl Fn(A) -> Option<Self::Item> + Send, ) -> impl Adapter<Item = A>

where Self: Sized + Send, Self::Item: Send + 'static, A: Send,

Create an adapter that maps items with an optional function. Some values are passed on, analogous to Iterator::filter_map.

fn with_map<A>( self, func: impl Fn(A) -> Self::Item + Send, ) -> impl Adapter<Item = A>

where Self: Sized + Send, Self::Item: Send + 'static, A: Send,

Create an adapter that maps each item with a function.

fn adapt<A>(self) -> impl Adapter<Item = A>

where Self: Sized + Send, Self::Item: Send + 'static, A: Into<Self::Item> + Send,

Create an adapter that converts each item from another type. This relies on an Into implementation for the conversion.

fn adapt_fallible<A>(self) -> impl Adapter<Item = A>

where Self: Sized + Send, Self::Item: Send + 'static, A: TryInto<Self::Item> + Send,

Create an adapter that fallibly converts each item from another type. This relies on an TryInto implementation for the conversion.

impl<A: Debug, F: Debug, G: Debug> Debug for FilterMap<A, F, G>

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

Formats the value using the given formatter.