Skip to main content

ComposeOperator

rx_core

Struct ComposeOperator 

Source 
pub struct ComposeOperator<Op>
where
    Op: 'static + ComposableOperator,
{ /* private fields */ }

Implementations§

Source§

impl<Op> ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source

pub fn new(operator: Op) -> ComposeOperator<Op>

Trait Implementations§

Source§

impl<Op> Clone for ComposeOperator<Op>
where Op: Clone + 'static + ComposableOperator,

Source§

fn clone(&self) -> ComposeOperator<Op>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<Op> ComposableOperator for ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source§

type Subscriber<Destination: 'static + Subscriber<In = <ComposeOperator<Op> as ObservableOutput>::Out, InError = <ComposeOperator<Op> as ObservableOutput>::OutError> + Send + Sync> = <Op as ComposableOperator>::Subscriber<Destination>

Source§

fn operator_subscribe<Destination>( &mut self, destination: Destination, ) -> <ComposeOperator<Op> as ComposableOperator>::Subscriber<Destination>
where Destination: 'static + Subscriber<In = <ComposeOperator<Op> as ObservableOutput>::Out, InError = <ComposeOperator<Op> as ObservableOutput>::OutError> + Send + Sync,

Source§

impl<Op> Debug for ComposeOperator<Op>
where Op: Debug + 'static + ComposableOperator,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<Op> From<Op> for ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source§

fn from(operator: Op) -> ComposeOperator<Op>

Converts to this type from the input type.
Source§

impl<Op> ObservableOutput for ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source§

type Out = <Op as ObservableOutput>::Out

Source§

type OutError = <Op as ObservableOutput>::OutError

Source§

impl<Op> ObserverInput for ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source§

type In = <Op as ObserverInput>::In

Source§

type InError = <Op as ObserverInput>::InError

Source§

impl<Op> WithPrimaryCategory for ComposeOperator<Op>
where Op: 'static + ComposableOperator,

Source§

type PrimaryCategory = PrimaryCategoryOperator

Auto Trait Implementations§

§

impl<Op> Freeze for ComposeOperator<Op>
where Op: Freeze,

§

impl<Op> RefUnwindSafe for ComposeOperator<Op>
where Op: RefUnwindSafe,

§

impl<Op> Send for ComposeOperator<Op>
where Op: Send,

§

impl<Op> Sync for ComposeOperator<Op>
where Op: Sync,

§

impl<Op> Unpin for ComposeOperator<Op>
where Op: Unpin,

§

impl<Op> UnwindSafe for ComposeOperator<Op>
where Op: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> Downcast for T
where T: Any,

Source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
Source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
Source§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
Source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> DowncastSend for T
where T: Any + Send,

Source§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoResult<T> for T

Source§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
Source§

impl<'o, Op> Operator<'o> for Op
where Op: 'static + ComposableOperator,

Source§

type OutObservable<InObservable: 'o + Observable<Out = <Op as ObserverInput>::In, OutError = <Op as ObserverInput>::InError> + Send + Sync> = Pipe<InObservable, Op>

Source§

fn operate<InObservable>( self, source: InObservable, ) -> <Op as Operator<'o>>::OutObservable<InObservable>
where InObservable: 'o + Observable<Out = <Op as ObserverInput>::In, OutError = <Op as ObserverInput>::InError> + Send + Sync,

Source§

impl<Op> OperatorComposeExtension for Op
where Op: ComposableOperator,

Source§

fn compose_with<NextOp>( self, next_operator: NextOp, ) -> CompositeOperator<Self, NextOp>
where NextOp: ComposableOperator<In = Self::Out, InError = Self::OutError>,

Source§

impl<Op> OperatorComposeExtensionAdsr for Op
where Op: ComposableOperator<Out = AdsrTrigger>,

Source§

fn adsr<S>( self, options: AdsrOperatorOptions, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, AdsrOperator<Self::OutError, S>>
where S: 'static + Scheduler,

Source§

impl<Op> OperatorComposeExtensionBufferCount for Op
where Op: ComposableOperator,

Source§

fn buffer_count( self, buffer_size: usize, ) -> CompositeOperator<Self, BufferCountOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionCatch for Op
where Op: ComposableOperator,

Source§

fn catch<NextInnerObservable, OnError>( self, on_error: OnError, ) -> CompositeOperator<Self, CatchOperator<Self::Out, Self::OutError, OnError, NextInnerObservable>>
where NextInnerObservable: Observable<Out = Self::Out> + Signal, OnError: 'static + FnOnce(Self::OutError) -> NextInnerObservable + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionConcatAll for Op
where Op: ComposableOperator,

Source§

fn concat_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ConcatAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionConcatMap for Op
where Op: ComposableOperator,

Source§

fn concat_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ConcatMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionCount for Op
where Op: ComposableOperator,

Source§

fn count( self, ) -> CompositeOperator<Self, CountOperator<Self::Out, Self::OutError>>

CountOperator Read more
Source§

impl<Op, T, S> OperatorComposeExtensionDebounceTime<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn debounce_time( self, duration: Duration, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, DebounceTimeOperator<T, Self::OutError, S>>

DebounceTimeOperator Read more
Source§

impl<Op, T, S> OperatorComposeExtensionDelay<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn delay( self, duration: Duration, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, DelayOperator<T, Self::OutError, S>>

DelayOperator Read more
Source§

impl<Op, In, InError> OperatorComposeExtensionDematerialize<In, InError> for Op
where Op: ComposableOperator<Out = ObserverNotification<In, InError>, OutError = Infallible>, In: Signal, InError: Signal,

Source§

fn dematerialize( self, ) -> CompositeOperator<Self, DematerializeOperator<In, InError>>

Source§

impl<Op> OperatorComposeExtensionElementAt for Op
where Op: ComposableOperator,

Source§

fn element_at( self, index: usize, ) -> CompositeOperator<Self, ElementAtOperator<Self::Out, Self::OutError>>

ElementAtOperator Read more
Source§

fn element_at_or_else<P>( self, index: usize, default_value: P, ) -> CompositeOperator<Self, ElementAtOperator<Self::Out, Self::OutError>>
where P: 'static + Provider<Provided = Self::Out> + Send + Sync,

ElementAtOperator Read more
Source§

impl<Op> OperatorComposeExtensionEndWith for Op
where Op: ComposableOperator,

Source§

fn end_with( self, end_with: Self::Out, ) -> CompositeOperator<Self, EndWithOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionEnumerate for Op
where Op: ComposableOperator,

Source§

fn enumerate( self, ) -> CompositeOperator<Self, EnumerateOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionErrorBoundary for Op
where Op: ComposableOperator<OutError = Infallible>,

Source§

fn error_boundary( self, ) -> CompositeOperator<Self, ErrorBoundaryOperator<Self::Out>>

Source§

impl<Op> OperatorComposeExtensionExhaustAll for Op
where Op: ComposableOperator,

Source§

fn exhaust_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ExhaustAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionExhaustMap for Op
where Op: ComposableOperator,

Source§

fn exhaust_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, ExhaustMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionFallbackWhenSilent for Op
where Op: ComposableOperator,

Source§

fn fallback_when_silent<Fallback, S>( self, fallback: Fallback, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, FallbackWhenSilentOperator<Self::Out, Self::OutError, Fallback, S>>
where Fallback: 'static + Fn(<S as WithWorkInputOutput>::Tick, &mut <<S as WithWorkContextProvider>::WorkContextProvider as WorkContextProvider>::Item<'_>, usize) -> Self::Out + Clone + Send + Sync, S: 'static + Scheduler + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFilter for Op
where Op: ComposableOperator,

Source§

fn filter<Filter>( self, filter: Filter, ) -> CompositeOperator<Self, FilterOperator<Self::Out, Self::OutError, Filter>>
where Filter: 'static + Fn(&Self::Out, usize) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFilterMap for Op
where Op: ComposableOperator,

Source§

fn filter_map<NextOut, Mapper>( self, mapper: Mapper, ) -> CompositeOperator<Self, FilterMapOperator<Self::Out, Self::OutError, Mapper, NextOut>>
where NextOut: Signal, Mapper: 'static + Fn(Self::Out) -> Option<NextOut> + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFinalize for Op
where Op: ComposableOperator,

Source§

fn finalize<Callback>( self, callback: Callback, ) -> CompositeOperator<Self, FinalizeOperator<Self::Out, Self::OutError, Callback>>
where Callback: 'static + Clone + FnOnce() + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFind for Op
where Op: ComposableOperator,

Source§

fn find<Predicate>( self, predicate: Predicate, ) -> CompositeOperator<Self, FindOperator<Self::Out, Self::OutError, Predicate>>
where Predicate: 'static + Fn(&Self::Out) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFindIndex for Op
where Op: ComposableOperator,

Source§

fn find_index<Predicate>( self, predicate: Predicate, ) -> CompositeOperator<Self, FindIndexOperator<Self::Out, Self::OutError, Predicate>>
where Predicate: 'static + Fn(&Self::Out) -> bool + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionFirst for Op
where Op: ComposableOperator,

Source§

fn first( self, ) -> CompositeOperator<Self, FirstOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionInto for Op
where Op: ComposableOperator,

Source§

fn map_into<NextOut, NextOutError>( self, ) -> CompositeOperator<Self, MapIntoOperator<Self::Out, Self::OutError, NextOut, NextOutError>>
where NextOut: Signal, NextOutError: Signal, Self::Out: Into<NextOut>, Self::OutError: Into<NextOutError>,

Source§

impl<Op> OperatorComposeExtensionIntoResult for Op
where Op: ComposableOperator,

Source§

fn into_result( self, ) -> CompositeOperator<Self, IntoResultOperator<Self::Out, Self::OutError>>

IntoResultOperator Read more
Source§

impl<Op> OperatorComposeExtensionIsEmpty for Op
where Op: ComposableOperator,

Source§

fn is_empty( self, ) -> CompositeOperator<Self, IsEmptyOperator<Self::Out, Self::OutError>>

IsEmptyOperator Read more
Source§

impl<Op, T> OperatorComposeExtensionLiftOption<T> for Op
where Op: ComposableOperator<Out = Option<T>>, T: Signal,

Source§

fn lift_option( self, ) -> CompositeOperator<Self, LiftOptionOperator<T, Self::OutError>>

Source§

impl<Op, ResultIn, ResultInError> OperatorComposeExtensionLiftResult<ResultIn, ResultInError> for Op
where Op: ComposableOperator<Out = Result<ResultIn, ResultInError>, OutError = Infallible>, ResultIn: Signal, ResultInError: Signal,

Source§

fn lift_result( self, ) -> CompositeOperator<Self, LiftResultOperator<ResultIn, ResultInError, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionMap for Op
where Op: ComposableOperator,

Source§

fn map<NextOut, Mapper>( self, mapper: Mapper, ) -> CompositeOperator<Self, MapOperator<Self::Out, Self::OutError, Mapper, NextOut>>
where NextOut: Signal, Mapper: 'static + Fn(Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionMapError for Op
where Op: ComposableOperator,

Source§

fn map_error<NextOutError, ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MapErrorOperator<Self::Out, Self::OutError, ErrorMapper, NextOutError>>
where NextOutError: Signal, ErrorMapper: 'static + FnOnce(Self::OutError) -> NextOutError + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionMapNeverBoth for Op
where Op: ComposableOperator<Out = Infallible, OutError = Infallible>,

Source§

fn map_never_both<NextOut, NextOutError>( self, ) -> CompositeOperator<Self, MapNeverBothOperator<NextOut, NextOutError>>
where NextOut: Signal, NextOutError: Signal,

Source§

impl<Op> OperatorComposeExtensionMapNeverError for Op
where Op: ComposableOperator<OutError = Infallible>,

Source§

fn map_never<NextOutError>( self, ) -> CompositeOperator<Self, MapNeverErrorOperator<Self::Out, NextOutError>>
where NextOutError: Signal,

Source§

impl<Op> OperatorComposeExtensionMapNeverNext for Op
where Op: ComposableOperator<Out = Infallible>,

Source§

fn map_never<NextOut>( self, ) -> CompositeOperator<Self, MapNeverNextOperator<NextOut, Self::OutError>>
where NextOut: Signal,

Source§

impl<Op> OperatorComposeExtensionMaterialize for Op
where Op: ComposableOperator,

Source§

fn materialize( self, ) -> CompositeOperator<Self, MaterializeOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionMergeAll for Op
where Op: ComposableOperator,

Source§

fn merge_all<ErrorMapper>( self, concurrency_limit: usize, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MergeAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionMergeMap for Op
where Op: ComposableOperator,

Source§

fn merge_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, concurrency_limit: usize, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, MergeMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op, T, S> OperatorComposeExtensionObserveOn<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn observe_on( self, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, ObserveOnOperator<T, Self::OutError, S>>

ObserveOnOperator Read more
Source§

impl<Op> OperatorComposeExtensionOnNext for Op
where Op: ComposableOperator,

Source§

fn on_next<OnNext>( self, on_next: OnNext, ) -> CompositeOperator<Self, OnNextOperator<OnNext, Self::Out, Self::OutError>>
where OnNext: 'static + FnMut(&Self::Out, &mut dyn Subscriber<In = Self::Out, InError = Self::OutError>) -> bool + Send + Sync + Clone,

Source§

impl<Op> OperatorComposeExtensionOnSubscribe for Op
where Op: ComposableOperator,

Source§

fn on_subscribe<OnSubscribe>( self, on_subscribe: OnSubscribe, ) -> CompositeOperator<Self, OnSubscribeOperator<OnSubscribe, Self::Out, Self::OutError>>
where OnSubscribe: 'static + FnMut(&mut dyn Subscriber<In = Self::Out, InError = Self::OutError>) + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionPairwise for Op
where Op: ComposableOperator,

Source§

fn pairwise( self, ) -> CompositeOperator<Self, PairwiseOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionReduce for Op
where Op: ComposableOperator,

Source§

fn reduce<NextOut, Reducer>( self, reducer: Reducer, seed: NextOut, ) -> CompositeOperator<Self, ReduceOperator<Self::Out, Self::OutError, Reducer, NextOut>>
where NextOut: Signal + Clone, Reducer: 'static + Fn(&NextOut, Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionScan for Op
where Op: ComposableOperator,

Source§

fn scan<NextOut, Reducer>( self, reducer: Reducer, seed: NextOut, ) -> CompositeOperator<Self, ScanOperator<Self::Out, Self::OutError, Reducer, NextOut>>
where NextOut: Signal + Clone, Reducer: 'static + Fn(&NextOut, Self::Out) -> NextOut + Clone + Send + Sync,

Source§

impl<Op> OperatorComposeExtensionSkip for Op
where Op: ComposableOperator,

Source§

fn skip( self, count: usize, ) -> CompositeOperator<Self, SkipOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionStartWith for Op
where Op: ComposableOperator,

Source§

fn start_with( self, start_with: Self::Out, ) -> CompositeOperator<Self, StartWithOperator<Self::Out, Self::OutError>>
where Self::Out: Clone,

Source§

impl<Op> OperatorComposeExtensionSwitchAll for Op
where Op: ComposableOperator,

Source§

fn switch_all<ErrorMapper>( self, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, SwitchAllOperator<Self::Out, Self::OutError, ErrorMapper>>
where ErrorMapper: 'static + Fn(Self::OutError) -> <Self::Out as ObservableOutput>::OutError + Clone + Send + Sync, Self::Out: Observable, Self::OutError: Into<<Self::Out as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionSwitchMap for Op
where Op: ComposableOperator,

Source§

fn switch_map<NextInnerObservable, Mapper, ErrorMapper>( self, mapper: Mapper, error_mapper: ErrorMapper, ) -> CompositeOperator<Self, SwitchMapOperator<Self::Out, Self::OutError, Mapper, ErrorMapper, NextInnerObservable>>
where NextInnerObservable: Observable + Signal, Mapper: 'static + Fn(Self::Out) -> NextInnerObservable + Clone + Send + Sync, ErrorMapper: 'static + FnOnce(Self::OutError) -> <NextInnerObservable as ObservableOutput>::OutError + Clone + Send + Sync, Self::OutError: Into<<NextInnerObservable as ObservableOutput>::OutError>,

Source§

impl<Op> OperatorComposeExtensionTake for Op
where Op: ComposableOperator,

Source§

fn take( self, count: usize, ) -> CompositeOperator<Self, TakeOperator<Self::Out, Self::OutError>>

Source§

impl<Op> OperatorComposeExtensionTap for Op
where Op: ComposableOperator,

Source§

fn tap<TapDestination>( self, tap_destination: TapDestination, ) -> CompositeOperator<Self, TapOperator<TapDestination>>
where TapDestination: 'static + RxObserver<In = Self::Out, InError = Self::OutError> + Clone + Send + Sync, Self::Out: Clone, Self::OutError: Clone,

Source§

impl<Op> OperatorComposeExtensionTapNext for Op
where Op: ComposableOperator,

Source§

fn tap_next<OnNext>( self, callback: OnNext, ) -> CompositeOperator<Self, TapNextOperator<Self::Out, Self::OutError, OnNext>>
where OnNext: 'static + Fn(&Self::Out) + Clone + Send + Sync,

Source§

impl<Op, T, S> OperatorComposeExtensionThrottleTime<T, S> for Op
where Op: ComposableOperator<Out = T>, T: Signal, S: 'static + Scheduler + Send + Sync,

Source§

fn throttle_time( self, options: ThrottleTimeOptions, scheduler: SchedulerHandle<S>, ) -> CompositeOperator<Self, ThrottleTimeOperator<T, Self::OutError, S>>

ThrottleTimeOperator Read more
Source§

impl<Op> OperatorComposeExtensionWithLatestFrom for Op
where Op: ComposableOperator,

Source§

fn with_latest_from<InnerObservable>( self, inner_observable: InnerObservable, ) -> CompositeOperator<Self, WithLatestFromOperator<InnerObservable, Self::Out, Self::OutError>>
where InnerObservable: 'static + Observable<OutError = Self::OutError>, <InnerObservable as ObservableOutput>::Out: Clone,

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> ConditionalSend for T
where T: Send,

Source§

impl<T> Signal for T
where T: 'static + Send + Sync,