LiftOperators2

Abstract Value Members

abstract def liftToSelf[U](f: (Observable[T]) ⇒ Observable[U]): Self[I, U]

Attributes
protected

Concrete Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def ++[U >: T](other: ⇒ Observable[U]): Self[I, U]
def +:[U >: T](elem: U): Self[I, U]
def :+[U >: T](elem: U): Self[I, U]
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ambWith[U >: T](other: Observable[U]): Self[I, U]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def asyncBoundary[U >: T](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U): Self[I, U]
def asyncBoundary(overflowStrategy: OverflowStrategy): Self[I, T]
def buffer(timespan: FiniteDuration, maxSize: Int): Self[I, Seq[T]]
def buffer(timespan: FiniteDuration): Self[I, Seq[T]]
def buffer(count: Int, skip: Int): Self[I, Seq[T]]
def buffer(count: Int): Self[I, Seq[T]]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[U](pf: PartialFunction[T, U]): Self[I, U]
def combineLatest[U](other: Observable[U]): Self[I, (T, U)]
def combineLatestDelayError[U](other: Observable[U]): Self[I, (T, U)]
def complete: Self[I, Nothing]
def concat[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def concatDelayError[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def concatMap[U](f: (T) ⇒ Observable[U]): Self[I, U]
def concatMapDelayError[U](f: (T) ⇒ Observable[U]): Self[I, U]
def count: Self[I, Long]
def debounce[U](selector: (T) ⇒ Observable[Any], f: (T) ⇒ Observable[U]): Self[I, U]
def debounce(selector: (T) ⇒ Observable[Any]): Self[I, T]
def debounce[U](timeout: FiniteDuration, f: (T) ⇒ Observable[U]): Self[I, U]
def debounce(timeout: FiniteDuration): Self[I, T]
def debounceRepeated(period: FiniteDuration): Self[I, T]
def defaultIfEmpty[U >: T](default: U): Self[I, U]
def delay[U](selector: (T) ⇒ Observable[U]): Self[I, T]
def delay(duration: FiniteDuration): Self[I, T]
def delaySubscription(timespan: FiniteDuration): Self[I, T]
def delaySubscription[U](trigger: Observable[U]): Self[I, T]
def distinct[U](fn: (T) ⇒ U): Self[I, T]
def distinct: Self[I, T]
def distinctUntilChanged[U](fn: (T) ⇒ U): Self[I, T]
def distinctUntilChanged: Self[I, T]
def doOnCanceled(cb: ⇒ Unit): Self[I, T]
def doOnComplete(cb: ⇒ Unit): Self[I, T]
def doOnError(cb: (Throwable) ⇒ Unit): Self[I, T]
def doOnStart(cb: (T) ⇒ Unit): Self[I, T]
def doWork(cb: (T) ⇒ Unit): Self[I, T]
def drop(n: Int): Self[I, T]
def dropByTimespan(timespan: FiniteDuration): Self[I, T]
def dropWhile(p: (T) ⇒ Boolean): Self[I, T]
def dropWhileWithIndex(p: (T, Int) ⇒ Boolean): Self[I, T]
def dump(prefix: String, out: PrintStream = System.out): Self[I, T]
def echoOnce(timeout: FiniteDuration): Self[I, T]
def echoRepeated(timeout: FiniteDuration): Self[I, T]
def endWith[U >: T](elems: U*): Self[I, U]
def endWithError(error: Throwable): Self[I, T]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def error: Self[I, Throwable]
def exists(p: (T) ⇒ Boolean): Self[I, Boolean]
def filter(p: (T) ⇒ Boolean): Self[I, T]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (T) ⇒ Boolean): Self[I, T]
def firstOrElse[U >: T](default: ⇒ U): Self[I, U]
def flatMap[U](f: (T) ⇒ Observable[U]): Self[I, U]
def flatMapDelayError[U](f: (T) ⇒ Observable[U]): Self[I, U]
def flatMapLatest[U](f: (T) ⇒ Observable[U]): Self[I, U]
def flatScan[R](initial: R)(op: (R, T) ⇒ Observable[R]): Self[I, R]
def flatScanDelayError[R](initial: R)(op: (R, T) ⇒ Observable[R]): Self[I, R]
def flatten[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def flattenDelayError[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def flattenLatest[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def foldLeft[R](initial: R)(op: (R, T) ⇒ R): Self[I, R]
def forAll(p: (T) ⇒ Boolean): Self[I, Boolean]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](keyBufferSize: Int, keySelector: (T) ⇒ K): Self[I, GroupedObservable[K, T]]
def groupBy[K](keySelector: (T) ⇒ K): Self[I, GroupedObservable[K, T]]
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: Self[I, T]
def headOrElse[B >: T](default: ⇒ B): Self[I, B]
def ignoreElements: Self[I, Nothing]
def isEmpty: Self[I, Boolean]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def last: Self[I, T]
def lift[U](f: (Observable[T]) ⇒ Observable[U]): Self[I, U]
def map[U](f: (T) ⇒ U): Self[I, U]
def materialize: Self[I, Notification[T]]
def max[U >: T](implicit ev: Ordering[U]): Self[I, U]
def maxBy[U](f: (T) ⇒ U)(implicit ev: Ordering[U]): Self[I, T]
def merge[U](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U)(implicit ev: <:<[T, Observable[U]]): Self[I, U]
def merge[U](overflowStrategy: OverflowStrategy)(implicit ev: <:<[T, Observable[U]]): Self[I, U]
def merge[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def mergeDelayErrors[U](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U)(implicit ev: <:<[T, Observable[U]]): Self[I, U]
def mergeDelayErrors[U](overflowStrategy: OverflowStrategy)(implicit ev: <:<[T, Observable[U]]): Self[I, U]
def mergeDelayErrors[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def mergeMap[U](f: (T) ⇒ Observable[U]): Self[I, U]
def mergeMapDelayErrors[U](f: (T) ⇒ Observable[U]): Self[I, U]
def min[U >: T](implicit ev: Ordering[U]): Self[I, U]
def minBy[U](f: (T) ⇒ U)(implicit ev: Ordering[U]): Self[I, T]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: Self[I, Boolean]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onErrorFallbackTo[U >: T](that: ⇒ Observable[U]): Self[I, U]
def onErrorRecoverWith[U >: T](pf: PartialFunction[Throwable, Observable[U]]): Self[I, U]
def onErrorRetry(maxRetries: Long): Self[I, T]
def onErrorRetryIf(p: (Throwable) ⇒ Boolean): Self[I, T]
def onErrorRetryUnlimited: Self[I, T]
def reduce[U >: T](op: (U, U) ⇒ U): Self[I, U]
def repeat: Self[I, T]
def sample[U](sampler: Observable[U]): Self[I, T]
def sample(initialDelay: FiniteDuration, delay: FiniteDuration): Self[I, T]
def sample(delay: FiniteDuration): Self[I, T]
def sampleRepeated[U](sampler: Observable[U]): Self[I, T]
def sampleRepeated(initialDelay: FiniteDuration, delay: FiniteDuration): Self[I, T]
def sampleRepeated(delay: FiniteDuration): Self[I, T]
def scan[R](initial: R)(op: (R, T) ⇒ R): Self[I, R]
def startWith[U >: T](elems: U*): Self[I, U]
def subscribeOn(s: Scheduler): Self[I, T]
def sum[U >: T](implicit ev: Numeric[U]): Self[I, U]
def switch[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]
def switchMap[U](f: (T) ⇒ Observable[U]): Self[I, U]
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Self[I, T]
def take(timespan: FiniteDuration): Self[I, T]
def take(n: Long): Self[I, T]
def takeRight(n: Int): Self[I, T]
def takeWhile(p: (T) ⇒ Boolean): Self[I, T]
def takeWhileNotCanceled(c: BooleanCancelable): Self[I, T]
def throttleFirst(interval: FiniteDuration): Self[I, T]
def throttleLast(period: FiniteDuration): Self[I, T]
def throttleWithTimeout(timeout: FiniteDuration): Self[I, T]
def timeout[U >: T](timeout: FiniteDuration, backup: Observable[U]): Self[I, U]
def timeout(timeout: FiniteDuration): Self[I, T]
def toString(): String

Definition Classes
AnyRef → Any
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 whileBusyBuffer[U >: T](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U): Self[I, U]
def whileBusyBuffer[U >: T](overflowStrategy: Synchronous): Self[I, U]
def whileBusyDropEvents[U >: T](onOverflow: (Long) ⇒ U): Self[I, U]
def whileBusyDropEvents: Self[I, T]
def window(timespan: FiniteDuration, maxCount: Int): Self[I, Observable[T]]
def window(timespan: FiniteDuration): Self[I, Observable[T]]
def window(count: Int, skip: Int): Self[I, Observable[T]]
def window(count: Int): Self[I, Observable[T]]
def zip[U](other: Observable[U]): Self[I, (T, U)]
def zipWithIndex: Self[I, (T, Long)]

Related Doc: package observables

trait LiftOperators2[I, +T, Self[A, +B] <: Observable[B]] extends AnyRef

Abstract Value Members

abstract def liftToSelf[U](f: (Observable[T]) ⇒ Observable[U]): Self[I, U]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[U >: T](other: ⇒ Observable[U]): Self[I, U]

def +:[U >: T](elem: U): Self[I, U]

def :+[U >: T](elem: U): Self[I, U]

final def ==(arg0: Any): Boolean

def ambWith[U >: T](other: Observable[U]): Self[I, U]

final def asInstanceOf[T0]: T0

def asyncBoundary[U >: T](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U): Self[I, U]

def asyncBoundary(overflowStrategy: OverflowStrategy): Self[I, T]

def buffer(timespan: FiniteDuration, maxSize: Int): Self[I, Seq[T]]

def buffer(timespan: FiniteDuration): Self[I, Seq[T]]

def buffer(count: Int, skip: Int): Self[I, Seq[T]]

def buffer(count: Int): Self[I, Seq[T]]

def clone(): AnyRef

def collect[U](pf: PartialFunction[T, U]): Self[I, U]

def combineLatest[U](other: Observable[U]): Self[I, (T, U)]

def combineLatestDelayError[U](other: Observable[U]): Self[I, (T, U)]

def complete: Self[I, Nothing]

def concat[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

def concatDelayError[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

def concatMap[U](f: (T) ⇒ Observable[U]): Self[I, U]

def concatMapDelayError[U](f: (T) ⇒ Observable[U]): Self[I, U]

def count: Self[I, Long]

def debounce[U](selector: (T) ⇒ Observable[Any], f: (T) ⇒ Observable[U]): Self[I, U]

def debounce(selector: (T) ⇒ Observable[Any]): Self[I, T]

def debounce[U](timeout: FiniteDuration, f: (T) ⇒ Observable[U]): Self[I, U]

def debounce(timeout: FiniteDuration): Self[I, T]

def debounceRepeated(period: FiniteDuration): Self[I, T]

def defaultIfEmpty[U >: T](default: U): Self[I, U]

def delay[U](selector: (T) ⇒ Observable[U]): Self[I, T]

def delay(duration: FiniteDuration): Self[I, T]

def delaySubscription(timespan: FiniteDuration): Self[I, T]

def delaySubscription[U](trigger: Observable[U]): Self[I, T]

def distinct[U](fn: (T) ⇒ U): Self[I, T]

def distinct: Self[I, T]

def distinctUntilChanged[U](fn: (T) ⇒ U): Self[I, T]

def distinctUntilChanged: Self[I, T]

def doOnCanceled(cb: ⇒ Unit): Self[I, T]

def doOnComplete(cb: ⇒ Unit): Self[I, T]

def doOnError(cb: (Throwable) ⇒ Unit): Self[I, T]

def doOnStart(cb: (T) ⇒ Unit): Self[I, T]

def doWork(cb: (T) ⇒ Unit): Self[I, T]

def drop(n: Int): Self[I, T]

def dropByTimespan(timespan: FiniteDuration): Self[I, T]

def dropWhile(p: (T) ⇒ Boolean): Self[I, T]

def dropWhileWithIndex(p: (T, Int) ⇒ Boolean): Self[I, T]

def dump(prefix: String, out: PrintStream = System.out): Self[I, T]

def echoOnce(timeout: FiniteDuration): Self[I, T]

def echoRepeated(timeout: FiniteDuration): Self[I, T]

def endWith[U >: T](elems: U*): Self[I, U]

def endWithError(error: Throwable): Self[I, T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error: Self[I, Throwable]

def exists(p: (T) ⇒ Boolean): Self[I, Boolean]

def filter(p: (T) ⇒ Boolean): Self[I, T]

def finalize(): Unit

def find(p: (T) ⇒ Boolean): Self[I, T]

def firstOrElse[U >: T](default: ⇒ U): Self[I, U]

def flatMap[U](f: (T) ⇒ Observable[U]): Self[I, U]

def flatMapDelayError[U](f: (T) ⇒ Observable[U]): Self[I, U]

def flatMapLatest[U](f: (T) ⇒ Observable[U]): Self[I, U]

def flatScan[R](initial: R)(op: (R, T) ⇒ Observable[R]): Self[I, R]

def flatScanDelayError[R](initial: R)(op: (R, T) ⇒ Observable[R]): Self[I, R]

def flatten[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

def flattenDelayError[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

def flattenLatest[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

def foldLeft[R](initial: R)(op: (R, T) ⇒ R): Self[I, R]

def forAll(p: (T) ⇒ Boolean): Self[I, Boolean]

final def getClass(): Class[_]

def groupBy[K](keyBufferSize: Int, keySelector: (T) ⇒ K): Self[I, GroupedObservable[K, T]]

def groupBy[K](keySelector: (T) ⇒ K): Self[I, GroupedObservable[K, T]]

def hashCode(): Int