From 2d191ab05fff3392697fbce8dd909003c86d34e1 Mon Sep 17 00:00:00 2001 From: Gabor Gevay Date: Tue, 14 Jul 2015 18:34:05 +0200 Subject: [PATCH] [FLINK-2359] [java api] Add factory methods to the Java TupleX types This closes #911 --- .../apache/flink/api/java/io/CsvReader.java | 2 +- .../api/java/operators/JoinOperator.java | 2 +- .../apache/flink/api/java/tuple/Tuple.java | 2 - .../apache/flink/api/java/tuple/Tuple1.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple10.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple11.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple12.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple13.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple14.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple15.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple16.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple17.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple18.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple19.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple2.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple20.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple21.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple22.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple23.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple24.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple25.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple3.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple4.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple5.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple6.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple7.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple8.java | 14 ++++- .../apache/flink/api/java/tuple/Tuple9.java | 14 ++++- .../flink/api/java/tuple/TupleGenerator.java | 55 +++++++++++++------ .../base/CoGroupOperatorCollectionTest.java | 2 +- .../SemanticPropertiesPrecedenceTest.java | 8 +-- 31 files changed, 369 insertions(+), 52 deletions(-) diff --git a/flink-java/src/main/java/org/apache/flink/api/java/io/CsvReader.java b/flink-java/src/main/java/org/apache/flink/api/java/io/CsvReader.java index da5ee49a284c7..c5d6cb5e9287c 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/io/CsvReader.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/io/CsvReader.java @@ -1064,4 +1064,4 @@ public projectSecond(int... secondFieldIndexes) { /** * Chooses a projectTupleX according to the length of - * {@link org.apache.flink.api.java.operators.JoinOperator.JoinProjection#fieldIndexes} + * {@link org.apache.flink.api.java.operators.JoinOperator.JoinProjection#fieldIndexes} * * @return The projected DataSet. * diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple.java index 9da50c745d2c4..145d21511e433 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple.java @@ -108,7 +108,5 @@ public static Class getTupleClass(int arity) { private static final Class[] CLASSES = new Class[] { Tuple1.class, Tuple2.class, Tuple3.class, Tuple4.class, Tuple5.class, Tuple6.class, Tuple7.class, Tuple8.class, Tuple9.class, Tuple10.class, Tuple11.class, Tuple12.class, Tuple13.class, Tuple14.class, Tuple15.class, Tuple16.class, Tuple17.class, Tuple18.class, Tuple19.class, Tuple20.class, Tuple21.class, Tuple22.class, Tuple23.class, Tuple24.class, Tuple25.class }; - - // END_OF_TUPLE_DEPENDENT_CODE } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple1.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple1.java index 5d0a2262428c6..8e0e3dd0484c3 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple1.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple1.java @@ -133,8 +133,20 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple1 copy(){ return new Tuple1(this.f0); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple1 of(T0 value0) { + return new Tuple1(value0); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple10.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple10.java index 04d4d66e863e4..7dd0e62c10810 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple10.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple10.java @@ -259,7 +259,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple10 copy(){ return new Tuple10(this.f0, this.f1, @@ -272,4 +272,16 @@ public Tuple10 copy(){ this.f8, this.f9); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple10 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9) { + return new Tuple10(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple11.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple11.java index eaa726d7b00c3..f1eabe3d01243 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple11.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple11.java @@ -273,7 +273,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple11 copy(){ return new Tuple11(this.f0, this.f1, @@ -287,4 +287,16 @@ public Tuple11 copy(){ this.f9, this.f10); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple11 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10) { + return new Tuple11(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple12.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple12.java index 09de5b2a3c1d8..304ef1ea76535 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple12.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple12.java @@ -287,7 +287,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple12 copy(){ return new Tuple12(this.f0, this.f1, @@ -302,4 +302,16 @@ public Tuple12 copy(){ this.f10, this.f11); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple12 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11) { + return new Tuple12(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple13.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple13.java index 1667158525de2..a546917bd5355 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple13.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple13.java @@ -301,7 +301,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple13 copy(){ return new Tuple13(this.f0, this.f1, @@ -317,4 +317,16 @@ public Tuple13 copy(){ this.f11, this.f12); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple13 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12) { + return new Tuple13(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple14.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple14.java index 18c2a0d656ac6..5b0c8e48a1abe 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple14.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple14.java @@ -315,7 +315,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple14 copy(){ return new Tuple14(this.f0, this.f1, @@ -332,4 +332,16 @@ public Tuple14 copy(){ this.f12, this.f13); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple14 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13) { + return new Tuple14(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple15.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple15.java index f160f4f3659f6..cd9230a5f9029 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple15.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple15.java @@ -329,7 +329,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple15 copy(){ return new Tuple15(this.f0, this.f1, @@ -347,4 +347,16 @@ public Tuple15 copy(){ this.f13, this.f14); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple15 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14) { + return new Tuple15(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple16.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple16.java index 86c32267d2c67..4f5c2649dfa40 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple16.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple16.java @@ -343,7 +343,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple16 copy(){ return new Tuple16(this.f0, this.f1, @@ -362,4 +362,16 @@ public Tuple16 copy(){ this.f14, this.f15); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple16 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15) { + return new Tuple16(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple17.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple17.java index 8b484559499bb..826ad0c3dd562 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple17.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple17.java @@ -357,7 +357,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple17 copy(){ return new Tuple17(this.f0, this.f1, @@ -377,4 +377,16 @@ public Tuple17 copy() this.f15, this.f16); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple17 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16) { + return new Tuple17(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple18.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple18.java index 4706df96c70da..a81bff8ef085d 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple18.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple18.java @@ -371,7 +371,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple18 copy(){ return new Tuple18(this.f0, this.f1, @@ -392,4 +392,16 @@ public Tuple18 co this.f16, this.f17); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple18 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17) { + return new Tuple18(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple19.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple19.java index 2383348a60787..6fed55cecec9b 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple19.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple19.java @@ -385,7 +385,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple19 copy(){ return new Tuple19(this.f0, this.f1, @@ -407,4 +407,16 @@ public Tuple19(n, x, s)} + */ + public static Tuple19 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18) { + return new Tuple19(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple2.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple2.java index 99511e8ea8a47..51b3641d0bcb8 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple2.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple2.java @@ -155,9 +155,21 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple2 copy(){ return new Tuple2(this.f0, this.f1); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple2 of(T0 value0, T1 value1) { + return new Tuple2(value0, value1); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple20.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple20.java index 0e19aed5275ea..c743cb7f0d905 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple20.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple20.java @@ -399,7 +399,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple20 copy(){ return new Tuple20(this.f0, this.f1, @@ -422,4 +422,16 @@ public Tuple20(n, x, s)} + */ + public static Tuple20 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19) { + return new Tuple20(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple21.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple21.java index 496d00fa8a32e..5749a1ee10c3d 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple21.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple21.java @@ -413,7 +413,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple21 copy(){ return new Tuple21(this.f0, this.f1, @@ -437,4 +437,16 @@ public Tuple21(n, x, s)} + */ + public static Tuple21 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19, T20 value20) { + return new Tuple21(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple22.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple22.java index 01952631a1eda..7a608085090dc 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple22.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple22.java @@ -427,7 +427,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple22 copy(){ return new Tuple22(this.f0, this.f1, @@ -452,4 +452,16 @@ public Tuple22(n, x, s)} + */ + public static Tuple22 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19, T20 value20, T21 value21) { + return new Tuple22(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple23.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple23.java index 9a57e802a244f..f0002fd7a15d1 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple23.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple23.java @@ -441,7 +441,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple23 copy(){ return new Tuple23(this.f0, this.f1, @@ -467,4 +467,16 @@ public Tuple23(n, x, s)} + */ + public static Tuple23 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19, T20 value20, T21 value21, T22 value22) { + return new Tuple23(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21, value22); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple24.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple24.java index 12a23a73a2961..874c090ba63d7 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple24.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple24.java @@ -455,7 +455,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple24 copy(){ return new Tuple24(this.f0, this.f1, @@ -482,4 +482,16 @@ public Tuple24(n, x, s)} + */ + public static Tuple24 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19, T20 value20, T21 value21, T22 value22, T23 value23) { + return new Tuple24(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21, value22, value23); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple25.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple25.java index f45e78ff04a40..1b86c0ba28850 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple25.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple25.java @@ -469,7 +469,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple25 copy(){ return new Tuple25(this.f0, this.f1, @@ -497,4 +497,16 @@ public Tuple25(n, x, s)} + */ + public static Tuple25 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9, T10 value10, T11 value11, T12 value12, T13 value13, T14 value14, T15 value15, T16 value16, T17 value17, T18 value18, T19 value19, T20 value20, T21 value21, T22 value22, T23 value23, T24 value24) { + return new Tuple25(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21, value22, value23, value24); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple3.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple3.java index 3cf47bfab9db9..36824ac2048a9 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple3.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple3.java @@ -161,10 +161,22 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple3 copy(){ return new Tuple3(this.f0, this.f1, this.f2); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple3 of(T0 value0, T1 value1, T2 value2) { + return new Tuple3(value0, value1, value2); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple4.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple4.java index 6b8dbf9d7dc72..4e24b1e264728 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple4.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple4.java @@ -175,11 +175,23 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple4 copy(){ return new Tuple4(this.f0, this.f1, this.f2, this.f3); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple4 of(T0 value0, T1 value1, T2 value2, T3 value3) { + return new Tuple4(value0, value1, value2, value3); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple5.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple5.java index 8f5b75ab988f8..c253e7ebe10cf 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple5.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple5.java @@ -189,7 +189,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple5 copy(){ return new Tuple5(this.f0, this.f1, @@ -197,4 +197,16 @@ public Tuple5 copy(){ this.f3, this.f4); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple5 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4) { + return new Tuple5(value0, value1, value2, value3, value4); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple6.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple6.java index c3ec29bdc4899..079db127ed70b 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple6.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple6.java @@ -203,7 +203,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple6 copy(){ return new Tuple6(this.f0, this.f1, @@ -212,4 +212,16 @@ public Tuple6 copy(){ this.f4, this.f5); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple6 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) { + return new Tuple6(value0, value1, value2, value3, value4, value5); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple7.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple7.java index d211287f8a7e9..b77535c6139db 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple7.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple7.java @@ -217,7 +217,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple7 copy(){ return new Tuple7(this.f0, this.f1, @@ -227,4 +227,16 @@ public Tuple7 copy(){ this.f5, this.f6); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple7 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6) { + return new Tuple7(value0, value1, value2, value3, value4, value5, value6); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple8.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple8.java index 1e05ad968ff2f..12a6e9d20e280 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple8.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple8.java @@ -231,7 +231,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple8 copy(){ return new Tuple8(this.f0, this.f1, @@ -242,4 +242,16 @@ public Tuple8 copy(){ this.f6, this.f7); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple8 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7) { + return new Tuple8(value0, value1, value2, value3, value4, value5, value6, value7); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple9.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple9.java index 92d52c885a025..198360df517c9 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple9.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple9.java @@ -245,7 +245,7 @@ public int hashCode() { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple9 copy(){ return new Tuple9(this.f0, this.f1, @@ -257,4 +257,16 @@ public Tuple9 copy(){ this.f7, this.f8); } + + /** + * Creates a new tuple and assigns the given values to the tuple's fields. + * This is more convenient than using the constructor, because the compiler can + * infer the generic type arguments implicitly. For example: + * {@code Tuple3.of(n, x, s)} + * instead of + * {@code new Tuple3(n, x, s)} + */ + public static Tuple9 of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8) { + return new Tuple9(value0, value1, value2, value3, value4, value5, value6, value7, value8); + } } diff --git a/flink-java/src/main/java/org/apache/flink/api/java/tuple/TupleGenerator.java b/flink-java/src/main/java/org/apache/flink/api/java/tuple/TupleGenerator.java index 03826fc7c5245..a87fa0a7997ba 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/tuple/TupleGenerator.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/tuple/TupleGenerator.java @@ -249,12 +249,14 @@ private static void modifyProjectOperator(File root) throws IOException { sb.append("\t\t * {@link org.apache.flink.api.java.operators.ProjectOperator.Projection#fieldIndexes} \n"); sb.append("\t\t * \n"); sb.append("\t\t * @return The projected DataSet.\n"); + sb.append("\t\t * \n"); + sb.append("\t\t * @see org.apache.flink.api.java.operators.ProjectOperator.Projection\n"); sb.append("\t\t */\n"); // method signature sb.append("\t\t@SuppressWarnings(\"unchecked\")\n"); sb.append("\t\tpublic ProjectOperator projectTupleX() {\n"); - sb.append("\t\t\tProjectOperator projOperator = null;\n\n"); + sb.append("\t\t\tProjectOperator projOperator;\n\n"); sb.append("\t\t\tswitch (fieldIndexes.length) {\n"); for (int numFields = FIRST; numFields <= LAST; numFields++) { sb.append("\t\t\tcase " + numFields +":" + " projOperator = (ProjectOperator) projectTuple"+numFields+"(); break;\n"); @@ -328,6 +330,8 @@ private static void modifyJoinProjectOperator(File root) throws IOException { sb.append("\t\t * {@link org.apache.flink.api.java.operators.JoinOperator.JoinProjection#fieldIndexes}\n"); sb.append("\t\t * \n"); sb.append("\t\t * @return The projected DataSet.\n"); + sb.append("\t\t * \n"); + sb.append("\t\t * @see org.apache.flink.api.java.operators.JoinOperator.ProjectJoin\n"); sb.append("\t\t */\n"); // method signature @@ -565,6 +569,15 @@ private static void writeTupleClass(PrintWriter w, int numFields) { } w.println(); + String paramList = "("; // This will be like "(T0 value0, T1 value1)" + for (int i = 0; i < numFields; i++) { + if (i > 0) { + paramList += ", "; + } + paramList += GEN_TYPE_PREFIX + i + " value" + i; + } + paramList += ")"; + // constructors w.println("\t/**"); w.println("\t * Creates a new tuple where all fields are null."); @@ -578,14 +591,7 @@ private static void writeTupleClass(PrintWriter w, int numFields) { w.println("\t * @param value" + i + " The value for field " + i); } w.println("\t */"); - w.print("\tpublic " + className + "("); - for (int i = 0; i < numFields; i++) { - if (i > 0) { - w.print(", "); - } - w.print(GEN_TYPE_PREFIX + i + " value" + i); - } - w.println(") {"); + w.println("\tpublic " + className + paramList + " {"); for (int i = 0; i < numFields; i++) { w.println("\t\tthis.f" + i + " = value" + i + ';'); } @@ -634,14 +640,7 @@ private static void writeTupleClass(PrintWriter w, int numFields) { w.println("\t * @param value" + i + " The value for field " + i); } w.println("\t */"); - w.print("\tpublic void setFields("); - for (int i = 0; i < numFields; i++) { - if (i > 0) { - w.print(", "); - } - w.print(GEN_TYPE_PREFIX + i + " value" + i); - } - w.println(") {"); + w.println("\tpublic void setFields" + paramList + " {"); for (int i = 0; i < numFields; i++) { w.println("\t\tthis.f" + i + " = value" + i + ';'); } @@ -730,7 +729,7 @@ private static void writeTupleClass(PrintWriter w, int numFields) { w.println("\t/**"); w.println("\t* Shallow tuple copy."); w.println("\t* @return A new Tuple with the same fields as this."); - w.println("\t */"); + w.println("\t*/"); w.println("\tpublic " + className + tupleTypes + " copy(){ "); w.print("\t\treturn new " + className + tupleTypes + "(this.f0"); @@ -747,6 +746,26 @@ private static void writeTupleClass(PrintWriter w, int numFields) { w.println(");"); w.println("\t}"); + w.println(); + w.println("\t/**"); + w.println("\t * Creates a new tuple and assigns the given values to the tuple's fields."); + w.println("\t * This is more convenient than using the constructor, because the compiler can"); + w.println("\t * infer the generic type arguments implicitly. For example:"); + w.println("\t * {@code Tuple3.of(n, x, s)}"); + w.println("\t * instead of"); + w.println("\t * {@code new Tuple3(n, x, s)}"); + w.println("\t */"); + w.println("\tpublic static " + tupleTypes + " " + className + tupleTypes + " of" + paramList + " {"); + w.print("\t\treturn new " + className + tupleTypes + "("); + for(int i = 0; i < numFields; i++) { + w.print("value" + i); + if(i < numFields - 1) { + w.print(", "); + } + } + w.println(");"); + w.println("\t}"); + // foot w.println("}"); } diff --git a/flink-java/src/test/java/org/apache/flink/api/common/operators/base/CoGroupOperatorCollectionTest.java b/flink-java/src/test/java/org/apache/flink/api/common/operators/base/CoGroupOperatorCollectionTest.java index a178a4742b117..71a2eb7bea091 100644 --- a/flink-java/src/test/java/org/apache/flink/api/common/operators/base/CoGroupOperatorCollectionTest.java +++ b/flink-java/src/test/java/org/apache/flink/api/common/operators/base/CoGroupOperatorCollectionTest.java @@ -158,7 +158,7 @@ public void coGroup( sumF1 += input.f1; } - out.collect(new Tuple2(f0, sumF1)); + out.collect(Tuple2.of(f0, sumF1)); } @Override diff --git a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesPrecedenceTest.java b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesPrecedenceTest.java index 014a3ca10f5f4..ed778c745752a 100644 --- a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesPrecedenceTest.java +++ b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesPrecedenceTest.java @@ -46,7 +46,7 @@ public void testFunctionForwardedAnnotationPrecedence() { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet> input = env.fromElements(new Tuple3(3l, "test", 42)); + DataSet> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapperWithForwardAnnotation>()) .output(new DiscardingOutputFormat>()); @@ -74,7 +74,7 @@ public void testFunctionSkipCodeAnalysisAnnotationPrecedence() { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet> input = env.fromElements(new Tuple3(3l, "test", 42)); + DataSet> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapperWithSkipAnnotation>()) .output(new DiscardingOutputFormat>()); @@ -102,7 +102,7 @@ public void testFunctionApiPrecedence() { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet> input = env.fromElements(new Tuple3(3l, "test", 42)); + DataSet> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapper>()) .withForwardedFields("f0") @@ -131,7 +131,7 @@ public void testFunctionAnalyzerPrecedence() { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet> input = env.fromElements(new Tuple3(3l, "test", 42)); + DataSet> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapper>()) .output(new DiscardingOutputFormat>());