Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  def apply[T](javaMono: publisher.Mono[T]): Mono[T]

   This function is used as bridge to create scala-wrapper of Mono based on existing Java Mono

   This function is used as bridge to create scala-wrapper of Mono based on existing Java Mono

   T

   The value type that will be emitted by this mono

   javaMono

   The underlying Java Mono

   returns

   Wrapper of Java Mono

5.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

6.  def clone(): AnyRef

   Attributes

   protected[java.lang]

   Definition Classes

   AnyRef

   Annotations

   @native() @throws( ... )

7.  def create[T](callback: (MonoSink[T]) ⇒ Unit): Mono[T]
8.  def defer[T](supplier: () ⇒ Mono[T]): Mono[T]
9.  def delay(duration: Duration, timer: Scheduler): Mono[Long]

   Create a Mono which delays an onNext signal by a given duration and completes.

   Create a Mono which delays an onNext signal by a given duration and completes. If the demand cannot be produced in time, an onError will be signalled instead.

   

   duration

   the Duration of the delay

   timer

   a time-capable Scheduler instance to run on

   returns

   a new Mono

10.  def delay(duration: Duration): Mono[Long]

    Create a Mono which delays an onNext signal of duration of given unit and complete on the global timer.

    Create a Mono which delays an onNext signal of duration of given unit and complete on the global timer. If the demand cannot be produced in time, an onError will be signalled instead. The delay is introduced through the parallel default Scheduler.

    

    duration

    the duration of the delay

    returns

    a new Mono

11.  def empty[T]: Mono[T]

    Create a Mono that completes without emitting any item.

    Create a Mono that completes without emitting any item.

    

    T

    the reified Subscriber type

    returns

    a completed Mono

12.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

13.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

14.  def error[T](error: Throwable): Mono[T]

    Create a Mono that completes with the specified error immediately after onSubscribe.

    Create a Mono that completes with the specified error immediately after onSubscribe.

    

    T

    the reified Subscriber type

    error

    the onError signal

    returns

    a failed Mono

15.  def finalize(): Unit

    Attributes

    protected[java.lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

16.  def first[T](monos: Iterable[_ <: Mono[_ <: T]]): Mono[T]

    Pick the first result coming from any of the given monos and populate a new Mono.

    Pick the first result coming from any of the given monos and populate a new Mono.

    

    T

    The type of the function result.

    monos

    The monos to use.

    returns

    a Mono.

17.  def first[T](monos: Mono[_ <: T]*): Mono[T]

    Pick the first result coming from any of the given monos and populate a new Mono.

    Pick the first result coming from any of the given monos and populate a new Mono.

    

    T

    The type of the function result.

    monos

    The deferred monos to use.

    returns

    a Mono.

18.  def from[T](source: Publisher[_ <: T]): Mono[T]

    Expose the specified Publisher with the Mono API, and ensure it will emit 0 or 1 item.

    Expose the specified Publisher with the Mono API, and ensure it will emit 0 or 1 item. The source emitter will be cancelled on the first onNext.

    

    T

    the source type

    source

    the { @link Publisher} source

    returns

    the next item emitted as a { @link Mono}

19.  def fromCallable[T](supplier: Callable[T]): Mono[T]

    Create a Mono producing the value for the Mono using the given supplier.

    Create a Mono producing the value for the Mono using the given supplier.

    

    T

    type of the expected value

    supplier

    { @link Callable} that will produce the value

    returns

    A Mono.

20.  def fromDirect[I](source: Publisher[_ <: I]): Mono[I]

    Unchecked cardinality conversion of Publisher as Mono, supporting reactor.core.Fuseable sources.

    Unchecked cardinality conversion of Publisher as Mono, supporting reactor.core.Fuseable sources.

    I

    input upstream type

    source

    the Publisher to wrap

    returns

    a wrapped Mono

21.  def fromFuture[T](future: Future[T])(implicit executionContext: ExecutionContext): Mono[T]

    Create a Mono producing the value for the Mono using the given Future.

    Create a Mono producing the value for the Mono using the given Future.

    

    T

    type of the expected value

    future

    Future that will produce the value or null to complete immediately

    executionContext

    an implicit ExecutionContext to use

    returns

    A Mono.

22.  def fromRunnable(runnable: Runnable): Mono[Unit]

    Create a Mono only producing a completion signal after using the given runnable.

    Create a Mono only producing a completion signal after using the given runnable.

    

    runnable

    Runnable that will callback the completion signal

    returns

    A Mono.

23.  def fromSupplier[T](supplier: () ⇒ T): Mono[T]

    Create a Mono producing the value for the Mono using the given supplier.

    Create a Mono producing the value for the Mono using the given supplier.

    

    T

    type of the expected value

    supplier

    that will produce the value

    returns

    A Mono.

24.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

25.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

26.  def ignoreElements[T](source: Publisher[T]): Mono[T]

    Create a new Mono that ignores onNext (dropping them) and only react on Completion signal.

    Create a new Mono that ignores onNext (dropping them) and only react on Completion signal.

    

    T

    the source type of the ignored data

    source

    the to ignore

    returns

    a new completable Mono.

27.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

28.  def just[T](data: T): Mono[T]

    Create a new Mono that emits the specified item.

    Create a new Mono that emits the specified item.

    

    T

    the type of the produced item

    data

    the only item to onNext

    returns

    a Mono.

29.  def justOrEmpty[T](data: T): Mono[T]

    Create a new Mono that emits the specified item if non null otherwise only emits onComplete.

    Create a new Mono that emits the specified item if non null otherwise only emits onComplete.

    

    T

    the type of the produced item

    data

    the item to onNext or onComplete if null

    returns

    a Mono.

30.  def justOrEmpty[T](data: Option[_ <: T]): Mono[T]

    Create a new Mono that emits the specified item if Option.isDefined otherwise only emits onComplete.

    Create a new Mono that emits the specified item if Option.isDefined otherwise only emits onComplete.

    

    T

    the type of the produced item

    data

    the Option item to onNext or onComplete if not present

    returns

    a Mono.

31.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

32.  def never[T]: Mono[T]

    Return a Mono that will never signal any data, error or completion signal.

    Return a Mono that will never signal any data, error or completion signal.

    

    T

    the Subscriber type target

    returns

    a never completing Mono

33.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

34.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

35.  def sequenceEqual[T](source1: Publisher[_ <: T], source2: Publisher[_ <: T], isEqual: (T, T) ⇒ Boolean, bufferSize: Int): Mono[Boolean]

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

    T

    the type of items emitted by each Publisher

    source1

    the first Publisher to compare

    source2

    the second Publisher to compare

    isEqual

    a function used to compare items emitted by each Publisher

    bufferSize

    the number of items to prefetch from the first and second source Publisher

    returns

    a Mono that emits a Boolean value that indicates whether the two Publisher two sequences are the same according to the specified function

36.  def sequenceEqual[T](source1: Publisher[_ <: T], source2: Publisher[_ <: T], isEqual: (T, T) ⇒ Boolean): Mono[Boolean]

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

    T

    the type of items emitted by each Publisher

    source1

    the first Publisher to compare

    source2

    the second Publisher to compare

    isEqual

    a function used to compare items emitted by each Publisher

    returns

    a Mono that emits a Boolean value that indicates whether the two sequences are the same

37.  def sequenceEqual[T](source1: Publisher[_ <: T], source2: Publisher[_ <: T]): Mono[Boolean]

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

    Returns a Mono that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

    T

    the type of items emitted by each Publisher

    source1

    the first Publisher to compare

    source2

    the second Publisher to compare

    returns

    a Mono that emits a Boolean value that indicates whether the two sequences are the same

38.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

39.  def toString(): String

    Definition Classes

    AnyRef → Any

40.  def using[T, D](resourceSupplier: () ⇒ D, sourceSupplier: (D) ⇒ Mono[_ <: T], resourceCleanup: (D) ⇒ Unit): Mono[T]

    Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

    Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

    Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.

    

    T

    emitted type

    D

    resource type

    resourceSupplier

    a function that is called on subscribe to prepare the resource

    sourceSupplier

    a Mono factory derived from the supplied resource

    resourceCleanup

    invoked on completion

    returns

    new Mono

41.  def using[T, D](resourceSupplier: () ⇒ D, sourceSupplier: Function1[D, _ <: Mono[_ <: T]], resourceCleanup: (D) ⇒ Unit, eager: Boolean): Mono[T]

    Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

    Uses a resource, generated by a supplier for each individual Subscriber, while streaming the value from a Mono derived from the same resource and makes sure the resource is released if the sequence terminates or the Subscriber cancels.

    • Eager resource cleanup happens just before the source termination and exceptions raised by the cleanup Consumer may override the terminal even.
    • Non-eager cleanup will drop any exception.

    

    T

    emitted type

    D

    resource type

    resourceSupplier

    a function that is called on subscribe for preparing the resource

    sourceSupplier

    a Mono factory derived from the supplied resource

    resourceCleanup

    invoked on completion

    eager

    true to clean before terminating downstream subscribers

    returns

    new Mono

42.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

44.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @native() @throws( ... )

45.  def when(sources: Publisher[Unit] with MapablePublisher[Unit]*): Mono[Unit]

    Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have been fulfilled.

    Aggregate given publishers into a new Mono that will be fulfilled when all of the given sources have been fulfilled. An error will cause pending results to be cancelled and immediate error emission to the returned Mono.

    

    sources

    The sources to use.

    returns

    a Mono.

46.  def when(sources: Iterable[_ <: Publisher[Unit] with MapablePublisher[Unit]]): Mono[Unit]

    Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled.

    

    sources

    The sources to use.

    returns

    a Mono.

47.  def whenDelayError[R](combinator: (Array[Any]) ⇒ R, monos: Mono[Any]*): Mono[R]

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function.

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled.

    

    R

    the combined result

    combinator

    the function to transform the combined array into an arbitrary object.

    monos

    The monos to use.

    returns

    a Mono.

48.  def whenDelayError(sources: Publisher[Unit] with MapablePublisher[Unit]*): Mono[Unit]

    Merge given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    Merge given void publishers into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    

    sources

    The sources to use.

    returns

    a Mono.

49.  def whenDelayError(sources: Iterable[_ <: Publisher[Unit] with MapablePublisher[Unit]]): Mono[Unit]

    Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled.

    Aggregate given void publishers into a new a Mono that will be fulfilled when all of the given sources have been fulfilled. If any Publisher terminates without value, the returned sequence will be terminated immediately and pending results cancelled. If several Publishers error, the exceptions are combined (suppressed into a combining exception).

    

    sources

    The sources to use.

    returns

    a Mono.

50.  def zip[R](combinator: (Array[AnyRef]) ⇒ R, monos: Mono[_]*): Mono[R]

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function.

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function. An error will cause pending results to be cancelled and immediate error emission to the returned Mono.

    

    R

    the combined result

    combinator

    the function to transform the combined array into an arbitrary object.

    monos

    The monos to use.

    returns

    a Mono.

51.  def zip[R](monos: Iterable[_ <: Mono[_]], combinator: (Array[AnyRef]) ⇒ R): Mono[R]

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function.

    Aggregate given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values according to the provided combinator function. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled.

    

    R

    the combined result

    monos

    The monos to use.

    combinator

    the function to transform the combined array into an arbitrary object.

    returns

    a Mono.

52.  def zipDelayError[R](monos: Iterable[_ <: Mono[_]], combinator: Function1[Array[AnyRef], _ <: R]): Mono[R]

    Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    Aggregate given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled. If any Mono terminates without value, the returned sequence will be terminated immediately and pending results cancelled. If several Monos error, the exceptions are combined (suppressed into a combining exception).

    

    R

    the combined result

    monos

    The monos to use.

    combinator

    the function to transform the combined array into an arbitrary object.

    returns

    a Mono.

53.  def zipDelayError[T1, T2, T3, T4, T5, T6](p1: Mono[_ <: T1], p2: Mono[_ <: T2], p3: Mono[_ <: T3], p4: Mono[_ <: T4], p5: Mono[_ <: T5], p6: Mono[_ <: T6]): Mono[(T1, T2, T3, T4, T5, T6)]

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple6 and delaying errors.

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple6 and delaying errors. If several Monos error, the two exceptions are combined (as suppressed exceptions on a root exception).

    

    T1

    type of the value from source1

    T2

    type of the value from source2

    T3

    type of the value from source3

    T4

    type of the value from source4

    T5

    type of the value from source5

    T6

    type of the value from source6

    p1

    The first upstream Publisher to subscribe to.

    p2

    The second upstream Publisher to subscribe to.

    p3

    The third upstream Publisher to subscribe to.

    p4

    The fourth upstream Publisher to subscribe to.

    p5

    The fifth upstream Publisher to subscribe to.

    p6

    The sixth upstream Publisher to subscribe to.

    returns

    a Mono.

54.  def zipDelayError[T1, T2, T3, T4, T5](p1: Mono[_ <: T1], p2: Mono[_ <: T2], p3: Mono[_ <: T3], p4: Mono[_ <: T4], p5: Mono[_ <: T5]): Mono[(T1, T2, T3, T4, T5)]

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple5 and delaying errors.

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple5 and delaying errors. If several Monos error, the two exceptions are combined (as suppressed exceptions on a root exception).

    

    T1

    type of the value from source1

    T2

    type of the value from source2

    T3

    type of the value from source3

    T4

    type of the value from source4

    T5

    type of the value from source5

    p1

    The first upstream Publisher to subscribe to.

    p2

    The second upstream Publisher to subscribe to.

    p3

    The third upstream Publisher to subscribe to.

    p4

    The fourth upstream Publisher to subscribe to.

    p5

    The fifth upstream Publisher to subscribe to.

    returns

    a Mono.

55.  def zipDelayError[T1, T2, T3, T4](p1: Mono[_ <: T1], p2: Mono[_ <: T2], p3: Mono[_ <: T3], p4: Mono[_ <: T4]): Mono[(T1, T2, T3, T4)]

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple4 and delaying errors.

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple4 and delaying errors. If several Monos error, the two exceptions are combined (as suppressed exceptions on a root exception).

    

    T1

    type of the value from source1

    T2

    type of the value from source2

    T3

    type of the value from source3

    T4

    type of the value from source4

    p1

    The first upstream Publisher to subscribe to.

    p2

    The second upstream Publisher to subscribe to.

    p3

    The third upstream Publisher to subscribe to.

    p4

    The fourth upstream Publisher to subscribe to.

    returns

    a Mono.

56.  def zipDelayError[T1, T2, T3](p1: Mono[_ <: T1], p2: Mono[_ <: T2], p3: Mono[_ <: T3]): Mono[(T1, T2, T3)]

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple3 and delaying errors.

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple3 and delaying errors. If several Monos error, the two exceptions are combined (as suppressed exceptions on a root exception).

    

    T1

    type of the value from source1

    T2

    type of the value from source2

    T3

    type of the value from source3

    p1

    The first upstream Publisher to subscribe to.

    p2

    The second upstream Publisher to subscribe to.

    p3

    The third upstream Publisher to subscribe to.

    returns

    a Mono.

57.  def zipDelayError[T1, T2](p1: Mono[_ <: T1], p2: Mono[_ <: T2]): Mono[(T1, T2)]

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple2 and delaying errors.

    Merge given monos into a new Mono that will be fulfilled when all of the given Monos have been fulfilled, aggregating their values into a Tuple2 and delaying errors. If both Monos error, the two exceptions are combined (as suppressed exceptions on a root exception).

    

    T1

    type of the value from source1

    T2

    type of the value from source2

    p1

    The first upstream { @link Publisher} to subscribe to.

    p2

    The second upstream { @link Publisher} to subscribe to.

    returns

    a Mono.

58.  def zipDelayError[R](combinator: (Array[Any]) ⇒ R, monos: Mono[Any]*): Mono[R]

    Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    Merge given monos into a new a Mono that will be fulfilled when all of the given Monos have been fulfilled.

    

    R

    the combined result

    combinator

    the function to transform the combined array into an arbitrary object.

    monos

    The monos to use.

    returns

    a combined Mono.