monifu.reactive.observables

LiftOperators2

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

An interface to be extended in Observable types that want to preserve the return type when applying operators. For example the result of Subject.map is still a Subject and this interface represents an utility to do just that.

Self Type
LiftOperators2[I, T, Self] with Observable[T]
Linear Supertypes
AnyRef, Any
Known Subclasses
AsyncChannel, AsyncSubject, BehaviorChannel, BehaviorSubject, GroupedObservable, ObservableChannel, PublishChannel, PublishSubject, ReplayChannel, ReplaySubject, Subject, SubjectChannel
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. LiftOperators2
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Abstract Value Members

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

    Attributes
    protected

Concrete Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

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

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

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

  7. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  8. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

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

  10. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

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

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

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

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

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

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

  17. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

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

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

  21. def complete: Self[I, Nothing]

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

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

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

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

  26. def count: Self[I, Long]

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

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

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

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

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

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

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

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

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

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

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

  38. def distinct: Self[I, T]

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

  40. def distinctUntilChanged: Self[I, T]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  55. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  56. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  57. def error: Self[I, Throwable]

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

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

  60. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

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

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

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

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

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

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

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

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

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

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

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

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

  73. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

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

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

  76. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  77. def head: Self[I, T]

  78. def headOrElse[B >: T](default: ⇒ B): Self[I, B]

  79. def ignoreElements: Self[I, Nothing]

  80. def isEmpty: Self[I, Boolean]

  81. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  82. def last: Self[I, T]

  83. def lift[U](f: (Observable[T]) ⇒ Observable[U]): Self[I, U]

  84. def map[U](f: (T) ⇒ U): Self[I, U]

  85. def materialize: Self[I, Notification[T]]

  86. def max[U >: T](implicit ev: Ordering[U]): Self[I, U]

  87. def maxBy[U](f: (T) ⇒ U)(implicit ev: Ordering[U]): Self[I, T]

  88. def merge[U](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U)(implicit ev: <:<[T, Observable[U]]): Self[I, U]

  89. def merge[U](overflowStrategy: OverflowStrategy)(implicit ev: <:<[T, Observable[U]]): Self[I, U]

  90. def merge[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

  91. def mergeDelayErrors[U](overflowStrategy: Evicted, onOverflow: (Long) ⇒ U)(implicit ev: <:<[T, Observable[U]]): Self[I, U]

  92. def mergeDelayErrors[U](overflowStrategy: OverflowStrategy)(implicit ev: <:<[T, Observable[U]]): Self[I, U]

  93. def mergeDelayErrors[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

  94. def mergeMap[U](f: (T) ⇒ Observable[U]): Self[I, U]

  95. def mergeMapDelayErrors[U](f: (T) ⇒ Observable[U]): Self[I, U]

  96. def min[U >: T](implicit ev: Ordering[U]): Self[I, U]

  97. def minBy[U](f: (T) ⇒ U)(implicit ev: Ordering[U]): Self[I, T]

  98. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  99. def nonEmpty: Self[I, Boolean]

  100. final def notify(): Unit

    Definition Classes
    AnyRef

  101. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  102. def onErrorFallbackTo[U >: T](that: ⇒ Observable[U]): Self[I, U]

  103. def onErrorRecoverWith[U >: T](pf: PartialFunction[Throwable, Observable[U]]): Self[I, U]

  104. def onErrorRetry(maxRetries: Long): Self[I, T]

  105. def onErrorRetryIf(p: (Throwable) ⇒ Boolean): Self[I, T]

  106. def onErrorRetryUnlimited: Self[I, T]

  107. def reduce[U >: T](op: (U, U) ⇒ U): Self[I, U]

  108. def repeat: Self[I, T]

  109. def sample[U](sampler: Observable[U]): Self[I, T]

  110. def sample(initialDelay: FiniteDuration, delay: FiniteDuration): Self[I, T]

  111. def sample(delay: FiniteDuration): Self[I, T]

  112. def sampleRepeated[U](sampler: Observable[U]): Self[I, T]

  113. def sampleRepeated(initialDelay: FiniteDuration, delay: FiniteDuration): Self[I, T]

  114. def sampleRepeated(delay: FiniteDuration): Self[I, T]

  115. def scan[R](initial: R)(op: (R, T) ⇒ R): Self[I, R]

  116. def startWith[U >: T](elems: U*): Self[I, U]

  117. def subscribeOn(s: Scheduler): Self[I, T]

  118. def sum[U >: T](implicit ev: Numeric[U]): Self[I, U]

  119. def switch[U](implicit ev: <:<[T, Observable[U]]): Self[I, U]

  120. def switchMap[U](f: (T) ⇒ Observable[U]): Self[I, U]

  121. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef

  122. def tail: Self[I, T]

  123. def take(timespan: FiniteDuration): Self[I, T]

  124. def take(n: Long): Self[I, T]

  125. def takeRight(n: Int): Self[I, T]

  126. def takeWhile(p: (T) ⇒ Boolean): Self[I, T]

  127. def takeWhileNotCanceled(c: BooleanCancelable): Self[I, T]

  128. def throttleFirst(interval: FiniteDuration): Self[I, T]

  129. def throttleLast(period: FiniteDuration): Self[I, T]

  130. def throttleWithTimeout(timeout: FiniteDuration): Self[I, T]

  131. def timeout[U >: T](timeout: FiniteDuration, backup: Observable[U]): Self[I, U]

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

  133. def toString(): String

    Definition Classes
    AnyRef → Any

  134. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  135. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  136. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

  138. def whileBusyBuffer[U >: T](overflowStrategy: Synchronous): Self[I, U]

  139. def whileBusyDropEvents[U >: T](onOverflow: (Long) ⇒ U): Self[I, U]

  140. def whileBusyDropEvents: Self[I, T]

  141. def window(timespan: FiniteDuration, maxCount: Int): Self[I, Observable[T]]

  142. def window(timespan: FiniteDuration): Self[I, Observable[T]]

  143. def window(count: Int, skip: Int): Self[I, Observable[T]]

  144. def window(count: Int): Self[I, Observable[T]]

  145. def zip[U](other: Observable[U]): Self[I, (T, U)]

  146. def zipWithIndex: Self[I, (T, Long)]

Inherited from AnyRef

Inherited from Any

Ungrouped