class RxVar[A] extends RxStream[A] with RxVarOps[A]
A reactive variable supporting update and propagation of the updated value to the chained operators
- Alphabetic
- By Inheritance
- RxVar
- RxVarOps
- RxStream
- LogSupport
- LazyLogger
- LoggingMethods
- Serializable
- Rx
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new RxVar(currentValue: A)
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def :=(newValue: A): Unit
- Definition Classes
- RxVarOps
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def andThen[B](f: (A) => 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
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cache[A1 >: A]: 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
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def concat[A1 >: A](other: Rx[A1]): RxStream[A1]
- Definition Classes
- RxStream
- macro def debug(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def debug(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- macro def error(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def error(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- def filter(f: (A) => Boolean): RxStream[A]
- Definition Classes
- RxStream
- def flatMap[B](f: (A) => Rx[B]): RxStream[B]
- Definition Classes
- RxStream
- def forceSet(newValue: A): Unit
- Definition Classes
- RxVarOps
- def forceUpdate(updater: (A) => A): Unit
Update the variable and force notification to subscribers
Update the variable and force notification to subscribers
- Definition Classes
- RxVarOps
- def foreach[U](f: (A) => U): Cancelable
- def foreachEvent[U](effect: (RxEvent) => U): Cancelable
- def get: A
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- macro def info(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def info(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[(A, B, C, D)]
- Definition Classes
- RxStream
- def join[B, C](b: Rx[B], c: Rx[C]): RxStream[(A, B, C)]
- Definition Classes
- RxStream
- def join[B](other: Rx[B]): RxStream[(A, 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
- def lastOption: RxOption[A]
- Definition Classes
- RxStream
- macro def logAt(logLevel: LogLevel, message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- lazy val logger: Logger
- Attributes
- protected[this]
- Definition Classes
- LazyLogger
- def map[B](f: (A) => B): RxStream[B]
- Definition Classes
- RxStream
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def parents: Seq[Rx[_]]
- 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
- 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
- def run[U](effect: (A) => 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
- def runContinuously[U](effect: (A) => 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
- def sample(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[A]
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
- def set(newValue: A): Unit
- Definition Classes
- RxVarOps
- def setException(e: Throwable): Unit
Propagate an error to the subscribers
- def startWith[A1 >: A](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
- def startWith[A1 >: A](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
- def subscribe[U](subscriber: (A) => U): Cancelable
- Definition Classes
- Rx
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def take(n: Long): RxStream[A]
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
- def throttleFirst(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[A]
Emit the first item of the source within each sampling period.
Emit the first item of the source within each sampling period. This is useful, for example, to prevent double-clicks of buttons.
- Definition Classes
- RxStream
- def throttleLast(timeWindow: Long, unit: TimeUnit = TimeUnit.MILLISECONDS): RxStream[A]
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
- def toOption[X, A1 >: A](implicit ev: <:<[A1, Option[X]]): RxOptionVar[X]
- def toRxStream: RxStream[A]
- def toSeq: Seq[A]
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
- def toString(): String
- Definition Classes
- RxVar → AnyRef → Any
- macro def trace(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def trace(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- def update(updater: (A) => A, force: Boolean = false): Unit
Updates the variable and trigger the recalculation of the subscribers currentValue => newValue
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- macro def warn(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def warn(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- def withFilter(f: (A) => Boolean): RxStream[A]
- Definition Classes
- RxStream
- def withName(name: String): RxStream[A]
- Definition Classes
- RxStream
- def zip[B, C, D](b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[(A, B, C, D)]
- Definition Classes
- RxStream
- def zip[B, C](b: Rx[B], c: Rx[C]): RxStream[(A, B, C)]
- Definition Classes
- RxStream
- def zip[B](other: Rx[B]): RxStream[(A, 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
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated