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
/**
* Copyright (c) 2014-2015, 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.stream.Collector;
/**
* 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 collector of degree 1.
*/
static Collector, Tuple1> collectors(
Collector collector1
) {
return Collector.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.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.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.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.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.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.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.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)
)
);
}
/**
* Create a new range.
*/
static > Range range(T t1, T t2) {
return new Range<>(t1, t2);
}
/**
* Get an array representation of this tuple.
*/
Object[] array();
/**
* Get a list representation of this tuple.
*/
List list();
/**
* The degree of this tuple.
*/
int degree();
}
