Struct reactor_rs::mono::MonoScheduleOn

pub struct MonoScheduleOn<T, E, M, C> where
    M: 'static + Send + Mono<T, E> + Sized,
    C: Scheduler<Item = T, Error = E> + Sized,  { /* fields omitted */ }

Methods

impl<T, E, M, C> MonoScheduleOn<T, E, M, C> where
    M: 'static + Send + Mono<T, E> + Sized,
    C: Scheduler<Item = T, Error = E> + Sized, 

pub fn new(source: M, scheduler: C) -> MonoScheduleOn<T, E, M, C>

Trait Implementations

impl<T, E, M, C> Mono<T, E> for MonoScheduleOn<T, E, M, C> where
    M: 'static + Send + Mono<T, E> + Sized,
    C: Scheduler<Item = T, Error = E> + Sized, 

fn block(self) -> Result<Option<Self::Item>, Self::Error> where
    Self::Item: 'static + Send,
    Self::Error: 'static + Send,
    Self: Sized, 

fn do_on_error<F>(self, f: F) -> MonoDoOnError<Self::Item, Self::Error, Self, F> where
    F: 'static + Send + Fn(&Self::Error),
    Self: Sized, 

fn do_on_success<F>(self, f: F) -> Foreach<Self, Self::Item, F, Self::Error> where
    F: 'static + Send + Fn(&Self::Item),
    Self: Sized, 

fn do_on_complete<F>(
    self,
    f: F
) -> MonoDoOnComplete<Self::Item, Self::Error, Self, F> where
    Self: Sized,
    F: 'static + Send + Fn(), 

fn map<A, F>(
    self,
    transform: F
) -> MonoTransform<Self, Self::Item, A, F, Self::Error> where
    F: 'static + Send + Fn(Self::Item) -> A,
    Self: Sized, 

fn flatmap<A, M, F>(
    self,
    mapper: F
) -> MonoFlatMap<Self::Item, A, Self::Error, Self, M, F> where
    Self: 'static + Send + Sized,
    Self::Item: 'static + Send,
    Self::Error: 'static + Send,
    A: 'static + Send,
    M: 'static + Send + Mono<A, Self::Error>,
    F: 'static + Send + Fn(Self::Item) -> M, 

fn do_finally<F>(
    self,
    action: F
) -> MonoDoFinally<Self::Item, Self::Error, Self, F> where
    Self: Sized,
    F: 'static + Send + Fn(), 

fn filter<F>(self, predicate: F) -> MonoFilter<Self, Self::Item, F, Self::Error> where
    Self: Sized,
    F: 'static + Send + Fn(&Self::Item) -> bool, 

fn subscribe_on<C>(
    self,
    scheduler: C
) -> MonoScheduleOn<Self::Item, Self::Error, Self, C> where
    Self: 'static + Send + Sized,
    C: Scheduler<Item = Self::Item, Error = Self::Error>, 

impl<T, E, M, C> Publisher for MonoScheduleOn<T, E, M, C> where
    M: 'static + Send + Mono<T, E> + Sized,
    C: Scheduler<Item = T, Error = E> + Sized, 

type Item = T

type Error = E

fn subscribe(
    self,
    subscriber: impl Subscriber<Item = T, Error = E> + 'static + Send
)