Rx - wvlet.airframe.rx.Rx

Type Members

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 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
def apply[A](v: A): RxVar[A]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
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 empty[A]: RxStream[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): RxStream[A]
def fromFuture[A](f: Future[A])(implicit ec: ExecutionContext): RxOption[A]

Mapping a Scala Future into Rx
def fromSeq[A](lst: ⇒ Seq[A]): RxStream[A]

Create a sequence of values from Seq[A]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@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
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@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 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( ... )
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, 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)]

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Rx

Related Docs: trait Rx | package rx

object Rx extends LogSupport

Type Members

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 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

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](v: A): RxVar[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

macro def debug(message: Any): Unit

def empty[A]: RxStream[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

macro def error(message: Any, cause: Throwable): Unit

macro def error(message: Any): Unit

def exception[A](e: Throwable): RxStream[A]

def fromFuture[A](f: Future[A])(implicit ec: ExecutionContext): RxOption[A]

def fromSeq[A](lst: ⇒ Seq[A]): RxStream[A]

final def getClass(): Class[_]

def hashCode(): Int

macro def info(message: Any, cause: Throwable): Unit

macro def info(message: Any): Unit

def interval(interval: Long, unit: TimeUnit): RxStream[Long]

def intervalMillis(intervalMillis: Long): RxStream[Long]

final def isInstanceOf[T0]: Boolean

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

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

val none: RxOption[Nothing]

final def notify(): Unit

final def notifyAll(): Unit

def option[A](v: ⇒ Option[A]): RxOption[A]

def optionVariable[A](v: Option[A]): RxOptionVar[A]

def sequence[A](values: A*): RxStream[A]

def single[A](v: ⇒ A): RxStream[A]

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

def toString(): String

macro def trace(message: Any, cause: Throwable): Unit

macro def trace(message: Any): Unit

def variable[A](v: A): RxVar[A]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

macro def warn(message: Any, cause: Throwable): Unit

macro def warn(message: Any): Unit

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)]

Deprecated Value Members

def finalize(): Unit