airframe-rx
API
Generated with
airframe-rx/wvlet.airframe.rx/RxCache

RxCache

wvlet.airframe.rx.RxCache
trait RxCache[A] extends Rx[A]

Rx[A] with a caching capability

Attributes

Graph
Supertypes
trait Rx[A]
trait RxOps[A]
class Object
trait Matchable
class Any
Known subtypes
class CacheOp[A]

Members list

Value members

Abstract methods

def expireAfterWrite(time: Long, unit: TimeUnit): RxCache[A]

Discard the cached value after the given duration.

Discard the cached value after the given duration.

Attributes

def getCurrent: Option[A]

Get the current cached value if exists

Get the current cached value if exists

Attributes

def withTicker(ticker: Ticker): RxCache[A]

Set a custom ticker. Use this only for testing purpose

Set a custom ticker. Use this only for testing purpose

Attributes

Inherited methods

def andThen[B](f: A => Future[B])(implicit ex: ExecutionContext): Rx[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

Attributes

Inherited from:
Rx
def await: A

Await the completion of the first Rx result. This method is available only in Scala JVM.

Await the completion of the first Rx result. This method is available only in Scala JVM.

Note: Generally speaking, blocking operations should be avoided in reactive programming. Use this method only for testing purpose. Both airframe-http and AirSpec supports evaluating Rx[X] result (async) in a non-blocking way.

Attributes

Returns

the result

Inherited from:
RxOps
def cache[A1 >: A]: RxCache[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 => ... }

Attributes

Inherited from:
Rx
def concat[A1 >: A](other: Rx[A1]): Rx[A1]

Attributes

Inherited from:
Rx
def filter(f: A => Boolean): Rx[A]

Applies the given filter and emit the value only when the filter condition matches

Applies the given filter and emit the value only when the filter condition matches

Attributes

Inherited from:
Rx
def flatMap[B](f: A => RxOps[B]): Rx[B]

Applies f to the input value that produces another Rx stream.

Applies f to the input value that produces another Rx stream.

Attributes

Inherited from:
Rx
def join[B, C, D, E](b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]): Rx[(A, B, C, D, E)]

Emit a new output if one of Rx[A], Rx[B], Rx[C], Rx[D], or Rx[E] is changed.

Emit a new output if one of Rx[A], Rx[B], Rx[C], Rx[D], or Rx[E] is changed.

Attributes

Inherited from:
Rx
def join[B, C, D](b: RxOps[B], c: RxOps[C], d: RxOps[D]): Rx[(A, B, C, D)]

Emit a new output if one of Rx[A], Rx[B], Rx[C], or Rx[D] is changed.

Emit a new output if one of Rx[A], Rx[B], Rx[C], or Rx[D] is changed.

Attributes

Inherited from:
Rx
def join[B, C](b: RxOps[B], c: RxOps[C]): Rx[(A, B, C)]

Emit a new output if one of Rx[A], Rx[B], or Rx[C] is changed.

Emit a new output if one of Rx[A], Rx[B], or Rx[C] is changed.

Attributes

Inherited from:
Rx
def join[B](other: RxOps[B]): Rx[(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 { ...} }.

Attributes

Inherited from:
Rx
def lastOption: RxOption[A]

Attributes

Inherited from:
Rx
def map[B](f: A => B): Rx[B]

Applies f to the input value and return the result.

Applies f to the input value and return the result.

Attributes

Inherited from:
Rx
def mapToRx[B](f: A => RxOps[B]): Rx[B]

Applies f to the input value that produces another Rx stream. This method is an alias of flatMap(f)

Applies f to the input value that produces another Rx stream. This method is an alias of flatMap(f)

Attributes

Inherited from:
Rx
def parents: Seq[RxOps[_]]

Attributes

Inherited from:
RxOps
def recover[U](f: PartialFunction[Throwable, U]): Rx[U]

Recover from a known error and emit a replacement value

Recover from a known error and emit a replacement value

Attributes

Inherited from:
RxOps
def recoverWith[A](f: PartialFunction[Throwable, RxOps[A]]): Rx[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

Attributes

Inherited from:
RxOps
def run[U](effect: A => U): Cancelable

Evaluate this Rx[A] and apply the given effect function. Once OnError(e) or OnCompletion is observed, it will stop the evaluation.

Evaluate this Rx[A] and apply the given effect function. Once OnError(e) or OnCompletion is observed, it will stop the evaluation.

Attributes

Inherited from:
RxOps
def runContinuously[U](effect: A => U): Cancelable

Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported. This is useful for keep processing streams.

Keep evaluating Rx[A] even if OnError(e) or OnCompletion is reported. This is useful for keep processing streams.

Attributes

Inherited from:
RxOps
def sample(timeWindow: Long, unit: TimeUnit): Rx[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.

Attributes

Inherited from:
Rx
def startWith[A1 >: A](lst: Seq[A1]): Rx[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.

Attributes

Inherited from:
Rx
def startWith[A1 >: A](a: A1): Rx[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.

Attributes

Inherited from:
Rx
def subscribe[U](subscriber: A => U): Cancelable

Attributes

Inherited from:
RxOps
def take(n: Long): Rx[A]

Take an event up to n elements. This may receive fewer events than n if the upstream operator completes before generating 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.

Attributes

Inherited from:
Rx
def tap(f: A => Unit): Rx[A]

Applies f to the value for having a side effect, and return the original value.

Applies f to the value for having a side effect, and return the original value.

The difference from tapOn is that this method will not receive an input failure.

Value parameters

f

side-effect function used when observing a value

Attributes

Returns

the original Rx event

Inherited from:
RxOps
def tapOn(f: PartialFunction[Try[A], Unit]): Rx[A]

Applies f to the value for having a side effect, and return the original value.

Applies f to the value for having a side effect, and return the original value.

This method is useful for debugging Rx chains. For example:

 rx.tapOn {
   case Success(v) => debug(s"received ${v}")
   case Failure(e) => error(s"request failed", e)
 }

Value parameters

f

partial function for the side effect

Attributes

Returns

the original Rx event

Inherited from:
RxOps
def tapOnFailure(f: Throwable => Unit): Rx[A]

Applies f to the error if it happens, and return the original value.

Applies f to the error if it happens, and return the original value.

This method is useful for logging the error.

Value parameters

f

side-effect function used when observing an error

Attributes

Returns

the original Rx event

Inherited from:
RxOps
def throttleFirst(timeWindow: Long, unit: TimeUnit): Rx[A]

Emit the first item of the source within each sampling period. For example, this is useful to prevent double-clicks of buttons.

Emit the first item of the source within each sampling period. For example, this is useful to prevent double-clicks of buttons.

Attributes

Inherited from:
Rx
def throttleLast(timeWindow: Long, unit: TimeUnit): Rx[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.

Attributes

Inherited from:
Rx
def toOption[X, A1 >: A](implicit ev: A1 <:< Option[X]): RxOption[X]

Attributes

Inherited from:
Rx
override def toRx: Rx[A]

Attributes

Definition Classes
Rx -> RxOps
Inherited from:
Rx
def toSeq: Seq[A]

Materialize the stream as Seq[A]. This works only for the finite stream and for Scala JVM.

Materialize the stream as Seq[A]. This works only for the finite stream and for Scala JVM.

Attributes

Inherited from:
Rx
def transform[B](f: (Try[A]) => B): Rx[B]

Transform a Success(v) or Failure(Throwable) input with a given function.

Transform a Success(v) or Failure(Throwable) input with a given function.

Attributes

Inherited from:
Rx
def transformFailure(f: PartialFunction[Throwable, Throwable]): Rx[A]

Transform a specific type of an exception into another exception. This is useful for handling exceptions.

Transform a specific type of an exception into another exception. This is useful for handling exceptions.

Attributes

Inherited from:
Rx
def transformRx[B](f: (Try[A]) => RxOps[B]): Rx[B]

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to handle both success and failure cases in the same way.

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to handle both success and failure cases in the same way.

Attributes

Inherited from:
Rx
def transformTry[B](f: (Try[A]) => Try[B]): Rx[B]

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to add a post-processing step after handling success and failure cases.

Transform the input value by wrapping it with Try regardless of success or failure. This is useful when you need to add a post-processing step after handling success and failure cases.

Attributes

Inherited from:
Rx
def when(cond: A => Boolean): Rx[A]

An alias of filter

An alias of filter

Attributes

Inherited from:
Rx
def withFilter(f: A => Boolean): Rx[A]

An alias of filter

An alias of filter

Attributes

Inherited from:
Rx
def withName(name: String): Rx[A]

Attributes

Inherited from:
Rx
def zip[B, C, D, E](b: RxOps[B], c: RxOps[C], d: RxOps[D], e: RxOps[E]): Rx[(A, B, C, D, E)]

Combine five Rx streams to form a sequence of quintuples. This will emit a new quintuple when all of the streams are updated.

Combine five Rx streams to form a sequence of quintuples. This will emit a new quintuple when all of the streams are updated.

Attributes

Inherited from:
Rx
def zip[B, C, D](b: RxOps[B], c: RxOps[C], d: RxOps[D]): Rx[(A, B, C, D)]

Combine four Rx streams to form a sequence of quadruples. This will emit a new quadruple when all of the streams are updated.

Combine four Rx streams to form a sequence of quadruples. This will emit a new quadruple when all of the streams are updated.

Attributes

Inherited from:
Rx
def zip[B, C](b: RxOps[B], c: RxOps[C]): Rx[(A, B, C)]

Combine three Rx streams to form a sequence of triples. This will emit a new triple when all of the streams are updated.

Combine three Rx streams to form a sequence of triples. This will emit a new triple when all of the streams are updated.

Attributes

Inherited from:
Rx
def zip[B](other: RxOps[B]): Rx[(A, B)]

Combine two Rx streams to form a sequence of pairs. This will emit a new pair when both of the streams are updated.

Combine two Rx streams to form a sequence of pairs. This will emit a new pair when both of the streams are updated.

Attributes

Inherited from:
Rx
Generated with