Object/Trait

reactor.core.scala.publisher

SFlux

Related Docs: trait SFlux | package publisher

Permalink

object SFlux

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SFlux
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

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

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. def apply[T](elements: T*): SFlux[T]

    Permalink
  5. def apply[T](source: Publisher[_ <: T]): SFlux[T]

    Permalink
  6. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  7. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  8. def combineLatest[T](sources: Publisher[T]*): SFlux[Seq[T]]

    Permalink
  9. def combineLatest[T1, T2](p1: Publisher[T1], p2: Publisher[T2]): SFlux[(T1, T2)]

    Permalink
  10. def combineLatestMap[T, V](mapper: (Array[T]) ⇒ V, sources: Publisher[T]*)(implicit arg0: ClassTag[T]): SFlux[V]

    Permalink
  11. def combineLatestMap[T1, T2, V](p1: Publisher[T1], p2: Publisher[T2], mapper: (T1, T2) ⇒ V): SFlux[V]

    Permalink
  12. def concat[T](sources: Publisher[T]*): SFlux[T]

    Permalink
  13. def concatDelayError[T](sources: Publisher[T]*): SFlux[T]

    Permalink
  14. def create[T](emitter: (FluxSink[T]) ⇒ Unit, backPressure: OverflowStrategy = OverflowStrategy.BUFFER): SFlux[T]

    Permalink
  15. def defer[T](f: ⇒ Publisher[T]): SFlux[T]

    Permalink

    Lazily supply a Publisher every time a org.reactivestreams.Subscription is made on the resulting SFlux, so the actual source instantiation is deferred until each subscribe and the Supplier can create a subscriber-specific instance.

    Lazily supply a Publisher every time a org.reactivestreams.Subscription is made on the resulting SFlux, so the actual source instantiation is deferred until each subscribe and the Supplier can create a subscriber-specific instance. If the supplier doesn't generate a new instance however, this operator will effectively behave like SFlux.from(Publisher)

    T

    the type of values passing through the SFlux

    f

    the {Publisher Supplier to call on subscribe

    returns

    a deferred SFlux

    See also

    SFlux.deferWithContext(Function)

  16. def deferWithContext[T](supplier: (Context) ⇒ Publisher[T]): ReactiveSFlux[T]

    Permalink

    Lazily supply a Publisher every time a org.reactivestreams.Subscription is made on the resulting SFlux, so the actual source instantiation is deferred until each subscribe and the Function1 can create a subscriber-specific instance.

    Lazily supply a Publisher every time a org.reactivestreams.Subscription is made on the resulting SFlux, so the actual source instantiation is deferred until each subscribe and the Function1 can create a subscriber-specific instance. This operator behaves the same way as SFlux.defer(Supplier), but accepts a Function1 that will receive the current Context as an argument. If the supplier doesn't generate a new instance however, this operator will effectively behave like SFlux.from(Publisher).

    T

    the type of values passing through the SFlux

    supplier

    the Publisher Function1 to call on subscribe

    returns

    a deferred SFlux

  17. def empty[T]: SFlux[T]

    Permalink
  18. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  19. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  20. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  21. def firstEmitter[I](sources: Publisher[_ <: I]*): SFlux[I]

    Permalink
  22. def fromArray[T <: AnyRef](array: Array[T]): SFlux[T]

    Permalink
  23. def fromIterable[T](iterable: Iterable[T]): SFlux[T]

    Permalink
  24. def fromPublisher[T](source: Publisher[_ <: T]): SFlux[T]

    Permalink
  25. def fromStream[T](streamSupplier: () ⇒ Stream[T]): SFlux[T]

    Permalink
  26. def generate[T, S](generator: (S, SynchronousSink[T]) ⇒ S, stateSupplier: Option[Callable[S]] = None, stateConsumer: Option[(S) ⇒ Unit] = None): SFlux[T]

    Permalink
  27. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  28. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  29. def interval(period: Duration, scheduler: Scheduler = Schedulers.parallel())(implicit delay: Duration = period): SFlux[Long]

    Permalink
  30. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  31. def just[T](data: T*): SFlux[T]

    Permalink
  32. def merge[I](sources: Seq[Publisher[_ <: I]], prefetch: Int = Queues.XS_BUFFER_SIZE, delayError: Boolean = false): ReactiveSFlux[I]

    Permalink

    Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence.

    Merge data from Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike concat, sources are subscribed to eagerly.

    Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

    I

    The source type of the data sequence

    sources

    the array of Publisher sources to merge

    prefetch

    the inner source request size

    delayError

    This parameter will delay any error until after the rest of the merge backlog has been processed.

    returns

    a fresh Reactive SFlux publisher ready to be subscribed

  33. def mergeOrdered[I <: Comparable[I]](sources: Seq[Publisher[_ <: I]], prefetch: Int = Queues.SMALL_BUFFER_SIZE, comparator: Comparator[I] = Comparator.naturalOrder[I]()): ReactiveSFlux[I]

    Permalink

    Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator).

    Merge data from provided Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided Comparator). This is not a SFlux.sort(Ordering), as it doesn't consider the whole of each sequences.

    Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.

    I

    the merged type

    sources

    Publisher sources to merge

    prefetch

    the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)

    comparator

    the Comparator to use to find the smallest value

    returns

    a merged SFlux that , subscribing early but keeping the original ordering

  34. def mergeSequential[I](sources: Seq[Publisher[_ <: I]], delayError: Boolean = false, prefetch: Int = XS_BUFFER_SIZE): SFlux[I]

    Permalink
  35. def mergeSequentialIterable[I](sources: Iterable[Publisher[_ <: I]], delayError: Boolean = false, maxConcurrency: Int = SMALL_BUFFER_SIZE, prefetch: Int = XS_BUFFER_SIZE): ReactiveSFlux[I]

    Permalink
  36. def mergeSequentialPublisher[T](sources: Publisher[_ <: Publisher[T]], delayError: Boolean = false, maxConcurrency: Int = SMALL_BUFFER_SIZE, prefetch: Int = XS_BUFFER_SIZE): SFlux[T]

    Permalink
  37. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  38. def never[T](): SFlux[T]

    Permalink
  39. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  40. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  41. def push[T](emitter: (FluxSink[T]) ⇒ Unit, backPressure: OverflowStrategy = OverflowStrategy.BUFFER): SFlux[T]

    Permalink
  42. def raiseError[T](e: Throwable, whenRequested: Boolean = false): SFlux[T]

    Permalink
  43. def range(start: Int, count: Int): SFlux[Int]

    Permalink
  44. def switchOnNext[T](mergedPublishers: Publisher[_ <: Publisher[_ <: T]]): SFlux[T]

    Permalink

    Build a reactor.core.publisher.FluxProcessor whose data are emitted by the most recent emitted Publisher.

    Build a reactor.core.publisher.FluxProcessor whose data are emitted by the most recent emitted Publisher. The SFlux will complete once both the publishers source and the last switched to Publisher have completed.

    T

    the produced type

    mergedPublishers

    The Publisher of switching Publisher to subscribe to.

    returns

    a reactor.core.publisher.FluxProcessor accepting publishers and producing T

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

    Permalink
    Definition Classes
    AnyRef
  46. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  47. def using[T, D](resourceSupplier: () ⇒ D, sourceSupplier: (D) ⇒ Publisher[_ <: T], resourceCleanup: (D) ⇒ Unit, eager: Boolean = false): SFlux[T]

    Permalink
  48. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  49. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  50. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  51. def zip[T1, T2](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2]): SFlux[(T1, T2)]

    Permalink
  52. def zip3[T1, T2, T3](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2], source3: Publisher[_ <: T3]): SFlux[(T1, T2, T3)]

    Permalink
  53. def zip4[T1, T2, T3, T4](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2], source3: Publisher[_ <: T3], source4: Publisher[_ <: T4]): SFlux[(T1, T2, T3, T4)]

    Permalink
  54. def zip5[T1, T2, T3, T4, T5](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2], source3: Publisher[_ <: T3], source4: Publisher[_ <: T4], source5: Publisher[_ <: T5]): SFlux[(T1, T2, T3, T4, T5)]

    Permalink
  55. def zip6[T1, T2, T3, T4, T5, T6](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2], source3: Publisher[_ <: T3], source4: Publisher[_ <: T4], source5: Publisher[_ <: T5], source6: Publisher[_ <: T6]): SFlux[(T1, T2, T3, T4, T5, T6)]

    Permalink
  56. def zipMap[I, O](combinator: (Array[AnyRef]) ⇒ O, sources: Seq[Publisher[_ <: I]], prefetch: Int = XS_BUFFER_SIZE): SFlux[O]

    Permalink
  57. def zipMap[T1, T2, O](source1: Publisher[_ <: T1], source2: Publisher[_ <: T2], combinator: (T1, T2) ⇒ O): SFlux[O]

    Permalink
  58. def zipMapIterable[O](sources: Iterable[_ <: Publisher[_]], combinator: (Array[_]) ⇒ O, prefetch: Int = SMALL_BUFFER_SIZE): SFlux[O]

    Permalink

Inherited from AnyRef

Inherited from Any

Ungrouped