object Rx extends LogSupport
- Alphabetic
- By Inheritance
- Rx
- LogSupport
- LazyLogger
- LoggingMethods
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
- case class CacheOp[A](input: RxOps[A], lastValue: Option[A] = None, lastUpdatedNanos: Long = System.nanoTime(), expirationAfterWriteNanos: Option[Long] = None, ticker: Ticker = Ticker.systemTicker) extends UnaryRx[A, A] with RxCache[A] with Product with Serializable
- case class ConcatOp[A](first: RxOps[A], next: RxOps[A]) extends Rx[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) ⇒ RxOps[B]) extends UnaryRx[A, B] with Product with Serializable
- case class IntervalOp(interval: Long, unit: TimeUnit) extends Rx[Long] with Product with Serializable
- case class Join3Op[A, B, C](a: RxOps[A], b: RxOps[B], c: RxOps[C]) extends Rx[(A, B, C)] with Product with Serializable
- case class Join4Op[A, B, C, D](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D]) extends Rx[(A, B, C, D)] with Product with Serializable
- case class Join5Op[A, B, C, D, E](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]) extends Rx[(A, B, C, D, E)] with Product with Serializable
- case class JoinOp[A, B](a: RxOps[A], b: RxOps[B]) extends Rx[(A, B)] with Product with Serializable
- case class LastOp[A](input: RxOps[A]) extends Rx[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: RxOps[A], name: String) extends UnaryRx[A, A] with Product with Serializable
- case class RecoverOp[A, U](input: RxOps[A], f: PartialFunction[Throwable, U]) extends UnaryRx[A, U] with Product with Serializable
- case class RecoverWithOp[A, U](input: RxOps[A], f: PartialFunction[Throwable, RxOps[U]]) extends UnaryRx[A, U] with Product with Serializable
- case class SeqOp[A](lst: LazyF0[Seq[A]]) extends Rx[A] with Product with Serializable
- case class SingleOp[A](v: LazyF0[A]) extends Rx[A] with Product with Serializable
- case class TakeOp[A](input: RxOps[A], n: Long) extends Rx[A] with Product with Serializable
- case class TapOnOp[A](input: RxOps[A], f: PartialFunction[Try[A], Unit]) extends UnaryRx[A, A] with Product with Serializable
- case class ThrottleFirstOp[A](input: RxOps[A], interval: Long, unit: TimeUnit) extends UnaryRx[A, A] with Product with Serializable
- case class ThrottleLastOp[A](input: RxOps[A], interval: Long, unit: TimeUnit) extends UnaryRx[A, A] with Product with Serializable
- case class TimerOp(interval: Long, unit: TimeUnit) extends Rx[Long] with Product with Serializable
- case class TransformOp[A, B](input: Rx[A], f: (Try[A]) ⇒ B) extends Rx[B] with Product with Serializable
- case class TransformRxOp[A, B](input: Rx[A], f: (Try[A]) ⇒ RxOps[B]) extends Rx[B] with Product with Serializable
- case class TransformTryOp[A, B](input: Rx[A], f: (Try[A]) ⇒ Try[B]) extends Rx[B] with Product with Serializable
- case class TryOp[A](v: LazyF0[Try[A]]) extends Rx[A] with Product with Serializable
- abstract class UnaryRx[I, A] extends Rx[A]
- case class Zip3Op[A, B, C](a: RxOps[A], b: RxOps[B], c: RxOps[C]) extends Rx[(A, B, C)] with Product with Serializable
- case class Zip4Op[A, B, C, D](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D]) extends Rx[(A, B, C, D)] with Product with Serializable
- case class Zip5Op[A, B, C, D, E](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]) extends Rx[(A, B, C, D, E)] with Product with Serializable
- case class ZipOp[A, B](a: RxOps[A], b: RxOps[B]) extends Rx[(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( ... ) @native() @IntrinsicCandidate()
- def concat[A, A1 >: A](a: RxOps[A], b: RxOps[A1]): Rx[A1]
-
def
concatRx[A, A1 >: A](seq: Seq[RxOps[A1]]): Rx[A1]
Concatenate a sequence of Rx[A] into a single Rx[A]
-
def
const[A](v: ⇒ A): Rx[A]
Provide a constant value by immediately evaluating the given input
-
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): Rx[Long]
Emits 0 once after the give delay period.
- def empty[A]: Rx[A]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): 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): Rx[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]): Rx[A]
Create a sequence of values from Seq[A]
- def fromTry[A](t: Try[A]): Rx[A]
-
def
future[A](f: Future[A])(implicit ec: ExecutionContext): Rx[A]
Mapping a Scala Future into Rx that emits a value when the future is completed.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
-
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): Rx[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): Rx[Long]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def join[A, B, C, D, E](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]): Rx[(A, B, C, D, E)]
- def join[A, B, C, D](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D]): Rx[(A, B, C, D)]
- def join[A, B, C](a: RxOps[A], b: RxOps[B], c: RxOps[C]): Rx[(A, B, C)]
- def join[A, B](a: RxOps[A], b: RxOps[B]): Rx[(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() @IntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
- def option[A](v: ⇒ Option[A]): RxOption[A]
- def optionVariable[A](v: Option[A]): RxOptionVar[A]
-
def
sequence[A](values: A*): Rx[A]
Create a sequence of values
-
def
single[A](v: ⇒ A): Rx[A]
Create a lazily evaluated single value
- def some[A](v: ⇒ A): RxOption[A]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
timer(interval: Long, unit: TimeUnit): Rx[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( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
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](seq: Seq[Rx[A]]): Rx[Seq[A]]
Combine a sequence of Rx[A] into a single Rx[Seq[A]]
- def zip[A, B, C, D, E](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]): Rx[(A, B, C, D, E)]
- def zip[A, B, C, D](a: RxOps[A], b: RxOps[B], c: RxOps[C], d: RxOps[D]): Rx[(A, B, C, D)]
- def zip[A, B, C](a: RxOps[A], b: RxOps[B], c: RxOps[C]): Rx[(A, B, C)]
- def zip[A, B](a: RxOps[A], b: RxOps[B]): Rx[(A, B)]