Java 类org.jooq.lambda.tuple.Tuple1 实例源码

/**
 * Map this stream to a windowed stream with 1 distinct windows.
 */
@Generated("This method was generated using jOOQ-tools")
default Seq<Tuple1<Window<T>>> window(
    WindowSpecification<T> specification1
) {
    List<Tuple2<T, Long>> buffer = zipWithIndex().toList();

    Map<?, Partition<T>> partitions1 = SeqUtils.partitions(specification1, buffer);

    return seq(buffer)
          .map(t -> tuple(
               (Window<T>) new WindowImpl<>(t, partitions1.get(specification1.partition().apply(t.v1)), specification1)
          ))
          .onClose(this::close);
}

/**
 * Partially apply this function to the arguments.
 */
default Function13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer5<T2, T3, T4, T5, T6> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6) -> accept(args.v1, v2, v3, v4, v5, v6);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer6<T2, T3, T4, T5, T6, T7> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7) -> accept(args.v1, v2, v3, v4, v5, v6, v7);
}

/**
 * Partially apply this function to the arguments.
 */
default Function0<R> applyPartially(Tuple1<? extends T1> args) {
    return () -> apply(args.v1);
}

/**
 * Partially apply this function to the arguments.
 */
default Function8<T2, T3, T4, T5, T6, T7, T8, T9, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9);
}

/**
 * Partially apply this function to the arguments.
 */
default Function3<T2, T3, T4, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4) -> apply(args.v1, v2, v3, v4);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16);
}

/**
 * Partially apply this function to the arguments.
 */
default Function1<T2, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2) -> apply(args.v1, v2);
}

/**
 * Partially apply this function to the arguments.
 */
default Function9<T2, T3, T4, T5, T6, T7, T8, T9, T10, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
}

/**
 * Partially apply this function to the arguments.
 */
default Function10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
}

/**
 * Partially apply this function to the arguments.
 */
default Function6<T2, T3, T4, T5, T6, T7, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7) -> apply(args.v1, v2, v3, v4, v5, v6, v7);
}

/**
 * Partially apply this function to the arguments.
 */
default Function2<T2, T3, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3) -> apply(args.v1, v2, v3);
}

/**
 * Partially apply this function to the arguments.
 */
default Function15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer2<T2, T3> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3) -> accept(args.v1, v2, v3);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer9<T2, T3, T4, T5, T6, T7, T8, T9, T10> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer7<T2, T3, T4, T5, T6, T7, T8> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer0 acceptPartially(Tuple1<? extends T1> args) {
    return () -> accept(args.v1);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer8<T2, T3, T4, T5, T6, T7, T8, T9> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9);
}

/**
 * Partially apply this function to the arguments.
 */
default Function5<T2, T3, T4, T5, T6, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6) -> apply(args.v1, v2, v3, v4, v5, v6);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
}

/**
 * Partially apply this function to the arguments.
 */
default Function14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
}

/**
 * Partially apply this function to the arguments.
 */
default Function4<T2, T3, T4, T5, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5) -> apply(args.v1, v2, v3, v4, v5);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer1<T2> acceptPartially(Tuple1<? extends T1> args) {
    return (v2) -> accept(args.v1, v2);
}

/**
 * Partially apply this function to the arguments.
 */
default Function11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
}

/**
 * Partially apply this function to the arguments.
 */
default Function7<T2, T3, T4, T5, T6, T7, T8, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
}

/**
 * Partially apply this function to the arguments.
 */
default Function12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer3<T2, T3, T4> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4) -> accept(args.v1, v2, v3, v4);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> accept(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
}

/**
 * Let this consumer partially accept the arguments.
 */
default Consumer4<T2, T3, T4, T5> acceptPartially(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5) -> accept(args.v1, v2, v3, v4, v5);
}

public static void main(String[] args) {

        Tuple3<Integer, String, String> student = new Tuple3<>(23, "Jack", "10th");

        System.out.println(student);

        Tuple2<Tuple1<Integer>, Tuple2<String, String>> student1 = student.split1();

        System.out.println(student1);
    }

/**
 * Partially apply this function to the arguments.
 *
 * @deprecated - Use {@link #applyPartially(Tuple1)} instead.
 */
@Deprecated
default Function13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> curry(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14);
}

/**
 * Apply this function to the arguments.
 *
 * @param args The arguments as a tuple.
 */
default R apply(Tuple1<? extends T1> args) {
    return apply(args.v1);
}

/**
 * Partially apply this function to the arguments.
 *
 * @deprecated - Use {@link #applyPartially(Tuple1)} instead.
 */
@Deprecated
default Function0<R> curry(Tuple1<? extends T1> args) {
    return () -> apply(args.v1);
}

/**
 * Partially apply this function to the arguments.
 *
 * @deprecated - Use {@link #applyPartially(Tuple1)} instead.
 */
@Deprecated
default Function8<T2, T3, T4, T5, T6, T7, T8, T9, R> curry(Tuple1<? extends T1> args) {
    return (v2, v3, v4, v5, v6, v7, v8, v9) -> apply(args.v1, v2, v3, v4, v5, v6, v7, v8, v9);
}

/**
 * Partially apply this function to the arguments.
 *
 * @deprecated - Use {@link #applyPartially(Tuple1)} instead.
 */
@Deprecated
default Function3<T2, T3, T4, R> curry(Tuple1<? extends T1> args) {
    return (v2, v3, v4) -> apply(args.v1, v2, v3, v4);
}

/**
 * Partially apply this function to the arguments.
 *
 * @deprecated - Use {@link #applyPartially(Tuple1)} instead.
 */
@Deprecated
default Function1<T2, R> curry(Tuple1<? extends T1> args) {
    return (v2) -> apply(args.v1, v2);
}