Uses of Class
io.reactivex.rxjava3.schedulers.Timed

Packages that use Timed

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.functions
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single

Uses of Timed in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core that return types with arguments of type Timed

Modifier and Type	Method	Description
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval()	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull TimeUnit unit)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval()	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull TimeUnit unit)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Observable<Timed<T>>	Observable.timeInterval()	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.
final @NonNull Observable<Timed<T>>	Observable.timeInterval(@NonNull Scheduler scheduler)	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
final @NonNull Observable<Timed<T>>	Observable.timeInterval(@NonNull TimeUnit unit)	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.
final @NonNull Observable<Timed<T>>	Observable.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
final @NonNull Single<Timed<T>>	Single.timeInterval()	Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull TimeUnit unit)	Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp()	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull TimeUnit unit)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp()	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull TimeUnit unit)	Combines the success value from the current Maybe with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final @NonNull Observable<Timed<T>>	Observable.timestamp()	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.
final @NonNull Observable<Timed<T>>	Observable.timestamp(@NonNull Scheduler scheduler)	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Observable<Timed<T>>	Observable.timestamp(@NonNull TimeUnit unit)	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.
final @NonNull Observable<Timed<T>>	Observable.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Single<Timed<T>>	Single.timestamp()	Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull TimeUnit unit)	Combines the success value from the current Single with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.

Uses of Timed in io.reactivex.rxjava3.internal.functions

Methods in io.reactivex.rxjava3.internal.functions that return Timed

Modifier and Type	Method	Description
Timed<T>	Functions.TimestampFunction.apply(T t)

Methods in io.reactivex.rxjava3.internal.functions that return types with arguments of type Timed

Modifier and Type	Method	Description
static <T> Function<T,Timed<T>>	Functions.timestampWith(TimeUnit unit, Scheduler scheduler)

Uses of Timed in io.reactivex.rxjava3.internal.operators.flowable

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type Timed

Modifier and Type	Field	Description
(package private) final org.reactivestreams.Subscriber<? super Timed<T>>	FlowableTimeInterval.TimeIntervalSubscriber.downstream

Method parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Timed

Modifier and Type	Method	Description
protected void	FlowableTimeInterval.subscribeActual(org.reactivestreams.Subscriber<? super Timed<T>> s)

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type Timed

Modifier	Constructor	Description
(package private)	TimeIntervalSubscriber(org.reactivestreams.Subscriber<? super Timed<T>> actual, TimeUnit unit, Scheduler scheduler)

Uses of Timed in io.reactivex.rxjava3.internal.operators.maybe

Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type Timed

Modifier and Type	Field	Description
(package private) final MaybeObserver<? super Timed<T>>	MaybeTimeInterval.TimeIntervalMaybeObserver.downstream

Method parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type Timed

Modifier and Type	Method	Description
protected void	MaybeTimeInterval.subscribeActual(@NonNull MaybeObserver<? super @NonNull Timed<T>> observer)

Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type Timed

Modifier	Constructor	Description
(package private)	TimeIntervalMaybeObserver(MaybeObserver<? super Timed<T>> downstream, TimeUnit unit, Scheduler scheduler, boolean start)

Uses of Timed in io.reactivex.rxjava3.internal.operators.observable

Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type Timed

Modifier and Type	Field	Description
(package private) final Observer<? super Timed<T>>	ObservableTimeInterval.TimeIntervalObserver.downstream

Method parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Timed

Modifier and Type	Method	Description
void	ObservableTimeInterval.subscribeActual(Observer<? super Timed<T>> t)

Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type Timed

Modifier	Constructor	Description
(package private)	TimeIntervalObserver(Observer<? super Timed<T>> actual, TimeUnit unit, Scheduler scheduler)

Uses of Timed in io.reactivex.rxjava3.internal.operators.single

Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type Timed

Modifier and Type	Field	Description
(package private) final SingleObserver<? super Timed<T>>	SingleTimeInterval.TimeIntervalSingleObserver.downstream

Method parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type Timed

Modifier and Type	Method	Description
protected void	SingleTimeInterval.subscribeActual(@NonNull SingleObserver<? super @NonNull Timed<T>> observer)

Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type Timed

Modifier	Constructor	Description
(package private)	TimeIntervalSingleObserver(SingleObserver<? super Timed<T>> downstream, TimeUnit unit, Scheduler scheduler, boolean start)