Packages

case class ZipOp[A, B](a: Rx[A], b: Rx[B]) extends RxStream[(A, B)] with Product with Serializable

Linear Supertypes
Product, Equals, RxStream[(A, B)], LogSupport, LazyLogger, LoggingMethods, Serializable, Serializable, Rx[(A, B)], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ZipOp
  2. Product
  3. Equals
  4. RxStream
  5. LogSupport
  6. LazyLogger
  7. LoggingMethods
  8. Serializable
  9. Serializable
  10. Rx
  11. AnyRef
  12. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ZipOp(a: Rx[A], b: Rx[B])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. val a: Rx[A]
  5. def andThen[B](f: ((A, B)) ⇒ Future[B])(implicit ex: ExecutionContext): RxStream[B]

    Combine Rx stream and Future operators.

    Combine Rx stream and Future operators.

    This method is useful when you need to call RPC multiple times and chain the next operation after receiving the response.

    Rx.intervalMillis(1000)
  .andThen { i => callRpc(...) } // Returns Future
  .map { (rpcReturnValue) => ... } // Use the Future response
    Definition Classes
    RxStream
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. val b: Rx[B]
  8. def cache[A1 >: (A, B)]: RxStreamCache[A1]

    Cache the last item, and emit the cached value if available.

    Cache the last item, and emit the cached value if available.

    The cached value will be preserved to the operator itself even after cancelling the subscription. Re-subscription of this operator will immediately return the cached value to the downstream operator.

    This operator is useful if we need to involve time-consuming process, and want to reuse the last result: val v = Rx.intervalMillis(1000).map(i => (heavy process)).cache v.map { x => ... }

    Definition Classes
    RxStream
  9. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native() @HotSpotIntrinsicCandidate()
  10. def concat[A1 >: (A, B)](other: Rx[A1]): RxStream[A1]
    Definition Classes
    RxStream
  11. macro def debug(message: Any, cause: Throwable): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  12. macro def debug(message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  13. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. macro def error(message: Any, cause: Throwable): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  15. macro def error(message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  16. def filter(f: ((A, B)) ⇒ Boolean): RxStream[(A, B)]
    Definition Classes
    RxStream
  17. def flatMap[B](f: ((A, B)) ⇒ Rx[B]): RxStream[B]
    Definition Classes
    RxStream
  18. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  19. macro def info(message: Any, cause: Throwable): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  20. macro def info(message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. def join[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[((A, B), B, C, D)]
    Definition Classes
    RxStream
  23. def join[B, C](b: Rx[B], c: Rx[C]): RxStream[((A, B), B, C)]
    Definition Classes
    RxStream
  24. def join[B](other: Rx[B]): RxStream[((A, B), B)]

    Emit a new output if one of Rx[A] or Rx[B] is changed.

    Emit a new output if one of Rx[A] or Rx[B] is changed.

    This method is useful when you need to monitor multiple Rx objects.

    Using joins will be more intuitive than nesting multiple Rx operators like Rx[A].map { x => ... Rx[B].map { ...} }.

    Definition Classes
    RxStream
  25. def lastOption: RxOption[(A, B)]
    Definition Classes
    RxStream
  26. macro def logAt(logLevel: LogLevel, message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  27. lazy val logger: Logger
    Attributes
    protected[this]
    Definition Classes
    LazyLogger
  28. def map[B](f: ((A, B)) ⇒ B): RxStream[B]
    Definition Classes
    RxStream
  29. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  30. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  31. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  32. def parents: Seq[Rx[_]]
    Definition Classes
    ZipOp → Rx
  33. def recover[U](f: PartialFunction[Throwable, U]): RxStream[U]

    Recover from a known error and emit a replacement value

    Recover from a known error and emit a replacement value

    Definition Classes
    Rx
  34. def recoverWith[A](f: PartialFunction[Throwable, Rx[A]]): RxStream[A]

    Recover from a known error and emit replacement values from a given Rx

    Recover from a known error and emit replacement values from a given Rx

    Definition Classes
    Rx
  35. def run[U](effect: ((A, B)) ⇒ U): Cancelable

    Evaluate this Rx[A] and apply the given effect function.

    Evaluate this Rx[A] and apply the given effect function. Once OnError(e) or OnCompletion is observed, it will stop the evaluation.

    Definition Classes
    Rx
  36. def runContinuously[U](effect: ((A, B)) ⇒ U): Cancelable

    Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported.

    Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported. This is useful for keep processing streams.

    Definition Classes
    Rx
  37. def sample(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B)]

    Emit the most recent item of the source within periodic time intervals.

    Emit the most recent item of the source within periodic time intervals.

    Definition Classes
    RxStream
  38. def startWith[A1 >: (A, B)](lst: Seq[A1]): RxStream[A1]

    Emit the given items first before returning the items from the source.

    Emit the given items first before returning the items from the source.

    Definition Classes
    RxStream
  39. def startWith[A1 >: (A, B)](a: A1): RxStream[A1]

    Emit the given item first before returning the items from the source.

    Emit the given item first before returning the items from the source.

    Definition Classes
    RxStream
  40. def subscribe[U](subscriber: ((A, B)) ⇒ U): Cancelable
    Definition Classes
    Rx
  41. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  42. def take(n: Long): RxStream[(A, B)]

    Take an event up to n elements.

    Take an event up to n elements. This may receive fewer events than n if the upstream operator completes before generating n elements.

    Definition Classes
    RxStream
  43. def throttleFirst(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B)]

    Emit the first item of the source within each sampling period.

    Emit the first item of the source within each sampling period. For example, this is useful to prevent double-clicks of buttons.

    Definition Classes
    RxStream
  44. def throttleLast(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[(A, B)]

    Emit the most recent item of the source within periodic time intervals.

    Emit the most recent item of the source within periodic time intervals.

    Definition Classes
    RxStream
  45. def toOption[X, A1 >: (A, B)](implicit ev: <:<[A1, Option[X]]): RxOption[X]
    Definition Classes
    RxStream
  46. def toRxStream: RxStream[(A, B)]
    Definition Classes
    RxStream → Rx
  47. def toSeq: Seq[(A, B)]

    Materialize the stream as Seq[A].

    Materialize the stream as Seq[A]. This works only for the finite stream and for Scala JVM.

    Definition Classes
    Rx
  48. macro def trace(message: Any, cause: Throwable): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  49. macro def trace(message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  50. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  51. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  52. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  53. macro def warn(message: Any, cause: Throwable): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  54. macro def warn(message: Any): Unit
    Attributes
    protected
    Definition Classes
    LoggingMethods
  55. def withFilter(f: ((A, B)) ⇒ Boolean): RxStream[(A, B)]
    Definition Classes
    RxStream
  56. def withName(name: String): RxStream[(A, B)]
    Definition Classes
    RxStream
  57. def zip[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[((A, B), B, C, D)]
    Definition Classes
    RxStream
  58. def zip[B, C](b: Rx[B], c: Rx[C]): RxStream[((A, B), B, C)]
    Definition Classes
    RxStream
  59. def zip[B](other: Rx[B]): RxStream[((A, B), B)]

    Combine two Rx streams to form a sequence of pairs.

    Combine two Rx streams to form a sequence of pairs. This will emit a new pair when both of the streams are updated.

    Definition Classes
    RxStream

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] ) @Deprecated
    Deprecated

Inherited from Product

Inherited from Equals

Inherited from RxStream[(A, B)]

Inherited from LogSupport

Inherited from LazyLogger

Inherited from LoggingMethods

Inherited from Serializable

Inherited from Serializable

Inherited from Rx[(A, B)]

Inherited from AnyRef

Inherited from Any

Ungrouped