RxOptionVar

final def !=(arg0: Any): Boolean

final def ##(): Int

def :=(newValue: Option[A]): Unit

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: (A) ⇒ Boolean): RxOption[A]

def flatMap[B](f: (A) ⇒ Rx[B]): RxOption[B]

def forceSet(newValue: Option[A]): Unit

def forceUpdate(updater: (Option[A]) ⇒ Option[A]): Unit

Update the variable and force notification to subscribers

def foreach[U](f: (Option[A]) ⇒ U): Cancelable

def get: Option[A]

final def getClass(): Class[_]

def getOrElse[A1 >: A](default: ⇒ A1): RxStream[A1]

def getOrElseRx[A1 >: A](default: ⇒ Rx[A1]): RxStream[A1]

def hashCode(): Int

def in: RxStream[Option[A]]

final def isInstanceOf[T0]: Boolean

def map[B](f: (A) ⇒ B): RxOption[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orElse[A1 >: A](default: ⇒ Option[A1]): RxOption[A1]

def parents: Seq[Rx[_]]

def recover[U](f: PartialFunction[Throwable, U]): RxStream[U]

Recover from a known error and emit a replacement value

def recoverWith[A](f: PartialFunction[Throwable, Rx[A]]): RxStream[A]

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

def run[U](effect: (Option[A]) ⇒ U): Cancelable

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

def runContinuously[U](effect: (Option[A]) ⇒ U): Cancelable

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

def set(newValue: Option[A]): Unit

def subscribe[U](subscriber: (Option[A]) ⇒ U): Cancelable

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

def toRxStream: RxStream[Option[A]]

def toSeq: Seq[Option[A]]

Materialize the stream as Seq[A].

def toString(): String

def transform[B](f: (Option[A]) ⇒ B): RxStream[B]

def transformOption[B](f: (Option[A]) ⇒ Option[B]): RxOption[B]

def transformRx[B](f: (Option[A]) ⇒ Rx[B]): RxStream[B]

def update(updater: (Option[A]) ⇒ Option[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

final def wait(arg0: Long): Unit

final def wait(): Unit

def withFilter(f: (A) ⇒ Boolean): RxOption[A]

def finalize(): Unit