All Classes

Class	Description
Action	All Action interfaces extend from this.
Action0	A zero-argument action.
Action1<T>	A one-argument action.
Action2<T1,T2>	A two-argument action.
Action3<T1,T2,T3>	A three-argument action.
Action4<T1,T2,T3,T4>	A four-argument action.
Action5<T1,T2,T3,T4,T5>	A five-argument action.
Action6<T1,T2,T3,T4,T5,T6>	A six-argument action.
Action7<T1,T2,T3,T4,T5,T6,T7>	A seven-argument action.
Action8<T1,T2,T3,T4,T5,T6,T7,T8>	An eight-argument action.
Action9<T1,T2,T3,T4,T5,T6,T7,T8,T9>	A nine-argument action.
ActionN	A vector-argument action.
ActionNotificationObserver<T>	An Observer that forwards the onXXX method calls to a notification callback by transforming each signal type into Notifications.
Actions	Utility class for the Action interfaces.
Actions.Action1CallsAction0<T>
Actions.EmptyAction<T0,T1,T2,T3,T4,T5,T6,T7,T8>
ActionSubscriber<T>	A Subscriber that forwards the onXXX method calls to callbacks.
AssemblyStackTraceException	A RuntimeException that is stackless but holds onto a textual stacktrace from tracking the assembly location of operators.
AsyncCompletableSubscriber	An abstract base class for CompletableSubscriber implementations that want to expose an unsubscription capability.
AsyncCompletableSubscriber.Unsubscribed
AsyncEmitter<T>	Abstraction over a RxJava Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount.
AsyncEmitter.BackpressureMode	Options to handle backpressure in the emitter.
AsyncEmitter.Cancellable	A functional interface that has a single close method that can throw.
AsyncOnSubscribe<S,T>	A utility class to create OnSubscribe<T> functions that respond correctly to back pressure requests from subscribers.
AsyncOnSubscribe.AsyncOnSubscribeImpl<S,T>	An implementation of AsyncOnSubscribe that delegates AsyncOnSubscribe.next(Object, long, Observer), AsyncOnSubscribe.generateState(), and AsyncOnSubscribe.onUnsubscribe(Object) to provided functions/closures.
AsyncOnSubscribe.AsyncOuterManager<S,T>
AsyncOnSubscribe.UnicastSubject<T>
AsyncOnSubscribe.UnicastSubject.State<T>
AsyncSubject<T>	Subject that publishes only the last item observed to each Observer once the source Observable has completed.
AtomicReferenceArrayQueue<E>
BackpressureDrainManager	Manages the producer-backpressure-consumer interplay by matching up available elements with requested elements and/or terminal events.
BackpressureDrainManager.BackpressureQueueCallback	Interface representing the minimal callbacks required to operate the drain part of a backpressure system.
BackpressureOverflow	Generic strategy and default implementations to deal with backpressure buffer overflows.
BackpressureOverflow.DropLatest	Drop most recent items, but not onError nor unsubscribe from source (as {code OperatorOnBackpressureDrop}).
BackpressureOverflow.DropOldest	Drop oldest items from the buffer making room for newer ones.
BackpressureOverflow.Error	onError a MissingBackpressureException and unsubscribe from source.
BackpressureOverflow.Strategy	Represents a callback called when a value is about to be dropped due to lack of downstream requests.
BackpressureUtils	Utility functions for use with backpressure.
BaseLinkedAtomicQueue<E>
BaseLinkedQueue<E>	A base data structure for concurrent linked queues.
BaseLinkedQueueConsumerNodeRef<E>
BaseLinkedQueuePad0<E>
BaseLinkedQueuePad1<E>
BaseLinkedQueueProducerNodeRef<E>
BehaviorSubject<T>	Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
Beta	Signifies that a public API (public class, method or field) is subject to incompatible changes, or even removal, in a future release.
BlockingObservable<T>	BlockingObservable is a variety of Observable that provides blocking operators.
BlockingOperatorLatest	Wait for and iterate over the latest values of the source observable.
BlockingOperatorLatest.LatestObserverIterator<T>	Observer of source, iterator for output.
BlockingOperatorMostRecent	Returns an Iterable that always returns the item most recently emitted by an Observable, or a seed value if no item has yet been emitted.
BlockingOperatorMostRecent.MostRecentObserver<T>
BlockingOperatorNext	Returns an Iterable that blocks until the Observable emits another item, then returns that item.
BlockingOperatorNext.NextIterator<T>
BlockingOperatorNext.NextObserver<T>
BlockingOperatorToFuture	Returns a Future representing the single value emitted by an Observable.
BlockingOperatorToIterator	Returns an Iterator that iterates over all items emitted by a specified Observable.
BlockingOperatorToIterator.SubscriberIterator<T>
BlockingSingle<T>	BlockingSingle is a blocking "version" of Single that provides blocking operators.
BlockingUtils	Utility functions relating to blocking types.
BooleanSubscription	Subscription that can be checked for status such as in a loop inside an Observable to exit the loop if unsubscribed.
BufferUntilSubscriber<T>	A solution to the "time gap" problem that occurs with groupBy and pivot.
BufferUntilSubscriber.OnSubscribeAction<T>
BufferUntilSubscriber.State<T>	The common state.
CachedObservable<T>	An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
CachedObservable.CachedSubscribe<T>	Manages the subscription of child subscribers by setting up a replay producer and performs auto-connection of the very first subscription.
CachedObservable.CacheState<T>	Contains the active child producers and the values to replay.
CachedObservable.ReplayProducer<T>	Keeps track of the current request amount and the replay position for a child Subscriber.
CachedThreadScheduler
CachedThreadScheduler.CachedWorkerPool
CachedThreadScheduler.EventLoopWorker
CachedThreadScheduler.ThreadWorker
Completable	Represents a deferred computation without any value but only indication for completion or exception.
Completable.CompletableOnSubscribe	Callback used for building deferred computations that takes a CompletableSubscriber.
Completable.CompletableOperator	Convenience interface and callback used by the lift operator that given a child CompletableSubscriber, return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
Completable.CompletableSubscriber	Represents the subscription API callbacks when subscribing to a Completable instance.
Completable.CompletableTransformer	Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.
CompletableOnSubscribeConcat
CompletableOnSubscribeConcat.CompletableConcatSubscriber
CompletableOnSubscribeConcatArray
CompletableOnSubscribeConcatArray.ConcatInnerSubscriber
CompletableOnSubscribeConcatIterable
CompletableOnSubscribeConcatIterable.ConcatInnerSubscriber
CompletableOnSubscribeMerge
CompletableOnSubscribeMerge.CompletableMergeSubscriber
CompletableOnSubscribeMergeArray
CompletableOnSubscribeMergeDelayErrorArray
CompletableOnSubscribeMergeDelayErrorIterable
CompletableOnSubscribeMergeIterable
CompletableOnSubscribeTimeout
CompositeException	Represents an exception that is a composite of one or more other exceptions.
CompositeException.CompositeExceptionCausalChain
CompositeException.PrintStreamOrWriter
CompositeException.WrappedPrintStream	Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation
CompositeException.WrappedPrintWriter
CompositeSubscription	Subscription that represents a group of Subscriptions that are unsubscribed together.
ConcurrentCircularArrayQueue<E>	A concurrent access enabling class used by circular array based queues this class exposes an offset computation method along with differently memory fenced load/store methods into the underlying array.
ConcurrentCircularArrayQueueL0Pad<E>
ConcurrentSequencedCircularArrayQueue<E>
ConnectableObservable<T>	A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect() method is called.
DeferredScalarSubscriber<T,R>	Base class for Subscribers that consume the entire upstream and signal zero or one element (or an error) in a backpressure honoring fashion.
DeferredScalarSubscriber.InnerProducer	Redirects the downstream request amount bach to the DeferredScalarSubscriber.
EmptyObservableHolder	Holds a singleton instance of an empty Observable which is stateless and completes the child subscriber immediately.
EventLoopsScheduler
EventLoopsScheduler.EventLoopWorker
EventLoopsScheduler.FixedSchedulerPool
EventLoopsScheduler.PoolWorker
Exceptions	Utility class with methods to wrap checked exceptions and manage fatal and regular exception delivery.
ExceptionsUtils	Utility methods for terminal atomics with Throwables.
ExecutorScheduler	Scheduler that wraps an Executor instance and establishes the Scheduler contract upon it.
ExecutorScheduler.ExecutorSchedulerWorker	Worker that schedules tasks on the executor indirectly through a trampoline mechanism.
Experimental	Signifies that a public API (public class, method or field) is will almost certainly be changed or removed in a future release.
Func0<R>	Represents a function with zero arguments.
Func1<T,R>	Represents a function with one argument.
Func2<T1,T2,R>	Represents a function with two arguments.
Func3<T1,T2,T3,R>	Represents a function with three arguments.
Func4<T1,T2,T3,T4,R>	Represents a function with four arguments.
Func5<T1,T2,T3,T4,T5,R>	Represents a function with five arguments.
Func6<T1,T2,T3,T4,T5,T6,R>	Represents a function with six arguments.
Func7<T1,T2,T3,T4,T5,T6,T7,R>	Represents a function with seven arguments.
Func8<T1,T2,T3,T4,T5,T6,T7,T8,R>	Represents a function with eight arguments.
Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>	Represents a function with nine arguments.
FuncN<R>	Represents a vector-argument function.
Function	All Func and Action interfaces extend from this.
Functions
GenericScheduledExecutorService	A default ScheduledExecutorService that can be used for scheduling actions when a Scheduler implementation doesn't have that ability.
GenericScheduledExecutorServiceFactory	Utility class to create the individual ScheduledExecutorService instances for the GenericScheduledExecutorService class.
GroupedObservable<K,T>	An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
ImmediateScheduler	Executes work immediately on the current thread.
ImmediateScheduler	Deprecated. This type was never publicly instantiable.
IndexedRingBuffer<E>	Add/Remove without object allocation (after initial construction).
IndexedRingBuffer.ElementSection<E>
IndexedRingBuffer.IndexSection
InternalObservableUtils	Holder of named utility classes factored out from Observable to save source space and help with debugging with properly named objects.
InternalObservableUtils.CollectorCaller<T,R>
InternalObservableUtils.EqualsWithFunc1
InternalObservableUtils.ErrorNotImplementedAction
InternalObservableUtils.IsInstanceOfFunc1
InternalObservableUtils.NotificationErrorExtractor
InternalObservableUtils.ObjectEqualsFunc2
InternalObservableUtils.PlusOneFunc2
InternalObservableUtils.PlusOneLongFunc2
InternalObservableUtils.RepeatNotificationDematerializer
InternalObservableUtils.ReplaySupplierBuffer<T>
InternalObservableUtils.ReplaySupplierBufferTime<T>
InternalObservableUtils.ReplaySupplierNoParams<T>
InternalObservableUtils.ReplaySupplierTime<T>
InternalObservableUtils.RetryNotificationDematerializer
InternalObservableUtils.ReturnsVoidFunc1
InternalObservableUtils.SelectorAndObserveOn<T,R>
InternalObservableUtils.ToArrayFunc1
LinkedArrayList	A list implementation which combines an ArrayList with a LinkedList to avoid copying values when the capacity needs to be increased.
LinkedQueueNode<E>
MessagePassingQueue<M>	This is a tagging interface for the queues in this library which implement a subset of the Queue interface sufficient for concurrent message passing. Message passing queues offer happens before semantics to messages passed through, namely that writes made by the producer before offering the message are visible to the consuming thread after the message has been polled out of the queue.
MissingBackpressureException	Represents an exception that indicates that a Subscriber or operator attempted to apply reactive pull backpressure to an Observable that does not implement it.
MpmcArrayQueue<E>	A Multi-Producer-Multi-Consumer queue based on a ConcurrentCircularArrayQueue.
MpmcArrayQueueConsumerField<E>
MpmcArrayQueueL1Pad<E>
MpmcArrayQueueL2Pad<E>
MpmcArrayQueueProducerField<E>
MpscLinkedAtomicQueue<E>	This is a direct Java port of the MPSC algorithm as presented on 1024 Cores by D.
MpscLinkedQueue<E>	This is a direct Java port of the MPSC algorithm as presented on 1024 Cores by D.
MultipleAssignmentSubscription	Subscription that can be checked for status such as in a loop inside an Observable to exit the loop if unsubscribed.
MultipleAssignmentSubscription.State
NeverObservableHolder	Holds a singleton instance of a never Observable which is stateless doesn't call any of the Subscriber's methods.
NewThreadScheduler	Schedules work on a new thread.
NewThreadScheduler	Deprecated. This type was never publicly instantiable.
NewThreadWorker
Notification<T>	An object representing a notification sent to an Observable.
Notification.Kind	Specifies the kind of the notification: an element, an error or a completion notification.
NotificationLite<T>	For use in internal operators that need something like materialize and dematerialize wholly within the implementation of the operator but don't want to incur the allocation cost of actually creating Notification objects for every onNext and onCompleted.
NotificationLite.OnErrorSentinel
ObjectPool<T>
Observable<T>	The Observable class that implements the Reactive Pattern.
Observable.OnSubscribe<T>	Invoked when Observable.subscribe is called.
Observable.OnSubscribeExtend<T>	Transforms a OnSubscribe.call() into an Observable.subscribe() call.
Observable.Operator<R,T>	Operator function for lifting into an Observable.
Observable.Transformer<T,R>	Function that receives the current Observable and should return another Observable, possibly with given element type, in exchange that will be subscribed to by the downstream operators and subscribers.
Observer<T>	Provides a mechanism for receiving push-based notifications.
Observers	Helper methods and utilities for creating and working with Observer objects.
ObserverSubscriber<T>	Wraps an Observer and forwards the onXXX method calls to it.
OnCompletedFailedException	Represents an exception used to re-throw errors thrown from Observer.onCompleted().
OnErrorFailedException	Represents an exception used to re-throw errors thrown from Observer.onError(Throwable).
OnErrorNotImplementedException	Represents an exception used to re-throw Observer.onError(Throwable) when an implementation doesn't exist.
OnErrorThrowable	Represents a Throwable that an Observable might notify its subscribers of, but that then can be handled by an operator that is designed to recover from or react appropriately to such an error.
OnErrorThrowable.OnNextValue	Represents an exception that was encountered while trying to emit an item from an Observable, and tries to preserve that item for future use and/or reporting.
OnErrorThrowable.OnNextValue.Primitives
OnSubscribeAmb<T>	Given multiple Observables, propagates the one that first emits an item.
OnSubscribeAmb.AmbSubscriber<T>
OnSubscribeAmb.Selection<T>
OnSubscribeAutoConnect<T>	Wraps a ConnectableObservable and calls its connect() method once the specified number of Subscribers have subscribed.
OnSubscribeCollect<T,R>
OnSubscribeCollect.CollectSubscriber<T,R>
OnSubscribeCombineLatest<T,R>
OnSubscribeCombineLatest.CombinerSubscriber<T,R>
OnSubscribeCombineLatest.LatestCoordinator<T,R>
OnSubscribeConcatMap<T,R>	Maps a source sequence into Observables and concatenates them in order, subscribing to one at a time.
OnSubscribeConcatMap.ConcatMapInnerScalarProducer<T,R>
OnSubscribeConcatMap.ConcatMapInnerSubscriber<T,R>
OnSubscribeConcatMap.ConcatMapSubscriber<T,R>
OnSubscribeDefer<T>	Do not create the Observable until an Observer subscribes; create a fresh Observable on each subscription.
OnSubscribeDelaySubscription<T>	Delays the subscription to the source by the given amount, running on the given scheduler.
OnSubscribeDelaySubscriptionOther<T,U>	Delays the subscription to the main source until the other observable fires an event or completes.
OnSubscribeDelaySubscriptionWithSelector<T,U>	Delays the subscription until the Observable emits an event.
OnSubscribeDetach<T>	Nulls out references to upstream data structures when the source terminates or the child unsubscribes.
OnSubscribeDetach.DetachProducer<T>	Callbacks from the child Subscriber.
OnSubscribeDetach.DetachSubscriber<T>	The parent subscriber that forwards events and cleans up on a terminal state.
OnSubscribeDetach.TerminatedProducer	Singleton instance via enum.
OnSubscribeFilter<T>	Filters an Observable by discarding any items it emits that do not meet some test.
OnSubscribeFilter.FilterSubscriber<T>
OnSubscribeFlattenIterable<T,R>	Flattens a sequence if Iterable sources, generated via a function, into a single sequence.
OnSubscribeFlattenIterable.FlattenIterableSubscriber<T,R>
OnSubscribeFlattenIterable.OnSubscribeScalarFlattenIterable<T,R>	A custom flattener that works from a scalar value and computes the iterable during subscription time.
OnSubscribeFromArray<T>
OnSubscribeFromArray.FromArrayProducer<T>
OnSubscribeFromAsync<T>
OnSubscribeFromAsync.BaseAsyncEmitter<T>
OnSubscribeFromAsync.BufferAsyncEmitter<T>
OnSubscribeFromAsync.CancellableSubscription
OnSubscribeFromAsync.DropAsyncEmitter<T>
OnSubscribeFromAsync.ErrorAsyncEmitter<T>
OnSubscribeFromAsync.LatestAsyncEmitter<T>
OnSubscribeFromAsync.NoneAsyncEmitter<T>
OnSubscribeFromAsync.NoOverflowBaseAsyncEmitter<T>
OnSubscribeFromCallable<T>	Do not invoke the function until an Observer subscribes; Invokes function on each subscription.
OnSubscribeFromIterable<T>	Converts an Iterable sequence into an Observable.
OnSubscribeFromIterable.IterableProducer<T>
OnSubscribeGroupJoin<T1,T2,D1,D2,R>	Correlates two sequences when they overlap and groups the results.
OnSubscribeGroupJoin.WindowObservableFunc<T>	The reference-counted window observable.
OnSubscribeJoin<TLeft,TRight,TLeftDuration,TRightDuration,R>	Correlates the elements of two sequences based on overlapping durations.
OnSubscribeLift<T,R>	Transforms the downstream Subscriber into a Subscriber via an operator callback and calls the parent OnSubscribe.call() method with it.
OnSubscribeMap<T,R>	Applies a function of your choosing to every item emitted by an Observable, and emits the results of this transformation as a new Observable.
OnSubscribeMap.MapSubscriber<T,R>
OnSubscribeOnAssembly<T>	Captures the current stack when it is instantiated, makes it available through a field and attaches it to all passing exception.
OnSubscribeOnAssembly.OnAssemblySubscriber<T>
OnSubscribeOnAssemblyCompletable<T>	Captures the current stack when it is instantiated, makes it available through a field and attaches it to all passing exception.
OnSubscribeOnAssemblyCompletable.OnAssemblyCompletableSubscriber
OnSubscribeOnAssemblySingle<T>	Captures the current stack when it is instantiated, makes it available through a field and attaches it to all passing exception.
OnSubscribeOnAssemblySingle.OnAssemblySingleSubscriber<T>
OnSubscribePublishMulticast<T>	Multicasts notifications coming through its input Subscriber view to its client Subscribers via lockstep backpressure mode.
OnSubscribePublishMulticast.ParentSubscriber<T>	The subscriber that must be used for subscribing to the upstream source.
OnSubscribePublishMulticast.PublishProducer<T>	A Producer and Subscription that wraps a child Subscriber and manages its backpressure requests along with its unsubscription from the parent class.
OnSubscribeRange	Emit ints from start to end inclusive.
OnSubscribeRange.RangeProducer
OnSubscribeRedo<T>
OnSubscribeRedo.RedoFinite
OnSubscribeRedo.RetryWithPredicate
OnSubscribeReduce<T>
OnSubscribeReduce.ReduceSubscriber<T>
OnSubscribeReduceSeed<T,R>
OnSubscribeReduceSeed.ReduceSeedSubscriber<T,R>
OnSubscribeRefCount<T>	Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
OnSubscribeSingle<T>	Allows conversion of an Observable to a Single ensuring that exactly one item is emitted - no more and no less.
OnSubscribeTakeLastOne<T>
OnSubscribeTakeLastOne.TakeLastOneSubscriber<T>
OnSubscribeThrow<T>	An Observable that invokes onError when the Observer subscribes to it.
OnSubscribeTimerOnce	Timer that emits a single 0L and completes after the specified time.
OnSubscribeTimerPeriodically	Emit 0L after the initial period and ever increasing number after each period.
OnSubscribeToObservableFuture	Converts a Future into an Observable.
OnSubscribeToObservableFuture.ToObservableFuture<T>
OnSubscribeUsing<T,Resource>	Constructs an observable sequence that depends on a resource object.
OnSubscribeUsing.DisposeAction<Resource>
OpenHashSet<T>	A simple open hash set with add, remove and clear capabilities only.
OperatorAll<T>	Returns an Observable that emits a Boolean that indicates whether all items emitted by an Observable satisfy a condition.
OperatorAny<T>	Returns an Observable that emits true if any element of an observable sequence satisfies a condition, otherwise false.
OperatorAsObservable<T>	Hides the identity of another observable.
OperatorAsObservable.Holder	Lazy initialization via inner-class holder.
OperatorBufferWithSingleObservable<T,TClosing>	This operation takes values from the specified Observable source and stores them in a buffer until the Observable constructed using the Func0 argument, produces a value.
OperatorBufferWithSize<T>	This operation takes values from the specified Observable source and stores them in all active chunks until the buffer contains a specified number of elements.
OperatorBufferWithSize.BufferExact<T>
OperatorBufferWithSize.BufferOverlap<T>
OperatorBufferWithSize.BufferSkip<T>
OperatorBufferWithStartEndObservable<T,TOpening,TClosing>	This operation takes values from the specified Observable source and stores them in the currently active chunks.
OperatorBufferWithTime<T>	This operation takes values from the specified Observable source and stores them in a buffer.
OperatorCast<T,R>	Converts the elements of an observable sequence to the specified type.
OperatorCast.CastSubscriber<T,R>
OperatorDebounceWithSelector<T,U>	Delay the emission via another observable if no new source appears in the meantime.
OperatorDebounceWithTime<T>	This operation filters out events which are published too quickly in succession.
OperatorDebounceWithTime.DebounceState<T>	Tracks the last value to be emitted and manages completion.
OperatorDelay<T>	Delays the emission of onNext events by a given amount of time.
OperatorDelayWithSelector<T,V>	Delay the subscription and emission of the source items by a per-item observable that fires its first element.
OperatorDematerialize<T>	Reverses the effect of OperatorMaterialize by transforming the Notification objects emitted by a source Observable into the items or notifications they represent.
OperatorDematerialize.Holder	Lazy initialization via inner-class holder.
OperatorDistinct<T,U>	Returns an Observable that emits all distinct items emitted by the source.
OperatorDistinct.Holder
OperatorDistinctUntilChanged<T,U>	Returns an Observable that emits all sequentially distinct items emitted by the source.
OperatorDistinctUntilChanged.Holder
OperatorDoAfterTerminate<T>	Registers an action to be called after an Observable invokes onComplete or onError.
OperatorDoOnEach<T>	Converts the elements of an observable sequence to the specified type.
OperatorDoOnRequest<T>	This operator modifies an Observable so a given action is invoked when the Producer receives a request.
OperatorDoOnRequest.ParentSubscriber<T>
OperatorDoOnSubscribe<T>	This operator modifies an Observable so a given action is invoked when the Observable is subscribed.
OperatorDoOnUnsubscribe<T>	This operator modifies an Observable so a given action is invoked when the Observable is unsubscribed.
OperatorEagerConcatMap<T,R>
OperatorEagerConcatMap.EagerInnerSubscriber<T>
OperatorEagerConcatMap.EagerOuterProducer
OperatorEagerConcatMap.EagerOuterSubscriber<T,R>
OperatorElementAt<T>	Returns the element at a specified index in a sequence.
OperatorElementAt.InnerProducer	A producer that wraps another Producer and requests Long.MAX_VALUE when the first positive request() call comes in.
OperatorGroupBy<T,K,V>	Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as Observables, one Observable per group.
OperatorGroupBy.GroupByProducer
OperatorGroupBy.GroupBySubscriber<T,K,V>
OperatorGroupBy.GroupBySubscriber.EvictionAction<K>
OperatorGroupBy.GroupedUnicast<K,T>
OperatorGroupBy.State<T,K>
OperatorIgnoreElements<T>
OperatorIgnoreElements.Holder
OperatorMapNotification<T,R>	Applies a function of your choosing to every item emitted by an Observable, and emits the results of this transformation as a new Observable.
OperatorMapNotification.MapNotificationSubscriber<T,R>
OperatorMapPair<T,U,R>	An Observable.Operator that pairs up items emitted by a source Observable with the sequence of items emitted by the Observable that is derived from each item by means of a selector, and emits the results of this pairing.
OperatorMapPair.MapPairSubscriber<T,U,R>
OperatorMapPair.OuterInnerMapper<T,U,R>
OperatorMaterialize<T>	Turns all of the notifications from an Observable into onNext emissions, and marks them with their original notification types within Notification objects.
OperatorMaterialize.Holder	Lazy initialization via inner-class holder.
OperatorMaterialize.ParentSubscriber<T>
OperatorMerge<T>	Flattens a list of Observables into one Observable, without any transformation.
OperatorMerge.HolderDelayErrors	Lazy initialization via inner-class holder.
OperatorMerge.HolderNoDelay	Lazy initialization via inner-class holder.
OperatorMerge.InnerSubscriber<T>
OperatorMerge.MergeProducer<T>
OperatorMerge.MergeSubscriber<T>	The subscriber that observes Observables.
OperatorMulticast<T,R>	Shares a single subscription to a source through a Subject.
OperatorObserveOn<T>	Delivers events on the specified Scheduler asynchronously via an unbounded buffer.
OperatorObserveOn.ObserveOnSubscriber<T>	Observe through individual queue per observer.
OperatorOnBackpressureBuffer<T>
OperatorOnBackpressureBuffer.BufferSubscriber<T>
OperatorOnBackpressureBuffer.Holder
OperatorOnBackpressureDrop<T>
OperatorOnBackpressureDrop.Holder	Lazy initialization via inner-class holder.
OperatorOnBackpressureLatest<T>	An operator which drops all but the last received value in case the downstream doesn't request more.
OperatorOnBackpressureLatest.Holder	Holds a singleton instance initialized on class-loading.
OperatorOnBackpressureLatest.LatestEmitter<T>	A terminable producer which emits the latest items on request.
OperatorOnBackpressureLatest.LatestSubscriber<T>
OperatorOnErrorResumeNextViaFunction<T>	Instruct an Observable to pass control to another Observable (the return value of a function) rather than invoking onError if it encounters an error.
OperatorPublish<T>	A connectable observable which shares an underlying source and dispatches source values to subscribers in a backpressure-aware manner.
OperatorPublish.InnerProducer<T>	A Producer and Subscription that manages the request and unsubscription state of a child subscriber in thread-safe manner.
OperatorPublish.PublishSubscriber<T>
OperatorReplay<T>
OperatorReplay.BoundedReplayBuffer<T>	Base class for bounded buffering with options to specify an enter and leave transforms and custom truncation behavior.
OperatorReplay.InnerProducer<T>	A Producer and Subscription that manages the request and unsubscription state of a child subscriber in thread-safe manner.
OperatorReplay.Node	Represents a node in a bounded replay buffer's linked list.
OperatorReplay.ReplayBuffer<T>	The interface for interacting with various buffering logic.
OperatorReplay.ReplaySubscriber<T>
OperatorReplay.SizeAndTimeBoundReplayBuffer<T>	Size and time bound replay buffer.
OperatorReplay.SizeBoundReplayBuffer<T>	A bounded replay buffer implementation with size limit only.
OperatorReplay.UnboundedReplayBuffer<T>	Holds an unbounded list of events.
OperatorRetryWithPredicate<T>
OperatorRetryWithPredicate.SourceSubscriber<T>
OperatorSampleWithObservable<T,U>	Sample with the help of another observable.
OperatorSampleWithTime<T>	Returns an Observable that emits the results of sampling the items emitted by the source Observable at a specified time interval.
OperatorSampleWithTime.SamplerSubscriber<T>	The source subscriber and sampler.
OperatorScan<R,T>	Returns an Observable that applies a function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by an Observable into the same function, and so on until all items have been emitted by the source Observable, emitting the result of each of these iterations.
OperatorScan.InitialProducer<R>
OperatorSequenceEqual	Returns an Observable that emits a single Boolean value that indicates whether two source Observables emit sequences of items that are equivalent to each other.
OperatorSerialize<T>
OperatorSerialize.Holder	Lazy initialization via inner-class holder.
OperatorSingle<T>	If the Observable completes after emitting a single item that matches a predicate, return an Observable containing that item.
OperatorSingle.Holder
OperatorSingle.ParentSubscriber<T>
OperatorSkip<T>	Returns an Observable that skips the first num items emitted by the source Observable.
OperatorSkipLast<T>	Bypasses a specified number of elements at the end of an observable sequence.
OperatorSkipLastTimed<T>	Skip delivering values in the time window before the values.
OperatorSkipTimed<T>	Skips elements until a specified time elapses.
OperatorSkipUntil<T,U>	Skip elements from the source Observable until the secondary observable fires an element.
OperatorSkipWhile<T>	Skips any emitted source items as long as the specified condition holds true.
OperatorSubscribeOn<T>	Subscribes Observers on the specified Scheduler.
OperatorSwitch<T>	Transforms an Observable that emits Observables into a single Observable that emits the items emitted by the most recently published of those Observables.
OperatorSwitch.Holder	Lazy initialization via inner-class holder.
OperatorSwitch.HolderDelayError	Lazy initialization via inner-class holder.
OperatorSwitch.InnerSubscriber<T>
OperatorSwitch.SwitchSubscriber<T>
OperatorSwitchIfEmpty<T>	If the Observable completes without emitting any items, subscribe to an alternate Observable.
OperatorSwitchIfEmpty.AlternateSubscriber<T>
OperatorSwitchIfEmpty.ParentSubscriber<T>
OperatorTake<T>	An Observable that emits the first num items emitted by the source Observable.
OperatorTakeLast<T>	Returns an Observable that emits the at most the last count items emitted by the source Observable.
OperatorTakeLast.TakeLastSubscriber<T>
OperatorTakeLastTimed<T>	Returns an Observable that emits the last count items emitted by the source Observable.
OperatorTakeLastTimed.TakeLastTimedSubscriber<T>
OperatorTakeTimed<T>	Takes values from the source until the specific time elapses.
OperatorTakeTimed.TakeSubscriber<T>	Subscribed to source and scheduled on a worker.
OperatorTakeUntil<T,E>	Returns an Observable that emits the items from the source Observable until another Observable emits an item.
OperatorTakeUntilPredicate<T>	Returns an Observable that emits items emitted by the source Observable until the provided predicate returns false
OperatorTakeWhile<T>	O Returns an Observable that emits items emitted by the source Observable as long as a specified condition is true.
OperatorThrottleFirst<T>	Throttle by windowing a stream and returning the first value in each window.
OperatorTimeInterval<T>	Records the time interval between consecutive elements in an observable sequence.
OperatorTimeout<T>	Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers.
OperatorTimeoutBase<T>
OperatorTimeoutBase.FirstTimeoutStub<T>	Set up the timeout action on the first value.
OperatorTimeoutBase.TimeoutStub<T>	Set up the timeout action based on every value
OperatorTimeoutBase.TimeoutSubscriber<T>
OperatorTimeoutWithSelector<T,U,V>	Returns an Observable that mirrors the source Observable.
OperatorTimestamp<T>	Wraps each item emitted by a source Observable in a Timestamped object.
OperatorToMap<T,K,V>	Maps the elements of the source observable into a java.util.Map instance and emits that once the source observable completes.
OperatorToMap.DefaultToMapFactory<K,V>	The default map factory.
OperatorToMultimap<T,K,V>	Maps the elements of the source observable into a multimap (Map<K, Collection<V>>) where each key entry has a collection of the source's values.
OperatorToMultimap.DefaultMultimapCollectionFactory<K,V>	The default collection factory for a key in the multimap returning an ArrayList independent of the key.
OperatorToMultimap.DefaultToMultimapFactory<K,V>	The default multimap factory returning a HashMap.
OperatorToObservableList<T>	Returns an Observable that emits a single item, a list composed of all the items emitted by the source Observable.
OperatorToObservableList.Holder	Lazy initialization via inner-class holder.
OperatorToObservableSortedList<T>	Return an Observable that emits the items emitted by the source Observable, in a sorted order (each item emitted by the Observable must implement Comparable with respect to all other items in the sequence, or you must pass in a sort function).
OperatorToObservableSortedList.DefaultComparableFunction
OperatorUnsubscribeOn<T>	Unsubscribes on the specified Scheduler.
OperatorWindowWithObservable<T,U>	Creates non-overlapping windows of items where each window is terminated by an event from a secondary observable and a new window is started immediately.
OperatorWindowWithObservable.BoundarySubscriber<T,U>	Observes the boundary.
OperatorWindowWithObservable.SourceSubscriber<T>	Observes the source.
OperatorWindowWithObservableFactory<T,U>	Creates non-overlapping windows of items where each window is terminated by an event from a secondary observable and a new window is started immediately.
OperatorWindowWithObservableFactory.BoundarySubscriber<T,U>	Observes the boundary.
OperatorWindowWithObservableFactory.SourceSubscriber<T,U>	Observes the source.
OperatorWindowWithSize<T>	Creates windows of values into the source sequence with skip frequency and size bounds.
OperatorWindowWithSize.WindowExact<T>
OperatorWindowWithSize.WindowOverlap<T>
OperatorWindowWithSize.WindowSkip<T>
OperatorWindowWithStartEndObservable<T,U,V>	Creates potentially overlapping windows of the source items where each window is started by a value emitted by an observable and closed when an associated Observable emits a value or completes.
OperatorWindowWithStartEndObservable.SerializedSubject<T>	Serialized access to the subject.
OperatorWindowWithTime<T>	Creates windows of values into the source sequence with timed window creation, length and size bounds.
OperatorWindowWithTime.CountedSerializedSubject<T>	Record to store the subject and the emission count.
OperatorWindowWithTime.State<T>	The immutable windowing state with one subject.
OperatorWithLatestFrom<T,U,R>	Combines values from two sources only when the main source emits.
OperatorWithLatestFromMany<T,R>
OperatorWithLatestFromMany.WithLatestMainSubscriber<T,R>
OperatorWithLatestFromMany.WithLatestOtherSubscriber
OperatorZip<R>	Returns an Observable that emits the results of a function applied to sets of items emitted, in sequence, by two or more other Observables.
OperatorZip.Zip<R>
OperatorZip.ZipProducer<R>
OperatorZipIterable<T1,T2,R>
PlatformDependent	Allow platform dependent logic such as checks for Android.
Pow2
Producer	Interface that establishes a request-channel between an Observable and a Subscriber and allows the Subscriber to request a certain amount of items from the Observable (otherwise known as backpressure).
ProducerArbiter	Producer that allows changing an underlying producer atomically and correctly resume with the accumulated requests.
ProducerObserverArbiter<T>	Producer that serializes any event emission with requesting and producer changes.
PublishSubject<T>	Subject that, once an Observer has subscribed, emits all subsequently observed items to the subscriber.
QueuedProducer<T>	Producer that holds an unbounded (or custom) queue, handles terminal events, enqueues values and relays them to a child subscriber on request.
QueuedValueProducer<T>	Producer that holds an unbounded (or custom) queue to enqueue values and relays them to a child subscriber on request.
QueueProgressIndicators	This interface is provided for monitoring purposes only and is only available on queues where it is easy to provide it.
RefCountSubscription	Keeps track of the sub-subscriptions and unsubscribes the underlying subscription once all sub-subscriptions have unsubscribed.
RefCountSubscription.InnerSubscription	The individual sub-subscriptions.
RefCountSubscription.State
ReplaySubject<T>	Subject that buffers all items it observes and replays them to any Observer that subscribes.
ReplaySubject.ReplayBuffer<T>	The base interface for buffering signals to be replayed to individual Subscribers.
ReplaySubject.ReplayProducer<T>	A producer and subscription implementation that tracks the current replay position of a particular subscriber.
ReplaySubject.ReplaySizeAndTimeBoundBuffer<T>
ReplaySubject.ReplaySizeAndTimeBoundBuffer.TimedNode<T>
ReplaySubject.ReplaySizeBoundBuffer<T>
ReplaySubject.ReplaySizeBoundBuffer.Node<T>
ReplaySubject.ReplayState<T>	Holds onto the array of Subscriber-wrapping ReplayProducers and the buffer that holds values to be replayed; it manages subscription and signal dispatching.
ReplaySubject.ReplayUnboundedBuffer<T>	An unbounded ReplayBuffer implementation that uses linked-arrays to avoid copy-on-grow situation with ArrayList.
RxJavaCompletableExecutionHook	Abstract ExecutionHook with invocations at different lifecycle points of Completable execution with a default no-op implementation.
RxJavaErrorHandler	Abstract class for defining error handling logic in addition to the normal Observer.onError(Throwable) behavior.
RxJavaHooks	Utility class that holds hooks for various Observable, Single and Completable lifecycle-related points as well as Scheduler hooks.
RxJavaObservableExecutionHook	Abstract ExecutionHook with invocations at different lifecycle points of Observable execution with a default no-op implementation.
RxJavaObservableExecutionHookDefault	Default no-op implementation of RxJavaObservableExecutionHook
RxJavaPlugins	Registry for plugin implementations that allows global override and handles the retrieval of correct implementation based on order of precedence: plugin registered globally via register methods in this class plugin registered and retrieved using System.getProperty(String) (see get methods for property names) default implementation
RxJavaSchedulersHook	This plugin class provides 2 ways to customize Scheduler functionality 1.
RxJavaSingleExecutionHook	Abstract ExecutionHook with invocations at different lifecycle points of Single execution with a default no-op implementation.
RxJavaSingleExecutionHookDefault	Default no-op implementation of RxJavaSingleExecutionHook
RxRingBuffer	This assumes Spsc or Spmc usage.
RxThreadFactory
SafeCompletableSubscriber	Wraps another CompletableSubscriber and handles exceptions thrown from onError and onCompleted.
SafeSubscriber<T>	SafeSubscriber is a wrapper around Subscriber that ensures that the Subscriber complies with the Observable contract.
ScalarSynchronousObservable<T>	An Observable that emits a single constant scalar value to Subscribers.
ScalarSynchronousObservable.JustOnSubscribe<T>	The OnSubscribe callback for the Observable constructor.
ScalarSynchronousObservable.ScalarAsyncOnSubscribe<T>	The OnSubscribe implementation that creates the ScalarAsyncProducer for each incoming subscriber.
ScalarSynchronousObservable.ScalarAsyncProducer<T>	Represents a producer which schedules the emission of a scalar value on the first positive request via the given scheduler callback.
ScalarSynchronousObservable.WeakSingleProducer<T>	This is the weak version of SingleProducer that uses plain fields to avoid reentrancy and as such is not threadsafe for concurrent request() calls.
ScalarSynchronousSingle<T>
ScalarSynchronousSingle.DirectScheduledEmission<T>	Optimized observeOn for scalar value observed on the EventLoopsScheduler.
ScalarSynchronousSingle.NormalScheduledEmission<T>	Emits a scalar value on a general scheduler.
ScalarSynchronousSingle.ScalarSynchronousSingleAction<T>	Action that emits a single value when called.
ScheduledAction	A Runnable that executes an Action0 and can be cancelled.
ScheduledAction.Remover	Remove a child subscription from a composite when unsubscribing.
ScheduledAction.Remover2	Remove a child subscription from a composite when unsubscribing.
Scheduler	A Scheduler is an object that schedules units of work.
Scheduler.Worker	Sequential Scheduler for executing actions on a single thread or event loop.
SchedulerLifecycle	Represents the capability of a Scheduler to be start or shut down its maintained threads.
Schedulers	Static factory methods for creating Schedulers.
SchedulerWhen	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
SchedulerWhen.DelayedAction
SchedulerWhen.ImmediateAction
SchedulerWhen.ScheduledAction
SerializedObserver<T>	Enforces single-threaded, serialized, ordered execution of SerializedObserver.onNext(T), SerializedObserver.onCompleted(), and SerializedObserver.onError(java.lang.Throwable).
SerializedObserver.FastList
SerializedSubject<T,R>	Wraps a Subject so that it is safe to call its various on methods from different threads.
SerializedSubscriber<T>	Enforces single-threaded, serialized, ordered execution of SerializedSubscriber.onNext(T), SerializedSubscriber.onCompleted(), and SerializedSubscriber.onError(java.lang.Throwable).
SerialSubscription	Represents a subscription whose underlying subscription can be swapped for another subscription which causes the previous underlying subscription to be unsubscribed.
SerialSubscription.State
Single<T>	The Single class implements the Reactive Pattern for a single value response.
Single.OnSubscribe<T>	Invoked when Single.execute is called.
Single.Transformer<T,R>	Transformer function used by Single.compose(rx.Single.Transformer<? super T, ? extends R>).
SingleDelayedProducer<T>	Producer that emits a single value and completes the child subscriber once that single value is set on it and the child requested items (maybe both asynchronously).
SingleDoAfterTerminate<T>	Execute an action after onSuccess or onError has been delivered.
SingleDoAfterTerminate.SingleDoAfterTerminateSubscriber<T>
SingleOnSubscribeDelaySubscriptionOther<T>	Delays the subscription to the Single until the Observable fires an event or completes.
SingleOnSubscribeMap<T,R>	Applies a function of your choosing to every item emitted by an Single, and emits the results of this transformation as a new Single.
SingleOnSubscribeMap.MapSubscriber<T,R>
SingleOnSubscribeUsing<T,Resource>	Generates a resource, derives a Single from it and disposes that resource once the Single terminates.
SingleOperatorOnErrorResumeNext<T>
SingleOperatorZip
SingleProducer<T>	A producer which emits a single value and completes the child on the first positive request.
SingleSubscriber<T>	Provides a mechanism for receiving push-based notifications.
SleepingAction
SpmcArrayQueue<E>
SpmcArrayQueueConsumerField<E>
SpmcArrayQueueL1Pad<E>
SpmcArrayQueueL2Pad<E>
SpmcArrayQueueL3Pad<E>
SpmcArrayQueueMidPad<E>
SpmcArrayQueueProducerField<E>
SpmcArrayQueueProducerIndexCacheField<E>
SpscArrayQueue<E>	A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
SpscArrayQueueColdField<E>
SpscArrayQueueConsumerField<E>
SpscArrayQueueL1Pad<E>
SpscArrayQueueL2Pad<E>
SpscArrayQueueL3Pad<E>
SpscArrayQueueProducerFields<E>
SpscAtomicArrayQueue<E>	A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
SpscExactAtomicArrayQueue<T>	A single-producer single-consumer bounded queue with exact capacity tracking.
SpscLinkedArrayQueue<T>	A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower than the producer.
SpscLinkedAtomicQueue<E>	This is a weakened version of the MPSC algorithm as presented on 1024 Cores by D.
SpscLinkedQueue<E>	This is a weakened version of the MPSC algorithm as presented on 1024 Cores by D.
SpscUnboundedArrayQueue<E>
SpscUnboundedArrayQueueConsumerColdField<E>
SpscUnboundedArrayQueueConsumerField<E>
SpscUnboundedArrayQueueL2Pad<E>
SpscUnboundedArrayQueueProducerColdFields<E>
SpscUnboundedArrayQueueProducerFields<E>
SpscUnboundedAtomicArrayQueue<T>	A single-producer single-consumer queue with unbounded capacity.
Subject<T,R>	Represents an object that is both an Observable and an Observer.
SubjectSubscriptionManager<T>	Represents the typical state and OnSubscribe logic for a Subject implementation.
SubjectSubscriptionManager.State<T>	State-machine representing the termination state and active SubjectObservers.
SubjectSubscriptionManager.SubjectObserver<T>	Observer wrapping the actual Subscriber and providing various emission facilities.
Subscriber<T>	Provides a mechanism for receiving push-based notifications from Observables, and permits manual unsubscribing from these Observables.
Subscribers	Helper methods and utilities for creating and working with Subscriber objects.
Subscription	Subscription returns from Observable.subscribe(Subscriber) to allow unsubscribing.
SubscriptionList	Subscription that represents a group of Subscriptions that are unsubscribed together.
Subscriptions	Helper methods and utilities for creating and working with Subscription objects
Subscriptions.FutureSubscription	Naming classes helps with debugging.
Subscriptions.Unsubscribed	Naming classes helps with debugging.
SuppressAnimalSniffer	Suppress errors by the AnimalSniffer plugin.
SynchronizedQueue<T>	Intended for use when the `sun.misc.Unsafe` implementations can't be used.
SyncOnSubscribe<S,T>	A utility class to create OnSubscribe<T> functions that respond correctly to back pressure requests from subscribers.
SyncOnSubscribe.SubscriptionProducer<S,T>	Contains the producer loop that reacts to downstream requests of work.
SyncOnSubscribe.SyncOnSubscribeImpl<S,T>	An implementation of SyncOnSubscribe that delegates SyncOnSubscribe#next(Object, Subscriber), SyncOnSubscribe.generateState(), and SyncOnSubscribe.onUnsubscribe(Object) to provided functions/closures.
TestObserver<T>	Deprecated. use the TestSubscriber insteand.
TestScheduler	The TestScheduler is useful for debugging.
TestScheduler.CompareActionsByTime
TestScheduler.TimedAction
TestSubject<T>	A variety of Subject that is useful for testing purposes.
TestSubscriber<T>	A TestSubscriber is a variety of Subscriber that you can use for unit testing, to perform assertions, inspect received events, or wrap a mocked Subscriber.
TimeInterval<T>	A TimeInterval represents an item emitted by an Observable along with the amount of time that elapsed either since the emission of the previous item or (if there was no previous item) since the Observable was first subscribed to.
Timestamped<T>	Composite class that takes a value and a timestamp and wraps them.
TrampolineScheduler	Schedules work on the current thread but does not execute immediately.
TrampolineScheduler	Deprecated. This type was never publicly instantiable.
TrampolineScheduler.InnerCurrentThreadScheduler
TrampolineScheduler.TimedAction
UnicastSubject<T>	A Subject variant which buffers events until a single Subscriber arrives and replays them to it and potentially switches to direct delivery once the Subscriber caught up and requested an unlimited amount.
UnicastSubject.State<T>	The single-consumption replaying state.
UnsafeAccess	All use of this class MUST first check that UnsafeAccess.isUnsafeAvailable() == true otherwise NPEs will happen in environments without "suc.misc.Unsafe" such as Android.
UnsubscribeFailedException	Represents an exception used to re-throw errors thrown from Subscriber.unsubscribe().
UtilityFunctions	Utility functions for internal use that we don't want part of the public API.
UtilityFunctions.AlwaysFalse
UtilityFunctions.AlwaysTrue