Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.jooq.lambda.tuple.Tuple Maven / Gradle / Ivy
jOOλ is part of the jOOQ series (along with jOOQ, jOOX, jOOR, jOOU) providing some useful extensions to Java 8 lambdas.
/**
* Copyright (c) 2014-2016, Data Geekery GmbH, [email protected]
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jooq.lambda.tuple;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import org.jooq.lambda.Seq;
import org.jooq.lambda.function.Consumer0;
import org.jooq.lambda.function.Consumer1;
import org.jooq.lambda.function.Consumer2;
import org.jooq.lambda.function.Consumer3;
import org.jooq.lambda.function.Consumer4;
import org.jooq.lambda.function.Consumer5;
import org.jooq.lambda.function.Consumer6;
import org.jooq.lambda.function.Consumer7;
import org.jooq.lambda.function.Consumer8;
import org.jooq.lambda.function.Consumer9;
import org.jooq.lambda.function.Consumer10;
import org.jooq.lambda.function.Consumer11;
import org.jooq.lambda.function.Consumer12;
import org.jooq.lambda.function.Consumer13;
import org.jooq.lambda.function.Consumer14;
import org.jooq.lambda.function.Consumer15;
import org.jooq.lambda.function.Consumer16;
import org.jooq.lambda.function.Function0;
import org.jooq.lambda.function.Function1;
import org.jooq.lambda.function.Function2;
import org.jooq.lambda.function.Function3;
import org.jooq.lambda.function.Function4;
import org.jooq.lambda.function.Function5;
import org.jooq.lambda.function.Function6;
import org.jooq.lambda.function.Function7;
import org.jooq.lambda.function.Function8;
import org.jooq.lambda.function.Function9;
import org.jooq.lambda.function.Function10;
import org.jooq.lambda.function.Function11;
import org.jooq.lambda.function.Function12;
import org.jooq.lambda.function.Function13;
import org.jooq.lambda.function.Function14;
import org.jooq.lambda.function.Function15;
import org.jooq.lambda.function.Function16;
/**
* A tuple.
*
* @author Lukas Eder
*/
public interface Tuple extends Iterable {
/**
* Construct a tuple of degree 0.
*/
static Tuple0 tuple() {
return new Tuple0();
}
/**
* Construct a tuple of degree 1.
*/
static Tuple1 tuple(T1 v1) {
return new Tuple1<>(v1);
}
/**
* Construct a tuple of degree 2.
*/
static Tuple2 tuple(T1 v1, T2 v2) {
return new Tuple2<>(v1, v2);
}
/**
* Construct a tuple of degree 3.
*/
static Tuple3 tuple(T1 v1, T2 v2, T3 v3) {
return new Tuple3<>(v1, v2, v3);
}
/**
* Construct a tuple of degree 4.
*/
static Tuple4 tuple(T1 v1, T2 v2, T3 v3, T4 v4) {
return new Tuple4<>(v1, v2, v3, v4);
}
/**
* Construct a tuple of degree 5.
*/
static Tuple5 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
return new Tuple5<>(v1, v2, v3, v4, v5);
}
/**
* Construct a tuple of degree 6.
*/
static Tuple6 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
return new Tuple6<>(v1, v2, v3, v4, v5, v6);
}
/**
* Construct a tuple of degree 7.
*/
static Tuple7 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
return new Tuple7<>(v1, v2, v3, v4, v5, v6, v7);
}
/**
* Construct a tuple of degree 8.
*/
static Tuple8 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
return new Tuple8<>(v1, v2, v3, v4, v5, v6, v7, v8);
}
/**
* Construct a tuple of degree 9.
*/
static Tuple9 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
return new Tuple9<>(v1, v2, v3, v4, v5, v6, v7, v8, v9);
}
/**
* Construct a tuple of degree 10.
*/
static Tuple10 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
return new Tuple10<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
}
/**
* Construct a tuple of degree 11.
*/
static Tuple11 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) {
return new Tuple11<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
}
/**
* Construct a tuple of degree 12.
*/
static Tuple12 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) {
return new Tuple12<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
}
/**
* Construct a tuple of degree 13.
*/
static Tuple13 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) {
return new Tuple13<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
}
/**
* Construct a tuple of degree 14.
*/
static Tuple14 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
return new Tuple14<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14);
}
/**
* Construct a tuple of degree 15.
*/
static Tuple15 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
return new Tuple15<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15);
}
/**
* Construct a tuple of degree 16.
*/
static Tuple16 tuple(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) {
return new Tuple16<>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16);
}
/**
* Construct a tuple function of degree 0.
*/
static Function1 function(Supplier function) {
return t -> function.get();
}
/**
* Construct a tuple function of degree 1.
*/
static Function1, R> function(Function function) {
return t -> function.apply(t.v1);
}
/**
* Construct a tuple function of degree 2.
*/
static Function1, R> function(BiFunction function) {
return t -> function.apply(t.v1, t.v2);
}
/**
* Construct a tuple function of degree 3.
*/
static Function1, R> function(Function3 function) {
return t -> function.apply(t.v1, t.v2, t.v3);
}
/**
* Construct a tuple function of degree 4.
*/
static Function1, R> function(Function4 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4);
}
/**
* Construct a tuple function of degree 5.
*/
static Function1, R> function(Function5 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5);
}
/**
* Construct a tuple function of degree 6.
*/
static Function1, R> function(Function6 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6);
}
/**
* Construct a tuple function of degree 7.
*/
static Function1, R> function(Function7 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7);
}
/**
* Construct a tuple function of degree 8.
*/
static Function1, R> function(Function8 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8);
}
/**
* Construct a tuple function of degree 9.
*/
static Function1, R> function(Function9 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9);
}
/**
* Construct a tuple function of degree 10.
*/
static Function1, R> function(Function10 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10);
}
/**
* Construct a tuple function of degree 11.
*/
static Function1, R> function(Function11 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11);
}
/**
* Construct a tuple function of degree 12.
*/
static Function1, R> function(Function12 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12);
}
/**
* Construct a tuple function of degree 13.
*/
static Function1, R> function(Function13 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13);
}
/**
* Construct a tuple function of degree 14.
*/
static Function1, R> function(Function14 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14);
}
/**
* Construct a tuple function of degree 15.
*/
static Function1, R> function(Function15 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14, t.v15);
}
/**
* Construct a tuple function of degree 16.
*/
static Function1, R> function(Function16 function) {
return t -> function.apply(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14, t.v15, t.v16);
}
/**
* Construct a tuple consumer of degree 0.
*/
static Consumer1 consumer(Runnable consumer) {
return t -> consumer.run();
}
/**
* Construct a tuple consumer of degree 1.
*/
static Consumer1> consumer(Consumer consumer) {
return t -> consumer.accept(t.v1);
}
/**
* Construct a tuple consumer of degree 2.
*/
static Consumer1> consumer(BiConsumer consumer) {
return t -> consumer.accept(t.v1, t.v2);
}
/**
* Construct a tuple consumer of degree 3.
*/
static Consumer1> consumer(Consumer3 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3);
}
/**
* Construct a tuple consumer of degree 4.
*/
static Consumer1> consumer(Consumer4 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4);
}
/**
* Construct a tuple consumer of degree 5.
*/
static Consumer1> consumer(Consumer5 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5);
}
/**
* Construct a tuple consumer of degree 6.
*/
static Consumer1> consumer(Consumer6 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6);
}
/**
* Construct a tuple consumer of degree 7.
*/
static Consumer1> consumer(Consumer7 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7);
}
/**
* Construct a tuple consumer of degree 8.
*/
static Consumer1> consumer(Consumer8 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8);
}
/**
* Construct a tuple consumer of degree 9.
*/
static Consumer1> consumer(Consumer9 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9);
}
/**
* Construct a tuple consumer of degree 10.
*/
static Consumer1> consumer(Consumer10 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10);
}
/**
* Construct a tuple consumer of degree 11.
*/
static Consumer1> consumer(Consumer11 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11);
}
/**
* Construct a tuple consumer of degree 12.
*/
static Consumer1> consumer(Consumer12 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12);
}
/**
* Construct a tuple consumer of degree 13.
*/
static Consumer1> consumer(Consumer13 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13);
}
/**
* Construct a tuple consumer of degree 14.
*/
static Consumer1> consumer(Consumer14 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14);
}
/**
* Construct a tuple consumer of degree 15.
*/
static Consumer1> consumer(Consumer15 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14, t.v15);
}
/**
* Construct a tuple consumer of degree 16.
*/
static Consumer1> consumer(Consumer16 consumer) {
return t -> consumer.accept(t.v1, t.v2, t.v3, t.v4, t.v5, t.v6, t.v7, t.v8, t.v9, t.v10, t.v11, t.v12, t.v13, t.v14, t.v15, t.v16);
}
/**
* Construct a tuple collector of degree 1.
*/
static Collector, Tuple1> collectors(
Collector collector1
) {
return Collector., Tuple1>of(
() -> tuple(
collector1.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
),
a -> tuple(
collector1.finisher().apply(a.v1)
)
);
}
/**
* Construct a tuple collector of degree 2.
*/
static Collector, Tuple2> collectors(
Collector collector1
, Collector collector2
) {
return Collector., Tuple2>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
)
);
}
/**
* Construct a tuple collector of degree 3.
*/
static Collector, Tuple3> collectors(
Collector collector1
, Collector collector2
, Collector collector3
) {
return Collector., Tuple3>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
)
);
}
/**
* Construct a tuple collector of degree 4.
*/
static Collector, Tuple4> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
) {
return Collector., Tuple4>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
)
);
}
/**
* Construct a tuple collector of degree 5.
*/
static Collector, Tuple5> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
) {
return Collector., Tuple5>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
)
);
}
/**
* Construct a tuple collector of degree 6.
*/
static Collector, Tuple6> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
) {
return Collector., Tuple6>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
)
);
}
/**
* Construct a tuple collector of degree 7.
*/
static Collector, Tuple7> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
) {
return Collector., Tuple7>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
)
);
}
/**
* Construct a tuple collector of degree 8.
*/
static Collector, Tuple8> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
) {
return Collector., Tuple8>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
)
);
}
/**
* Construct a tuple collector of degree 9.
*/
static Collector, Tuple9> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
) {
return Collector., Tuple9>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
)
);
}
/**
* Construct a tuple collector of degree 10.
*/
static Collector, Tuple10> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
) {
return Collector., Tuple10>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
)
);
}
/**
* Construct a tuple collector of degree 11.
*/
static Collector, Tuple11> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
) {
return Collector., Tuple11>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
)
);
}
/**
* Construct a tuple collector of degree 12.
*/
static Collector, Tuple12> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
, Collector collector12
) {
return Collector., Tuple12>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
, collector12.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
collector12.accumulator().accept(a.v12, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
, collector12.combiner().apply(a1.v12, a2.v12)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
, collector12.finisher().apply(a.v12)
)
);
}
/**
* Construct a tuple collector of degree 13.
*/
static Collector, Tuple13> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
, Collector collector12
, Collector collector13
) {
return Collector., Tuple13>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
, collector12.supplier().get()
, collector13.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
collector12.accumulator().accept(a.v12, t);
collector13.accumulator().accept(a.v13, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
, collector12.combiner().apply(a1.v12, a2.v12)
, collector13.combiner().apply(a1.v13, a2.v13)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
, collector12.finisher().apply(a.v12)
, collector13.finisher().apply(a.v13)
)
);
}
/**
* Construct a tuple collector of degree 14.
*/
static Collector, Tuple14> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
, Collector collector12
, Collector collector13
, Collector collector14
) {
return Collector., Tuple14>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
, collector12.supplier().get()
, collector13.supplier().get()
, collector14.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
collector12.accumulator().accept(a.v12, t);
collector13.accumulator().accept(a.v13, t);
collector14.accumulator().accept(a.v14, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
, collector12.combiner().apply(a1.v12, a2.v12)
, collector13.combiner().apply(a1.v13, a2.v13)
, collector14.combiner().apply(a1.v14, a2.v14)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
, collector12.finisher().apply(a.v12)
, collector13.finisher().apply(a.v13)
, collector14.finisher().apply(a.v14)
)
);
}
/**
* Construct a tuple collector of degree 15.
*/
static Collector, Tuple15> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
, Collector collector12
, Collector collector13
, Collector collector14
, Collector collector15
) {
return Collector., Tuple15>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
, collector12.supplier().get()
, collector13.supplier().get()
, collector14.supplier().get()
, collector15.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
collector12.accumulator().accept(a.v12, t);
collector13.accumulator().accept(a.v13, t);
collector14.accumulator().accept(a.v14, t);
collector15.accumulator().accept(a.v15, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
, collector12.combiner().apply(a1.v12, a2.v12)
, collector13.combiner().apply(a1.v13, a2.v13)
, collector14.combiner().apply(a1.v14, a2.v14)
, collector15.combiner().apply(a1.v15, a2.v15)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
, collector12.finisher().apply(a.v12)
, collector13.finisher().apply(a.v13)
, collector14.finisher().apply(a.v14)
, collector15.finisher().apply(a.v15)
)
);
}
/**
* Construct a tuple collector of degree 16.
*/
static Collector, Tuple16> collectors(
Collector collector1
, Collector collector2
, Collector collector3
, Collector collector4
, Collector collector5
, Collector collector6
, Collector collector7
, Collector collector8
, Collector collector9
, Collector collector10
, Collector collector11
, Collector collector12
, Collector collector13
, Collector collector14
, Collector collector15
, Collector collector16
) {
return Collector., Tuple16>of(
() -> tuple(
collector1.supplier().get()
, collector2.supplier().get()
, collector3.supplier().get()
, collector4.supplier().get()
, collector5.supplier().get()
, collector6.supplier().get()
, collector7.supplier().get()
, collector8.supplier().get()
, collector9.supplier().get()
, collector10.supplier().get()
, collector11.supplier().get()
, collector12.supplier().get()
, collector13.supplier().get()
, collector14.supplier().get()
, collector15.supplier().get()
, collector16.supplier().get()
),
(a, t) -> {
collector1.accumulator().accept(a.v1, t);
collector2.accumulator().accept(a.v2, t);
collector3.accumulator().accept(a.v3, t);
collector4.accumulator().accept(a.v4, t);
collector5.accumulator().accept(a.v5, t);
collector6.accumulator().accept(a.v6, t);
collector7.accumulator().accept(a.v7, t);
collector8.accumulator().accept(a.v8, t);
collector9.accumulator().accept(a.v9, t);
collector10.accumulator().accept(a.v10, t);
collector11.accumulator().accept(a.v11, t);
collector12.accumulator().accept(a.v12, t);
collector13.accumulator().accept(a.v13, t);
collector14.accumulator().accept(a.v14, t);
collector15.accumulator().accept(a.v15, t);
collector16.accumulator().accept(a.v16, t);
},
(a1, a2) -> tuple(
collector1.combiner().apply(a1.v1, a2.v1)
, collector2.combiner().apply(a1.v2, a2.v2)
, collector3.combiner().apply(a1.v3, a2.v3)
, collector4.combiner().apply(a1.v4, a2.v4)
, collector5.combiner().apply(a1.v5, a2.v5)
, collector6.combiner().apply(a1.v6, a2.v6)
, collector7.combiner().apply(a1.v7, a2.v7)
, collector8.combiner().apply(a1.v8, a2.v8)
, collector9.combiner().apply(a1.v9, a2.v9)
, collector10.combiner().apply(a1.v10, a2.v10)
, collector11.combiner().apply(a1.v11, a2.v11)
, collector12.combiner().apply(a1.v12, a2.v12)
, collector13.combiner().apply(a1.v13, a2.v13)
, collector14.combiner().apply(a1.v14, a2.v14)
, collector15.combiner().apply(a1.v15, a2.v15)
, collector16.combiner().apply(a1.v16, a2.v16)
),
a -> tuple(
collector1.finisher().apply(a.v1)
, collector2.finisher().apply(a.v2)
, collector3.finisher().apply(a.v3)
, collector4.finisher().apply(a.v4)
, collector5.finisher().apply(a.v5)
, collector6.finisher().apply(a.v6)
, collector7.finisher().apply(a.v7)
, collector8.finisher().apply(a.v8)
, collector9.finisher().apply(a.v9)
, collector10.finisher().apply(a.v10)
, collector11.finisher().apply(a.v11)
, collector12.finisher().apply(a.v12)
, collector13.finisher().apply(a.v13)
, collector14.finisher().apply(a.v14)
, collector15.finisher().apply(a.v15)
, collector16.finisher().apply(a.v16)
)
);
}
/**
* Create a new range.
*/
static > Range range(T t1, T t2) {
return new Range<>(t1, t2);
}
/**
* Get an array representation of this tuple.
*
* @deprecated - Use {@link #toArray()} instead.
*/
@Deprecated
Object[] array();
/**
* Get an array representation of this tuple.
*/
Object[] toArray();
/**
* Get a list representation of this tuple.
*
* @deprecated - Use {@link #toList()} instead.
*/
@Deprecated
List list();
/**
* Get a list representation of this tuple.
*/
List toList();
/**
* Get a Seq representation of this tuple.
*/
Seq toSeq();
/**
* Get a map representation of this tuple.
*/
Map toMap();
/**
* Get a map representation of this tuple.
*/
Map toMap(Function keyMapper);
/**
* The degree of this tuple.
*/
int degree();
}
