BoundedReplaySubject

Instance Constructors

new BoundedReplaySubject(asJavaSubject: ReplaySubject[T])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++[U >: T](that: Observable[U]): Observable[U]

Definition Classes
Observable
def +:[U >: T](elem: U): Observable[U]

Definition Classes
Observable
def :+[U >: T](elem: U): Observable[U]

Definition Classes
Observable
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def amb[U >: T](that: Observable[U]): Observable[U]

Definition Classes
Observable
def apply(subscriber: Subscriber[T]): Subscription

Definition Classes
Observable
def apply(observer: Observer[T]): Subscription

Definition Classes
Observable
final def asInstanceOf[T0]: T0

Definition Classes
Any
val asJavaObservable: Observable[_ <: T]

Definition Classes
Subject → Observable
val asJavaObserver: Observer[_ >: T]

Definition Classes
Subject → Observer
val asJavaSubject: ReplaySubject[T]

Definition Classes
BoundedReplaySubject → Subject
def cache(capacity: Int): Observable[T]

Definition Classes
Observable
def cache: Observable[T]

Definition Classes
Observable
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[R](pf: PartialFunction[T, R]): Observable[R]

Definition Classes
Observable
def combineLatest[U](that: Observable[U]): Observable[(T, U)]

Definition Classes
Observable
def combineLatestWith[U, R](that: Observable[U])(selector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
def concat[U](implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

Definition Classes
Observable
def concatMap[R](f: (T) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
def contains[U >: T](elem: U): Observable[Boolean]

Definition Classes
Observable
def count(p: (T) ⇒ Boolean): Observable[Int]

Definition Classes
Observable
def countLong: Observable[Long]

Definition Classes
Observable
def debounce(timeout: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def debounce(timeout: Duration): Observable[T]

Definition Classes
Observable
def debounce(debounceSelector: (T) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def delay(subscriptionDelay: () ⇒ Observable[Any], itemDelay: (T) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def delay(itemDelay: (T) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def delay(delay: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def delay(delay: Duration): Observable[T]

Definition Classes
Observable
def delaySubscription(subscriptionDelay: () ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def delaySubscription(delay: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def delaySubscription(delay: Duration): Observable[T]

Definition Classes
Observable
def dematerialize[U](implicit evidence: <:<[Observable[T], Observable[Notification[U]]]): Observable[U]

Definition Classes
Observable
def distinct[U](keySelector: (T) ⇒ U): Observable[T]

Definition Classes
Observable
def distinct: Observable[T]

Definition Classes
Observable
def distinctUntilChanged[U](keySelector: (T) ⇒ U): Observable[T]

Definition Classes
Observable
def distinctUntilChanged: Observable[T]

Definition Classes
Observable
def doOnCompleted(onCompleted: ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnEach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit, onCompleted: () ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnEach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnEach(onNext: (T) ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnEach(observer: Observer[T]): Observable[T]

Definition Classes
Observable
def doOnError(onError: (Throwable) ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnNext(onNext: (T) ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnRequest(onRequest: (Long) ⇒ Unit): Observable[T]

Definition Classes
Observable
Annotations
@Beta()
def doOnSubscribe(onSubscribe: ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnTerminate(onTerminate: ⇒ Unit): Observable[T]

Definition Classes
Observable
def doOnUnsubscribe(onUnsubscribe: ⇒ Unit): Observable[T]

Definition Classes
Observable
def drop(time: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def drop(time: Duration): Observable[T]

Definition Classes
Observable
def drop(n: Int): Observable[T]

Definition Classes
Observable
def dropRight(time: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def dropRight(time: Duration): Observable[T]

Definition Classes
Observable
def dropRight(n: Int): Observable[T]

Definition Classes
Observable
def dropUntil(other: Observable[Any]): Observable[T]

Definition Classes
Observable
def dropWhile(predicate: (T) ⇒ Boolean): Observable[T]

Definition Classes
Observable
def elementAt(index: Int): Observable[T]

Definition Classes
Observable
def elementAtOrDefault[U >: T](index: Int, default: U): Observable[U]

Definition Classes
Observable
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def exists(p: (T) ⇒ Boolean): Observable[Boolean]

Definition Classes
Observable
def filter(predicate: (T) ⇒ Boolean): Observable[T]

Definition Classes
Observable
def filterNot(p: (T) ⇒ Boolean): Observable[T]

Definition Classes
Observable
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def finallyDo(action: ⇒ Unit): Observable[T]

Definition Classes
Observable
def first: Observable[T]

Definition Classes
Observable
def firstOrElse[U >: T](default: ⇒ U): Observable[U]

Definition Classes
Observable
def flatMap[R](maxConcurrent: Int, onNext: (T) ⇒ Observable[R], onError: (Throwable) ⇒ Observable[R], onCompleted: () ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
Annotations
@Beta()
def flatMap[R](onNext: (T) ⇒ Observable[R], onError: (Throwable) ⇒ Observable[R], onCompleted: () ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
def flatMap[R](maxConcurrent: Int, f: (T) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
Annotations
@Beta()
def flatMap[R](f: (T) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
def flatMapIterable[R](collectionSelector: (T) ⇒ Iterable[R]): Observable[R]

Definition Classes
Observable
def flatMapIterableWith[U, R](collectionSelector: (T) ⇒ Iterable[U])(resultSelector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
def flatMapWith[U, R](maxConcurrent: Int, collectionSelector: (T) ⇒ Observable[U])(resultSelector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
Annotations
@Beta()
def flatMapWith[U, R](collectionSelector: (T) ⇒ Observable[U])(resultSelector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
def flatten[U](maxConcurrent: Int)(implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

Definition Classes
Observable
def flatten[U](implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

Definition Classes
Observable
def flattenDelayError[U](implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

Definition Classes
Observable
def foldLeft[R](initialValue: R)(accumulator: (R, T) ⇒ R): Observable[R]

Definition Classes
Observable
def forall(predicate: (T) ⇒ Boolean): Observable[Boolean]

Definition Classes
Observable
def foreach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit, onComplete: () ⇒ Unit): Unit

Definition Classes
Observable
def foreach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit): Unit

Definition Classes
Observable
def foreach(onNext: (T) ⇒ Unit): Unit

Definition Classes
Observable
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getThrowable: Throwable

Definition Classes
Subject
Annotations
@Experimental()
def getValue: T

Definition Classes
Subject
Annotations
@Experimental()
def getValues: Seq[T]

Definition Classes
Subject
Annotations
@Experimental()
def groupBy[K, V](keySelector: (T) ⇒ K, valueSelector: (T) ⇒ V): Observable[(K, Observable[V])]

Definition Classes
Observable
def groupBy[K](f: (T) ⇒ K): Observable[(K, Observable[T])]

Definition Classes
Observable
def groupJoin[S, R](other: Observable[S])(leftDuration: (T) ⇒ Observable[Any], rightDuration: (S) ⇒ Observable[Any], resultSelector: (T, Observable[S]) ⇒ R): Observable[R]

Definition Classes
Observable
def hasCompleted: Boolean

Definition Classes
Subject
Annotations
@Experimental()
def hasObservers: Boolean

Definition Classes
Subject
def hasThrowable: Boolean

Definition Classes
Subject
Annotations
@Experimental()
def hasValue: Boolean

Definition Classes
Subject
Annotations
@Experimental()
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: Observable[T]

Definition Classes
Observable
def headOption: Observable[Option[T]]

Definition Classes
Observable
def headOrElse[U >: T](default: ⇒ U): Observable[U]

Definition Classes
Observable
def isEmpty: Observable[Boolean]

Definition Classes
Observable
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def join[S, R](other: Observable[S])(leftDurationSelector: (T) ⇒ Observable[Any], rightDurationSelector: (S) ⇒ Observable[Any], resultSelector: (T, S) ⇒ R): Observable[R]

Definition Classes
Observable
def last: Observable[T]

Definition Classes
Observable
def lastOption: Observable[Option[T]]

Definition Classes
Observable
def lastOrElse[U >: T](default: ⇒ U): Observable[U]

Definition Classes
Observable
def length: Observable[Int]

Definition Classes
Observable
def lift[R](operator: (Subscriber[R]) ⇒ Subscriber[T]): Observable[R]

Definition Classes
Observable
def map[R](func: (T) ⇒ R): Observable[R]

Definition Classes
Observable
def materialize: Observable[Notification[T]]

Definition Classes
Observable
def merge[U >: T](that: Observable[U]): Observable[U]

Definition Classes
Observable
def mergeDelayError[U >: T](that: Observable[U]): Observable[U]

Definition Classes
Observable
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nest: Observable[Observable[T]]

Definition Classes
Observable
def nonEmpty: Observable[Boolean]

Definition Classes
Observable
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def observeOn(scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def onBackpressureBlock: Observable[T]

Definition Classes
Observable
Annotations
@Experimental()
def onBackpressureBlock(maxQueueLength: Int): Observable[T]

Definition Classes
Observable
Annotations
@Experimental()
def onBackpressureBuffer(capacity: Long, onOverflow: ⇒ Unit): Observable[T]

Definition Classes
Observable
Annotations
@Beta()
def onBackpressureBuffer(capacity: Long): Observable[T]

Definition Classes
Observable
Annotations
@Beta()
def onBackpressureBuffer: Observable[T]

Definition Classes
Observable
def onBackpressureDrop(onDrop: (T) ⇒ Unit): Observable[T]

Definition Classes
Observable
Annotations
@Experimental()
def onBackpressureDrop: Observable[T]

Definition Classes
Observable
def onBackpressureLatest: Observable[T]

Definition Classes
Observable
Annotations
@Experimental()
def onCompleted(): Unit

Definition Classes
Subject → Observer
def onError(error: Throwable): Unit

Definition Classes
Subject → Observer
def onErrorResumeNext[U >: T](resumeFunction: (Throwable) ⇒ Observable[U]): Observable[U]

Definition Classes
Observable
def onErrorReturn[U >: T](resumeFunction: (Throwable) ⇒ U): Observable[U]

Definition Classes
Observable
def onExceptionResumeNext[U >: T](resumeSequence: Observable[U]): Observable[U]

Definition Classes
Observable
def onNext(value: T): Unit

Definition Classes
Subject → Observer
def orElse[U >: T](default: ⇒ U): Observable[U]

Definition Classes
Observable
def product[U >: T](implicit num: Numeric[U]): Observable[U]

Definition Classes
Observable
def publish[R](selector: (Observable[T]) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
def publish: ConnectableObservable[T]

Definition Classes
Observable
def reduce[U >: T](accumulator: (U, U) ⇒ U): Observable[U]

Definition Classes
Observable
def repeat(count: Long, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def repeat(count: Long): Observable[T]

Definition Classes
Observable
def repeat(scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def repeat: Observable[T]

Definition Classes
Observable
def repeatWhen(notificationHandler: (Observable[Unit]) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def repeatWhen(notificationHandler: (Observable[Unit]) ⇒ Observable[Any], scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def replay(scheduler: Scheduler): ConnectableObservable[T]

Definition Classes
Observable
def replay(time: Duration, scheduler: Scheduler): ConnectableObservable[T]

Definition Classes
Observable
def replay(time: Duration): ConnectableObservable[T]

Definition Classes
Observable
def replay(bufferSize: Int, scheduler: Scheduler): ConnectableObservable[T]

Definition Classes
Observable
def replay(bufferSize: Int): ConnectableObservable[T]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], time: Duration): Observable[R]

Definition Classes
Observable
def replay(bufferSize: Int, time: Duration, scheduler: Scheduler): ConnectableObservable[T]

Definition Classes
Observable
def replay(bufferSize: Int, time: Duration): ConnectableObservable[T]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], scheduler: Scheduler): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], time: Duration, scheduler: Scheduler): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], bufferSize: Int, scheduler: Scheduler): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], bufferSize: Int, time: Duration, scheduler: Scheduler): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], bufferSize: Int, time: Duration): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R], bufferSize: Int): Observable[R]

Definition Classes
Observable
def replay[R](selector: (Observable[T]) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
def replay: ConnectableObservable[T]

Definition Classes
Observable
def retry(predicate: (Int, Throwable) ⇒ Boolean): Observable[T]

Definition Classes
Observable
def retry: Observable[T]

Definition Classes
Observable
def retry(retryCount: Long): Observable[T]

Definition Classes
Observable
def retryWhen(notificationHandler: (Observable[Throwable]) ⇒ Observable[Any], scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def retryWhen(notificationHandler: (Observable[Throwable]) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def sample(sampler: Observable[Any]): Observable[T]

Definition Classes
Observable
def sample(duration: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def sample(duration: Duration): Observable[T]

Definition Classes
Observable
def scan[U >: T](accumulator: (U, U) ⇒ U): Observable[U]

Definition Classes
Observable
def scan[R](initialValue: R)(accumulator: (R, T) ⇒ R): Observable[R]

Definition Classes
Observable
def sequenceEqual[U >: T](that: Observable[U]): Observable[Boolean]

Definition Classes
Observable
def sequenceEqualWith[U >: T](that: Observable[U])(equality: (U, U) ⇒ Boolean): Observable[Boolean]

Definition Classes
Observable
def serialize: Observable[T]

Definition Classes
Observable
def share: Observable[T]

Definition Classes
Observable
def single: Observable[T]

Definition Classes
Observable
def singleOption: Observable[Option[T]]

Definition Classes
Observable
def singleOrElse[U >: T](default: ⇒ U): Observable[U]

Definition Classes
Observable
def size: Observable[Int]

Definition Classes
Observable
def sliding(timespan: Duration, timeshift: Duration, count: Int, scheduler: Scheduler): Observable[Observable[T]]

Definition Classes
Observable
def sliding(timespan: Duration, timeshift: Duration, scheduler: Scheduler): Observable[Observable[T]]

Definition Classes
Observable
def sliding(timespan: Duration, timeshift: Duration): Observable[Observable[T]]

Definition Classes
Observable
def sliding(count: Int, skip: Int): Observable[Observable[T]]

Definition Classes
Observable
def sliding[Opening](openings: Observable[Opening])(closings: (Opening) ⇒ Observable[Any]): Observable[Observable[T]]

Definition Classes
Observable
def slidingBuffer(timespan: Duration, timeshift: Duration, scheduler: Scheduler): Observable[Seq[T]]

Definition Classes
Observable
def slidingBuffer(timespan: Duration, timeshift: Duration): Observable[Seq[T]]

Definition Classes
Observable
def slidingBuffer(count: Int, skip: Int): Observable[Seq[T]]

Definition Classes
Observable
def slidingBuffer[Opening](openings: Observable[Opening])(closings: (Opening) ⇒ Observable[Any]): Observable[Seq[T]]

Definition Classes
Observable
def subscribe(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit, onCompleted: () ⇒ Unit): Subscription

Definition Classes
Observable
def subscribe(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit): Subscription

Definition Classes
Observable
def subscribe(onNext: (T) ⇒ Unit): Subscription

Definition Classes
Observable
def subscribe(subscriber: Subscriber[T]): Subscription

Definition Classes
Observable
def subscribe(observer: Observer[T]): Subscription

Definition Classes
Observable
def subscribe(): Subscription

Definition Classes
Observable
def subscribeOn(scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def sum[U >: T](implicit num: Numeric[U]): Observable[U]

Definition Classes
Observable
def switch[U](implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

Definition Classes
Observable
def switchIfEmpty[U >: T](alternate: Observable[U]): Observable[U]

Definition Classes
Observable
Annotations
@Experimental()
def switchMap[R](f: (T) ⇒ Observable[R]): Observable[R]

Definition Classes
Observable
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Observable[T]

Definition Classes
Observable
def take(time: Duration, scheduler: Scheduler): Unit

Definition Classes
Observable
def take(time: Duration): Observable[T]

Definition Classes
Observable
def take(n: Int): Observable[T]

Definition Classes
Observable
def takeRight(count: Int, time: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def takeRight(count: Int, time: Duration): Observable[T]

Definition Classes
Observable
def takeRight(time: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def takeRight(time: Duration): Observable[T]

Definition Classes
Observable
def takeRight(count: Int): Observable[T]

Definition Classes
Observable
def takeUntil(that: Observable[Any]): Observable[T]

Definition Classes
Observable
def takeUntil(stopPredicate: (T) ⇒ Boolean): Observable[T]

Definition Classes
Observable
Annotations
@Experimental()
def takeWhile(predicate: (T) ⇒ Boolean): Observable[T]

Definition Classes
Observable
def throttleFirst(skipDuration: Duration): Observable[T]

Definition Classes
Observable
def throttleFirst(skipDuration: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def throttleLast(intervalDuration: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def throttleLast(intervalDuration: Duration): Observable[T]

Definition Classes
Observable
def throttleWithTimeout(timeout: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def throttleWithTimeout(timeout: Duration): Observable[T]

Definition Classes
Observable
def timeInterval(scheduler: Scheduler): Observable[(Duration, T)]

Definition Classes
Observable
def timeInterval: Observable[(Duration, T)]

Definition Classes
Observable
def timeout[U >: T](firstTimeoutSelector: () ⇒ Observable[Any], timeoutSelector: (T) ⇒ Observable[Any], other: Observable[U]): Observable[U]

Definition Classes
Observable
def timeout(firstTimeoutSelector: () ⇒ Observable[Any], timeoutSelector: (T) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def timeout[U >: T](timeoutSelector: (T) ⇒ Observable[Any], other: Observable[U]): Observable[U]

Definition Classes
Observable
def timeout(timeoutSelector: (T) ⇒ Observable[Any]): Observable[T]

Definition Classes
Observable
def timeout[U >: T](timeout: Duration, other: Observable[U], scheduler: Scheduler): Observable[U]

Definition Classes
Observable
def timeout(timeout: Duration, scheduler: Scheduler): Observable[T]

Definition Classes
Observable
def timeout[U >: T](timeout: Duration, other: Observable[U]): Observable[U]

Definition Classes
Observable
def timeout(timeout: Duration): Observable[T]

Definition Classes
Observable
def timestamp(scheduler: Scheduler): Observable[(Long, T)]

Definition Classes
Observable
def timestamp: Observable[(Long, T)]

Definition Classes
Observable
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T, Col[T]]): Observable[Col[T]]

Definition Classes
Observable
def to[M[_, _], K, V](keySelector: (T) ⇒ K, valueSelector: (T) ⇒ V)(implicit cbf: CanBuildFrom[Nothing, (K, V), M[K, V]]): Observable[M[K, V]]

Definition Classes
Observable
def toArray[U >: T](implicit arg0: ClassTag[U]): Observable[Array[U]]

Definition Classes
Observable
def toBlocking: BlockingObservable[T]

Definition Classes
Observable
def toBuffer[U >: T]: Observable[Buffer[U]]

Definition Classes
Observable
def toIndexedSeq: Observable[IndexedSeq[T]]

Definition Classes
Observable
def toIterable: Observable[Iterable[T]]

Definition Classes
Observable
def toIterator: Observable[Iterator[T]]

Definition Classes
Observable
def toList: Observable[List[T]]

Definition Classes
Observable
def toMap[K, V](keySelector: (T) ⇒ K, valueSelector: (T) ⇒ V): Observable[Map[K, V]]

Definition Classes
Observable
def toMap[K](keySelector: (T) ⇒ K): Observable[Map[K, T]]

Definition Classes
Observable
def toMap[K, V](implicit ev: <:<[Observable[T], Observable[(K, V)]]): Observable[Map[K, V]]

Definition Classes
Observable
def toMultiMap[K, V, M <: MultiMap[K, V]](keySelector: (T) ⇒ K, valueSelector: (T) ⇒ V, multiMapFactory: ⇒ M): Observable[M]

Definition Classes
Observable
def toMultiMap[K, V](keySelector: (T) ⇒ K, valueSelector: (T) ⇒ V): Observable[MultiMap[K, V]]

Definition Classes
Observable
def toMultiMap[K, V >: T](keySelector: (T) ⇒ K): Observable[MultiMap[K, V]]

Definition Classes
Observable
def toSeq: Observable[Seq[T]]

Definition Classes
Observable
def toSerialized: SerializedSubject[T]

Definition Classes
Subject
def toSet[U >: T]: Observable[Set[U]]

Definition Classes
Observable
def toStream: Observable[Stream[T]]

Definition Classes
Observable
def toString(): String

Definition Classes
AnyRef → Any
def toTraversable: Observable[Traversable[T]]

Definition Classes
Observable
def toVector: Observable[Vector[T]]

Definition Classes
Observable
def tumbling(timespan: Duration, count: Int, scheduler: Scheduler): Observable[Observable[T]]

Definition Classes
Observable
def tumbling(timespan: Duration, count: Int): Observable[Observable[T]]

Definition Classes
Observable
def tumbling(timespan: Duration, scheduler: Scheduler): Observable[Observable[T]]

Definition Classes
Observable
def tumbling(timespan: Duration): Observable[Observable[T]]

Definition Classes
Observable
def tumbling(count: Int): Observable[Observable[T]]

Definition Classes
Observable
def tumbling(boundary: ⇒ Observable[Any]): Observable[Observable[T]]

Definition Classes
Observable
def tumblingBuffer(boundary: Observable[Any], initialCapacity: Int): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(boundary: ⇒ Observable[Any]): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(timespan: Duration, count: Int, scheduler: Scheduler): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(timespan: Duration, count: Int): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(timespan: Duration, scheduler: Scheduler): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(timespan: Duration): Observable[Seq[T]]

Definition Classes
Observable
def tumblingBuffer(count: Int): Observable[Seq[T]]

Definition Classes
Observable
def unsafeSubscribe(subscriber: Subscriber[T]): Subscription

Definition Classes
Observable
def unsubscribeOn(scheduler: Scheduler): Observable[T]

Definition Classes
Observable
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withFilter(p: (T) ⇒ Boolean): WithFilter[T]

Definition Classes
Observable
def withLatestFrom[U, R](other: Observable[U])(resultSelector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
Annotations
@Experimental()
def zip[U](that: Iterable[U]): Observable[(T, U)]

Definition Classes
Observable
def zip[U](that: Observable[U]): Observable[(T, U)]

Definition Classes
Observable
def zipWith[U, R](that: Observable[U])(selector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
def zipWith[U, R](that: Iterable[U])(selector: (T, U) ⇒ R): Observable[R]

Definition Classes
Observable
def zipWithIndex: Observable[(T, Int)]

Definition Classes
Observable

Deprecated Value Members

def flatMapWithMaxConcurrent[R](onNext: (T) ⇒ Observable[R], onError: (Throwable) ⇒ Observable[R], onCompleted: () ⇒ Observable[R], maxConcurrent: Int): Observable[R]

Definition Classes
Observable
Annotations
@deprecated
Deprecated
(Since version 0.25.0) Use Observable.flatMap[R](maxConcurrent:Int,onNext:T=>rx\.lang\.scala\.Observable[R],onError:Throwable=>rx\.lang\.scala\.Observable[R],onCompleted:()=>rx\.lang\.scala\.Observable[R])* instead. This is kept here only for backward compatibility.
def flatMapWithMaxConcurrent[R](f: (T) ⇒ Observable[R], maxConcurrent: Int): Observable[R]

Definition Classes
Observable
Annotations
@deprecated
Deprecated
(Since version 0.25.0) Use Observable.flatMap[R](maxConcurrent:Int,f:T=>rx\.lang\.scala\.Observable[R])* instead. This is kept here only for backward compatibility.
def onBackpressureBufferWithCapacity(capacity: Long, onOverflow: ⇒ Unit): Observable[T]

Definition Classes
Observable
Annotations
@deprecated
Deprecated
(Since version 0.25.0) Use Observable.onBackpressureBuffer(capacity:Long,onOverflow:=>Unit)* instead. This is kept here only for backward compatibility.
def onBackpressureBufferWithCapacity(capacity: Long): Observable[T]

Definition Classes
Observable
Annotations
@deprecated
Deprecated
(Since version 0.25.0) Use Observable.onBackpressureBuffer(capacity:Long)* instead. This is kept here only for backward compatibility.
def onBackpressureDropDo(onDrop: (T) ⇒ Unit): Observable[T]

Definition Classes
Observable
Annotations
@deprecated
Deprecated
(Since version 0.25.0) Use Observable.onBackpressureDrop(onDrop:T=>Unit)* instead. This is kept here only for backward compatibility.

Related Docs: object BoundedReplaySubject | package rx

class BoundedReplaySubject[T] extends Subject[T]

Instance Constructors

new BoundedReplaySubject(asJavaSubject: ReplaySubject[T])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[U >: T](that: Observable[U]): Observable[U]

def +:[U >: T](elem: U): Observable[U]

def :+[U >: T](elem: U): Observable[U]

final def ==(arg0: Any): Boolean

def amb[U >: T](that: Observable[U]): Observable[U]

def apply(subscriber: Subscriber[T]): Subscription

def apply(observer: Observer[T]): Subscription

final def asInstanceOf[T0]: T0

val asJavaObservable: Observable[_ <: T]

val asJavaObserver: Observer[_ >: T]

val asJavaSubject: ReplaySubject[T]

def cache(capacity: Int): Observable[T]

def cache: Observable[T]

def clone(): AnyRef

def collect[R](pf: PartialFunction[T, R]): Observable[R]

def combineLatest[U](that: Observable[U]): Observable[(T, U)]

def combineLatestWith[U, R](that: Observable[U])(selector: (T, U) ⇒ R): Observable[R]

def concat[U](implicit evidence: <:<[Observable[T], Observable[Observable[U]]]): Observable[U]

def concatMap[R](f: (T) ⇒ Observable[R]): Observable[R]

def contains[U >: T](elem: U): Observable[Boolean]

def count(p: (T) ⇒ Boolean): Observable[Int]

def countLong: Observable[Long]

def debounce(timeout: Duration, scheduler: Scheduler): Observable[T]

def debounce(timeout: Duration): Observable[T]

def debounce(debounceSelector: (T) ⇒ Observable[Any]): Observable[T]

def delay(subscriptionDelay: () ⇒ Observable[Any], itemDelay: (T) ⇒ Observable[Any]): Observable[T]

def delay(itemDelay: (T) ⇒ Observable[Any]): Observable[T]

def delay(delay: Duration, scheduler: Scheduler): Observable[T]

def delay(delay: Duration): Observable[T]

def delaySubscription(subscriptionDelay: () ⇒ Observable[Any]): Observable[T]

def delaySubscription(delay: Duration, scheduler: Scheduler): Observable[T]

def delaySubscription(delay: Duration): Observable[T]

def dematerialize[U](implicit evidence: <:<[Observable[T], Observable[Notification[U]]]): Observable[U]

def distinct[U](keySelector: (T) ⇒ U): Observable[T]

def distinct: Observable[T]

def distinctUntilChanged[U](keySelector: (T) ⇒ U): Observable[T]

def distinctUntilChanged: Observable[T]

def doOnCompleted(onCompleted: ⇒ Unit): Observable[T]

def doOnEach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit, onCompleted: () ⇒ Unit): Observable[T]

def doOnEach(onNext: (T) ⇒ Unit, onError: (Throwable) ⇒ Unit): Observable[T]

def doOnEach(onNext: (T) ⇒ Unit): Observable[T]

def doOnEach(observer: Observer[T]): Observable[T]

def doOnError(onError: (Throwable) ⇒ Unit): Observable[T]

def doOnNext(onNext: (T) ⇒ Unit): Observable[T]

def doOnRequest(onRequest: (Long) ⇒ Unit): Observable[T]

def doOnSubscribe(onSubscribe: ⇒ Unit): Observable[T]

def doOnTerminate(onTerminate: ⇒ Unit): Observable[T]

def doOnUnsubscribe(onUnsubscribe: ⇒ Unit): Observable[T]

def drop(time: Duration, scheduler: Scheduler): Observable[T]

def drop(time: Duration): Observable[T]

def drop(n: Int): Observable[T]

def dropRight(time: Duration, scheduler: Scheduler): Observable[T]

def dropRight(time: Duration): Observable[T]

def dropRight(n: Int): Observable[T]

def dropUntil(other: Observable[Any]): Observable[T]

def dropWhile(predicate: (T) ⇒ Boolean): Observable[T]

def elementAt(index: Int): Observable[T]

def elementAtOrDefault[U >: T](index: Int, default: U): Observable[U]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (T) ⇒ Boolean): Observable[Boolean]

def filter(predicate: (T) ⇒ Boolean): Observable[T]

def filterNot(p: (T) ⇒ Boolean): Observable[T]

def finalize(): Unit

def finallyDo(action: ⇒ Unit): Observable[T]

def first: Observable[T]

def firstOrElse[U >: T](default: ⇒ U): Observable[U]

def flatMap[R](maxConcurrent: Int, onNext: (T) ⇒ Observable[R], onError: (Throwable) ⇒ Observable[R], onCompleted: () ⇒ Observable[R]): Observable[R]

def flatMap[R](onNext: (T) ⇒ Observable[R], onError: (Throwable) ⇒ Observable[R], onCompleted: () ⇒ Observable[R]): Observable[R]

def flatMap[R](maxConcurrent: Int, f: (T) ⇒ Observable[R]): Observable[R]

def flatMap[R](f: (T) ⇒ Observable[R]): Observable[R]

def flatMapIterable[R](collectionSelector: (T) ⇒ Iterable[R]): Observable[R]