How to use

reactor.util.function.Tuple3

constructor

/**
 * Create a {@link Tuple3} with the given objects.
 *
 * @param t1   The first value in the tuple. Not null.
 * @param t2   The second value in the tuple. Not null.
 * @param t3   The third value in the tuple. Not null.
 * @param <T1> The type of the first value.
 * @param <T2> The type of the second value.
 * @param <T3> The type of the third value.
 * @return The new {@link Tuple3}.
 */
public static <T1, T2, T3> Tuple3<T1, T2, T3> of(T1 t1, T2 t2, T3 t3) {
  return new Tuple3<>(t1, t2, t3);
}

/**
 * Map the 2nd part (T2) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T2 part
 * @param <R> the new type for the T2 part
 * @return a new {@link Tuple3} with a different T2 value
 */
public <R> Tuple3<T1, R, T3> mapT2(Function<T2, R> mapper) {
  return new Tuple3<>(t1, mapper.apply(t2), t3);
}

/**
 * Map the 3rd part (T3) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T3 part
 * @param <R> the new type for the T3 part
 * @return a new {@link Tuple3} with a different T3 value
 */
public <R> Tuple3<T1, T2, R> mapT3(Function<T3, R> mapper) {
  return new Tuple3<>(t1, t2, mapper.apply(t3));
}

/**
 * Map the 1st part (T1) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T1 part
 * @param <R> the new type for the T1 part
 * @return a new {@link Tuple3} with a different T1 value
 */
public <R> Tuple3<R, T2, T3> mapT1(Function<T1, R> mapper) {
  return new Tuple3<>(mapper.apply(t1), t2, t3);
}

@Test
public void t3Combinations() {
  assertThat(new Tuple3<>(1, 2, 3))
      .isNotEqualTo(new Tuple3<>(1, 2, 10))
      .isEqualTo(new Tuple3<>(1, 2, 3));
}

  @Test
  public void sanityTestHashcode() {
    Tuple3<Integer, Integer, Integer> same = new Tuple3<>(1, 2, 3);
    Tuple3<Integer, Integer, Integer> different = new Tuple3<>(1, 2, 1);

    assertThat(full.hashCode())
        .isEqualTo(same.hashCode())
        .isNotEqualTo(different.hashCode());
  }
}

@Test
public void fn3Delegate() {
  Integer[] source = new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8 };
  Function<Tuple3<Integer, Integer, Integer>, Tuple3> invert = t3 -> new Tuple3<>(t3.getT3(), t3.getT2(), t3.getT1());
  Tuple3 tuple = Tuples.fn3(invert).apply(source);
  assertThat(tuple.getT1()).isEqualTo(3);
  assertThat(tuple.getT2()).isEqualTo(2);
  assertThat(tuple.getT3()).isEqualTo(1);
  assertThat((Object) tuple).isExactlyInstanceOf(Tuple3.class);
}

@Test
public void nullT3Rejected() {
  assertThatExceptionOfType(NullPointerException.class)
      .isThrownBy(() -> new Tuple3<>(1, 2, null))
      .withMessage("t3");
}

/**
 * Create a {@link Tuple3} with the given objects.
 *
 * @param t1   The first value in the tuple. Not null.
 * @param t2   The second value in the tuple. Not null.
 * @param t3   The third value in the tuple. Not null.
 * @param <T1> The type of the first value.
 * @param <T2> The type of the second value.
 * @param <T3> The type of the third value.
 * @return The new {@link Tuple3}.
 */
public static <T1, T2, T3> Tuple3<T1, T2, T3> of(T1 t1, T2 t2, T3 t3) {
  return new Tuple3<>(t1, t2, t3);
}

/**
 * Map the 1st part (T1) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T1 part
 * @param <R> the new type for the T1 part
 * @return a new {@link Tuple3} with a different T1 value
 */
public <R> Tuple3<R, T2, T3> mapT1(Function<T1, R> mapper) {
  return new Tuple3<>(mapper.apply(t1), t2, t3);
}

/**
 * Map the 3rd part (T3) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T3 part
 * @param <R> the new type for the T3 part
 * @return a new {@link Tuple3} with a different T3 value
 */
public <R> Tuple3<T1, T2, R> mapT3(Function<T3, R> mapper) {
  return new Tuple3<>(t1, t2, mapper.apply(t3));
}

/**
 * Map the 2nd part (T2) of this {@link Tuple3} into a different value and type,
 * keeping the other parts.
 *
 * @param mapper the mapping {@link Function} for the T2 part
 * @param <R> the new type for the T2 part
 * @return a new {@link Tuple3} with a different T2 value
 */
public <R> Tuple3<T1, R, T3> mapT2(Function<T2, R> mapper) {
  return new Tuple3<>(t1, mapper.apply(t2), t3);
}