rx.subjects

public abstract Class Subject<T, R>

Class Inheritance

extends Observable<R>
implements Observer<T>

java.lang.Object
rx.Observable
rx.subjects.Subject

All Implemented Interfaces

Known Direct Subclasses

rx.subjects.TestSubject, rx.subjects.UnicastSubject, rx.internal.operators.BufferUntilSubscriber, rx.subjects.AsyncSubject, rx.subjects.BehaviorSubject, rx.subjects.PublishSubject, rx.subjects.ReplaySubject, rx.subjects.SerializedSubject

Type Parameters

<T>: the input value type
<R>: the output value type

Imports

rx.*

Represents an object that is both an Observable and an Observer.

Constructor Summary

Access	Constructor and Description
protected	Subject(Observable.OnSubscribe<R> onSubscribe)

Method Summary

Modifier and Type	Method and Description
public abstract boolean	Returns: true if there is at least one Observer subscribed to this Subject, false otherwise hasObservers() Indicates whether the `Subject` has `Observers` subscribed to it.
public final SerializedSubject<T, R>	Returns: SerializedSubject wrapping the current Subject toSerialized() Wraps a `Subject` so that it is safe to call its various `on` methods from different threads.

Inherited from rx.Observable:: all amb amb amb amb amb amb amb amb amb ambWith asObservable buffer buffer buffer buffer buffer buffer buffer buffer buffer buffer buffer buffer cache cache cacheWithInitialCapacity cast collect combineLatest combineLatest combineLatest combineLatest combineLatest combineLatest combineLatest combineLatest combineLatest combineLatest combineLatestDelayError compose concat concat concat concat concat concat concat concat concat concat concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatDelayError concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatEager concatMap concatMapDelayError concatMapEager concatMapEager concatMapEager concatMapIterable concatWith contains count countLong create create create create debounce debounce debounce defaultIfEmpty defer delay delay delay delay delaySubscription delaySubscription delaySubscription delaySubscription dematerialize distinct distinct distinctUntilChanged distinctUntilChanged distinctUntilChanged doAfterTerminate doOnCompleted doOnEach doOnEach doOnError doOnNext doOnRequest doOnSubscribe doOnTerminate doOnUnsubscribe elementAt elementAtOrDefault empty error exists filter finallyDo first first firstOrDefault firstOrDefault flatMap flatMap flatMap flatMap flatMap flatMap flatMapCompletable flatMapCompletable flatMapCompletable flatMapIterable flatMapIterable flatMapIterable flatMapIterable flatMapSingle flatMapSingle flatMapSingle forEach forEach forEach from from from from from fromCallable groupBy groupBy groupBy groupBy groupJoin ignoreElements interval interval interval interval isEmpty join just just just just just just just just just just last last lastOrDefault lastOrDefault lift limit map materialize merge merge merge merge merge merge merge merge merge merge merge merge merge merge mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeDelayError mergeWith nest never observeOn observeOn observeOn observeOn ofType onBackpressureBuffer onBackpressureBuffer onBackpressureBuffer onBackpressureBuffer onBackpressureDrop onBackpressureDrop onBackpressureLatest onErrorResumeNext onErrorResumeNext onErrorReturn onExceptionResumeNext onTerminateDetach publish publish range range rebatchRequests reduce reduce repeat repeat repeat repeat repeatWhen repeatWhen replay replay replay replay replay replay replay replay replay replay replay replay replay replay replay replay retry retry retry retryWhen retryWhen sample sample sample scan scan sequenceEqual sequenceEqual serialize share single single singleOrDefault singleOrDefault skip skip skip skipLast skipLast skipLast skipUntil skipWhile sorted sorted startWith startWith startWith startWith startWith startWith startWith startWith startWith startWith startWith subscribe subscribe subscribe subscribe subscribe subscribe subscribeOn subscribeOn switchIfEmpty switchMap switchMapDelayError switchOnNext switchOnNextDelayError take take take takeFirst takeLast takeLast takeLast takeLast takeLast takeLastBuffer takeLastBuffer takeLastBuffer takeLastBuffer takeLastBuffer takeUntil takeUntil takeWhile test test throttleFirst throttleFirst throttleLast throttleLast throttleWithTimeout throttleWithTimeout timeInterval timeInterval timeout timeout timeout timeout timeout timeout timeout timeout timer timer timer timer timestamp timestamp to toBlocking toCompletable toList toMap toMap toMap toMultimap toMultimap toMultimap toMultimap toSingle toSortedList toSortedList toSortedList toSortedList unsafeCreate unsafeSubscribe unsubscribeOn using using window window window window window window window window window window window window withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom withLatestFrom zip zip zip zip zip zip zip zip zip zip zip zipWith zipWith

Constructor Detail

Subject	back to summary
protected Subject(Observable.OnSubscribe<R> onSubscribe)

Method Detail

hasObservers back to summary

hasObservers	back to summary
public abstract boolean hasObservers() Indicates whether the `Subject` has `Observers` subscribed to it. Returns:boolean true if there is at least one Observer subscribed to this Subject, false otherwise

public abstract boolean hasObservers()

Indicates whether the Subject has Observers subscribed to it.

Returns:boolean: true if there is at least one Observer subscribed to this Subject, false otherwise

toSerialized back to summary

toSerialized	back to summary
public final SerializedSubject<T, R> toSerialized() Wraps a `Subject` so that it is safe to call its various `on` methods from different threads. When you use an ordinary `Subject` as a `Subscriber`, you must take care not to call its `Subscriber#onNext` method (or its other `on` methods) from multiple threads, as this could lead to non-serialized calls, which violates the Observable contract and creates an ambiguity in the resulting Subject. To protect a `Subject` from this danger, you can convert it into a `SerializedSubject` with code like the following: `mySafeSubject = myUnsafeSubject.toSerialized();` Returns:SerializedSubject<T, R> SerializedSubject wrapping the current Subject

public final SerializedSubject<T, R> toSerialized()

Wraps a Subject so that it is safe to call its various on methods from different threads.

When you use an ordinary Subject as a Subscriber, you must take care not to call its Subscriber#onNext method (or its other on methods) from multiple threads, as this could lead to non-serialized calls, which violates the Observable contract and creates an ambiguity in the resulting Subject.

To protect a Subject from this danger, you can convert it into a SerializedSubject with code like the following:

mySafeSubject = myUnsafeSubject.toSerialized();

Returns:SerializedSubject<T, R>: SerializedSubject wrapping the current Subject