object Rx extends LogSupport
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Rx
- LogSupport
- LazyLogger
- LoggingMethods
- Serializable
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Type Members
- case class CacheOp[A](input: Rx[A], lastValue: Option[A] = None, lastUpdatedNanos: Long = System.nanoTime(), expirationAfterWriteNanos: Option[Long] = None, ticker: Ticker = Ticker.systemTicker) extends UnaryRx[A, A] with RxStreamCache[A] with Product with Serializable
- case class ConcatOp[A](first: Rx[A], next: Rx[A]) extends RxStream[A] with Product with Serializable
- case class FilterOp[A](input: Rx[A], cond: (A) => Boolean) extends UnaryRx[A, A] with Product with Serializable
- case class FlatMapOp[A, B](input: Rx[A], f: (A) => Rx[B]) extends UnaryRx[A, B] with Product with Serializable
- case class IntervalOp(interval: Long, unit: TimeUnit) extends RxStream[Long] with Product with Serializable
- case class Join3Op[A, B, C](a: Rx[A], b: Rx[B], c: Rx[C]) extends RxStream[(A, B, C)] with Product with Serializable
- case class Join4Op[A, B, C, D](a: Rx[A], b: Rx[B], c: Rx[C], d: Rx[D]) extends RxStream[(A, B, C, D)] with Product with Serializable
- case class JoinOp[A, B](a: Rx[A], b: Rx[B]) extends RxStream[(A, B)] with Product with Serializable
- case class LastOp[A](input: Rx[A]) extends RxStream[Option[A]] with Product with Serializable
- case class MapOp[A, B](input: Rx[A], f: (A) => B) extends UnaryRx[A, B] with Product with Serializable
- case class NamedOp[A](input: Rx[A], name: String) extends UnaryRx[A, A] with Product with Serializable
- case class RecoverOp[A, U](input: Rx[A], f: PartialFunction[Throwable, U]) extends UnaryRx[A, U] with Product with Serializable
- case class RecoverWithOp[A, U](input: Rx[A], f: PartialFunction[Throwable, Rx[U]]) extends UnaryRx[A, U] with Product with Serializable
- case class SeqOp[A](lst: LazyF0[Seq[A]]) extends RxStream[A] with Product with Serializable
- case class SingleOp[A](v: LazyF0[A]) extends RxStream[A] with Product with Serializable
- case class TakeOp[A](input: Rx[A], n: Long) extends RxStream[A] with Product with Serializable
- case class ThrottleFirstOp[A](input: Rx[A], interval: Long, unit: TimeUnit) extends UnaryRx[A, A] with Product with Serializable
- case class ThrottleLastOp[A](input: Rx[A], interval: Long, unit: TimeUnit) extends UnaryRx[A, A] with Product with Serializable
- case class TimerOp(interval: Long, unit: TimeUnit) extends RxStream[Long] with Product with Serializable
- case class TryOp[A](v: Try[A]) extends RxStream[A] with Product with Serializable
- abstract class UnaryRx[I, A] extends RxStream[A]
- case class Zip3Op[A, B, C](a: Rx[A], b: Rx[B], c: Rx[C]) extends RxStream[(A, B, C)] with Product with Serializable
- case class Zip4Op[A, B, C, D](a: Rx[A], b: Rx[B], c: Rx[C], d: Rx[D]) extends RxStream[(A, B, C, D)] with Product with Serializable
- case class ZipOp[A, B](a: Rx[A], b: Rx[B]) extends RxStream[(A, B)] with Product with Serializable
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def concat[A, A1 >: A](a: Rx[A], b: Rx[A1]): RxStream[A1]
- def const[A](v: => A): RxStream[A]
- macro def debug(message: Any, cause: Throwable): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- macro def debug(message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- def delay(interval: Long, unit: TimeUnit): RxStream[Long]
Emits 0 once after the give delay period.
- def empty[A]: RxStream[A]
- 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 exception[A](e: Throwable): RxStream[A]
- def fromFuture[A](f: Future[A])(implicit ec: ExecutionContext): RxOption[A]
Mapping a Scala Future into Rx.
Mapping a Scala Future into Rx. While the future response is unavailable, it emits Rx.none. When the future is complete, Rx.some(A) will be returned.
The difference from Rx.future is that this method can observe the waiting state of the Future response. For example, while this returns None, you can render an icon that represents loading state.
- def fromSeq[A](lst: => Seq[A]): RxStream[A]
Create a sequence of values from Seq[A]
- def future[A](f: Future[A])(implicit ec: ExecutionContext): RxStream[A]
Mapping a Scala Future into Rx that emits a value when the future is completed.
- 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
- def interval(interval: Long, unit: TimeUnit): RxStream[Long]
Periodically trigger an event and report the interval millis.
Periodically trigger an event and report the interval millis. After running Rx with an interval, the cancel method must be called to stop the timer:
val c = Rx.interval(...).run { x => ... } c.cancel - def intervalMillis(intervalMillis: Long): RxStream[Long]
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[A, B, C, D](a: Rx[A], b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[(A, B, C, D)]
- def join[A, B, C](a: Rx[A], b: Rx[B], c: Rx[C]): RxStream[(A, B, C)]
- def join[A, B](a: Rx[A], b: Rx[B]): RxStream[(A, B)]
- macro def logAt(logLevel: LogLevel, message: Any): Unit
- Attributes
- protected
- Definition Classes
- LoggingMethods
- lazy val logger: Logger
- Attributes
- protected[this]
- Definition Classes
- LazyLogger
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val none: RxOption[Nothing]
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def option[A](v: => Option[A]): RxOption[A]
- def optionVariable[A](v: Option[A]): RxOptionVar[A]
- def sequence[A](values: A*): RxStream[A]
Create a sequence of values
- def single[A](v: => A): RxStream[A]
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def timer(interval: Long, unit: TimeUnit): RxStream[Long]
Emits 0 once after the give delay period.
- def toString(): String
- Definition Classes
- 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 variable[A](v: A): RxVar[A]
- 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 zip[A, B, C, D](a: Rx[A], b: Rx[B], c: Rx[C], d: Rx[D]): RxStream[(A, B, C, D)]
- def zip[A, B, C](a: Rx[A], b: Rx[B], c: Rx[C]): RxStream[(A, B, C)]
- def zip[A, B](a: Rx[A], b: Rx[B]): RxStream[(A, B)]