Uses of Class
reactor.util.function.Tuple2

Packages that use Tuple2

Package	Description
reactor.core	Core components of the framework supporting extensions to the Reactive Stream programming model.
reactor.core.publisher	Provide main Reactive APIs in Flux and Mono, as well as various helper classes, interfaces used in the composition API, variants of Flux and operator-building utilities.
reactor.test	Main test components supporting the testing and assertion of publishers.
reactor.util.function	Tuples provide a type-safe way to specify multiple parameters.

Uses of Tuple2 in reactor.core

Fields in reactor.core with type parameters of type Tuple2

Modifier and Type	Field and Description
static Scannable.Attr<Stream<Tuple2<String,String>>>	Scannable.Attr.TAGS A Stream of Tuple2 representing key/value pairs for tagged components.

Methods in reactor.core that return types with arguments of type Tuple2

Modifier and Type	Method and Description
default Stream<Tuple2<String,String>>	Scannable.tags() Visit this Scannable and its Scannable.parents(), starting by the furthest reachable parent, and return a Stream of the tags which includes duplicates and outputs tags in declaration order (grandparent tag(s) > parent tag(s) > current tag(s)).

Uses of Tuple2 in reactor.core.publisher

Methods in reactor.core.publisher with type parameters of type Tuple2

Modifier and Type	Method and Description
static <TUPLE extends Tuple2,V> Flux<V>	Flux.zip(Publisher<? extends Publisher<?>> sources, Function<? super TUPLE,? extends V> combinator) Zip multiple sources together, that is to say wait for all the sources to emit one element and combine these elements once into an output value (constructed by the provided combinator).

Methods in reactor.core.publisher that return types with arguments of type Tuple2

Modifier and Type	Method and Description
Flux<Tuple2<Long,T>>	Flux.elapsed() Map this Flux into Tuple2<Long, T> of timemillis and source data.
Mono<Tuple2<Long,T>>	Mono.elapsed() Map this Mono into Tuple2<Long, T> of timemillis and source data.
Flux<Tuple2<Long,T>>	Flux.elapsed(Scheduler scheduler) Map this Flux into Tuple2<Long, T> of timemillis and source data.
Mono<Tuple2<Long,T>>	Mono.elapsed(Scheduler scheduler) Map this Mono sequence into Tuple2<Long, T> of timemillis and source data.
Flux<Tuple2<Long,T>>	Flux.index() Keep information about the order in which source values were received by indexing them with a 0-based incrementing long, returning a Flux of Tuple2<(index, value)>.
Flux<Tuple2<Long,T>>	Flux.timestamp() Emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the parallel Scheduler) and T2 the emitted data (as a T), for each item from this Flux.
Mono<Tuple2<Long,T>>	Mono.timestamp() If this Mono is valued, emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the parallel Scheduler) and T2 the emitted data (as a T).
Flux<Tuple2<Long,T>>	Flux.timestamp(Scheduler scheduler) Emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the provided Scheduler) and T2 the emitted data (as a T), for each item from this Flux.
Mono<Tuple2<Long,T>>	Mono.timestamp(Scheduler scheduler) If this Mono is valued, emit a Tuple2 pair of T1 the current clock time in millis (as a Long measured by the provided Scheduler) and T2 the emitted data (as a T).
static <T1,T2> Mono<Tuple2<T1,T2>>	Mono.zip(Mono<? extends T1> p1, Mono<? extends T2> p2) Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple2.
static <T1,T2> Flux<Tuple2<T1,T2>>	Flux.zip(Publisher<? extends T1> source1, Publisher<? extends T2> source2) Zip two sources together, that is to say wait for all the sources to emit one element and combine these elements once into a Tuple2.
static <T1,T2> Mono<Tuple2<T1,T2>>	Mono.zipDelayError(Mono<? extends T1> p1, Mono<? extends T2> p2) Merge given monos into a new Mono that will be fulfilled when all of the given Monos have produced an item, aggregating their values into a Tuple2 and delaying errors.
<T2> Mono<Tuple2<T,T2>>	Mono.zipWhen(Function<T,Mono<? extends T2>> rightGenerator) Wait for the result from this mono, use it to create a second mono via the provided rightGenerator function and combine both results into a Tuple2.
<T2> Mono<Tuple2<T,T2>>	Mono.zipWith(Mono<? extends T2> other) Combine the result from this mono and another into a Tuple2.
<T2> Flux<Tuple2<T,T2>>	Flux.zipWith(Publisher<? extends T2> source2) Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements once into a Tuple2.
<T2> Flux<Tuple2<T,T2>>	Flux.zipWith(Publisher<? extends T2> source2, int prefetch) Zip this Flux with another Publisher source, that is to say wait for both to emit one element and combine these elements once into a Tuple2.
<T2> Flux<Tuple2<T,T2>>	Flux.zipWithIterable(Iterable<? extends T2> iterable) Zip elements from this Flux with the content of an Iterable, that is to say combine one element from each, pairwise, into a Tuple2.

Uses of Tuple2 in reactor.test

Method parameters in reactor.test with type arguments of type Tuple2

Modifier and Type	Method and Description
StepVerifier.Assertions	StepVerifier.Assertions.hasOperatorErrorsMatching(Predicate<Collection<Tuple2<Optional<Throwable>,Optional<?>>>> errorsConsumer) Assert that the tested publisher has triggered the onOperatorError hook once or more, and check that the collection of errors and their optionally associated data matches a predicate.
StepVerifier.Assertions	StepVerifier.Assertions.hasOperatorErrorsSatisfying(Consumer<Collection<Tuple2<Optional<Throwable>,Optional<?>>>> errorsConsumer) Assert that the tested publisher has triggered the onOperatorError hook once or more, and assert the errors and optionally associated data as a collection.

Uses of Tuple2 in reactor.util.function

Subclasses of Tuple2 in reactor.util.function

Modifier and Type	Class and Description
class	Tuple3<T1,T2,T3> A tuple that holds three non-null values.
class	Tuple4<T1,T2,T3,T4> A tuple that holds four non-null values
class	Tuple5<T1,T2,T3,T4,T5> A tuple that holds five non-null values
class	Tuple6<T1,T2,T3,T4,T5,T6> A tuple that holds six values
class	Tuple7<T1,T2,T3,T4,T5,T6,T7> A tuple that holds seven non-null values
class	Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> A tuple that holds eight values

Methods in reactor.util.function that return Tuple2

Modifier and Type	Method and Description
Tuple2	Tuples.apply(Object o)
static Tuple2	Tuples.fromArray(Object[] list) Create a Tuple2 with the given array if it is small enough to fit inside a Tuple2 to Tuple8.
<R> Tuple2<R,T2>	Tuple2.mapT1(Function<T1,R> mapper) Map the left-hand part (T1) of this Tuple2 into a different value and type, keeping the right-hand part (T2).
<R> Tuple2<T1,R>	Tuple2.mapT2(Function<T2,R> mapper) Map the right-hand part (T2) of this Tuple2 into a different value and type, keeping the left-hand part (T1).
static <T1,T2> Tuple2<T1,T2>	Tuples.of(T1 t1, T2 t2) Create a Tuple2 with the given objects.

Methods in reactor.util.function that return types with arguments of type Tuple2

Modifier and Type	Method and Description
static <T1,T2> Function<Object[],Tuple2<T1,T2>>	Tuples.fn2() A converting function from Object array to Tuple2
static Function<Object[],Tuple2>	Tuples.fnAny() A converting function from Object array to Tuples

Method parameters in reactor.util.function with type arguments of type Tuple2

Modifier and Type	Method and Description
static <R> Function<Object[],R>	Tuples.fnAny(Function<Tuple2,R> delegate) A converting function from Object array to Tuples to R.