Struct ThrottleTimeOperator

Source

pub struct ThrottleTimeOperator<In, InError, S>where
    In: Signal,
    InError: Signal,
    S: Scheduler,
{ /* private fields */ }

Expand description

§ThrottleTimeOperator

The throttle_time operator limits the frequency of downstream emissions by emitting an upstream value, then suppressing subsequent emissions until the duration elapses.

When the output is set to LeadingOnly, the first upstream value in a throttle window is emitted immediately. When the output is set to TrailingOnly, the most recent upstream value observed during the throttle window is emitted when it ends. The default LeadingAndTrailing setting emits both the first and the most recent values in each throttle window.

Upstream completion and cancellation can happen instantly if there is no pending trailing value, otherwise it will complete or cancel once the trailing value has been emitted.

Upstream errors are immediately propagated downstream, cancelling any pending throttled value.

§Options

Use ThrottleTimeOptions to configure duration and output behavior.

duration: The throttle window duration. Default: 1s.
output: Controls which emissions are produced in each throttle window. Default: ThrottleOutputBehavior::LeadingAndTrailing. Possible values: ThrottleOutputBehavior::LeadingOnly, ThrottleOutputBehavior::TrailingOnly, ThrottleOutputBehavior::LeadingAndTrailing.

Struct ThrottleTimeOperator Copy item path

§Options

Implementations§

impl<In, InError, S> ThrottleTimeOperator<In, InError, S>where In: Signal, InError: Signal, S: Scheduler,

pub fn new( duration: Duration, scheduler: SchedulerHandle<S>, ) -> ThrottleTimeOperator<In, InError, S>

pub fn new_with_options( options: ThrottleTimeOptions, scheduler: SchedulerHandle<S>, ) -> ThrottleTimeOperator<In, InError, S>

Trait Implementations§

impl<In, InError, S> ComposableOperator for ThrottleTimeOperator<In, InError, S>where In: Signal, InError: Signal, S: 'static + Scheduler + Send + Sync,

type Subscriber<Destination: 'static + Subscriber<In = <ThrottleTimeOperator<In, InError, S> as ObservableOutput>::Out, InError = <ThrottleTimeOperator<In, InError, S> as ObservableOutput>::OutError> + Send + Sync> = ThrottleTimeSubscriber<Destination, S>

impl<In, InError, S> ObservableOutput for ThrottleTimeOperator<In, InError, S>where In: Signal, InError: Signal, S: Scheduler,

type Out = In

type OutError = InError

impl<In, InError, S> ObserverInput for ThrottleTimeOperator<In, InError, S>where In: Signal, InError: Signal, S: Scheduler,

type In = In

type InError = InError

impl<In, InError, S> WithPrimaryCategory for ThrottleTimeOperator<In, InError, S>where In: Signal, InError: Signal, S: Scheduler,

type PrimaryCategory = PrimaryCategoryOperator

Auto Trait Implementations§

impl<In, InError, S> Freeze for ThrottleTimeOperator<In, InError, S>

impl<In, InError, S> RefUnwindSafe for ThrottleTimeOperator<In, InError, S>

impl<In, InError, S> Send for ThrottleTimeOperator<In, InError, S>

impl<In, InError, S> Sync for ThrottleTimeOperator<In, InError, S>

impl<In, InError, S> Unpin for ThrottleTimeOperator<In, InError, S>

impl<In, InError, S> UnwindSafe for ThrottleTimeOperator<In, InError, S>

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> Downcast for Twhere T: Any,

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

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

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

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

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

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

impl<T> From<T> for T

fn from(t: T) -> T

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

fn into(self) -> U

impl<T> IntoEither for T

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

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

impl<T> IntoResult<T> for T

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

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

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

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,

impl<Op> OperatorComposeExtension for Opwhere Op: ComposableOperator,

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

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

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

impl<Op> OperatorComposeExtensionBufferCount for Opwhere Op: ComposableOperator,

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

impl<Op> OperatorComposeExtensionCatch for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionConcatAll for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionConcatMap for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionCount for Opwhere Op: ComposableOperator,

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

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

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

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

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

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

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

impl<Op> OperatorComposeExtensionElementAt for Opwhere Op: ComposableOperator,

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

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,

impl<Op> OperatorComposeExtensionEndWith for Opwhere Op: ComposableOperator,

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

impl<Op> OperatorComposeExtensionEnumerate for Opwhere Op: ComposableOperator,

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

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

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

impl<Op> OperatorComposeExtensionExhaustAll for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionExhaustMap for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionFallbackWhenSilent for Opwhere Op: ComposableOperator,

impl<Op> OperatorComposeExtensionFilter for Opwhere Op: ComposableOperator,

Struct ThrottleTimeOperator

impl<In, InError, S> ThrottleTimeOperator<In, InError, S>
where In: Signal, InError: Signal, S: Scheduler,

impl<In, InError, S> ComposableOperator for ThrottleTimeOperator<In, InError, S>
where In: Signal, InError: Signal, S: 'static + Scheduler + Send + Sync,

impl<In, InError, S> ObservableOutput for ThrottleTimeOperator<In, InError, S>
where In: Signal, InError: Signal, S: Scheduler,

impl<In, InError, S> ObserverInput for ThrottleTimeOperator<In, InError, S>
where In: Signal, InError: Signal, S: Scheduler,

impl<In, InError, S> WithPrimaryCategory for ThrottleTimeOperator<In, InError, S>
where In: Signal, InError: Signal, S: Scheduler,

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

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

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

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

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

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

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

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

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,

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

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

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

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

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

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

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

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

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

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

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

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

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

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,

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

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

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

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

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

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

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

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

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,

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

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,

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

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

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

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

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

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,

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

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

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

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>,

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

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

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

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

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

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,

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

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,

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

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

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

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

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

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

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

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

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

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

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

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,

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

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,

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

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

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

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,

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

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,

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

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