Repository: flink Updated Branches: refs/heads/master 08ca9ffa9 -> 2d191ab05
[FLINK-2359] [java api] Add factory methods to the Java TupleX types This closes #911 Project: http://git-wip-us.apache.org/repos/asf/flink/repo Commit: http://git-wip-us.apache.org/repos/asf/flink/commit/2d191ab0 Tree: http://git-wip-us.apache.org/repos/asf/flink/tree/2d191ab0 Diff: http://git-wip-us.apache.org/repos/asf/flink/diff/2d191ab0 Branch: refs/heads/master Commit: 2d191ab05fff3392697fbce8dd909003c86d34e1 Parents: 08ca9ff Author: Gabor Gevay <gga...@gmail.com> Authored: Tue Jul 14 18:34:05 2015 +0200 Committer: Fabian Hueske <fhue...@apache.org> Committed: Fri Jul 17 14:50:36 2015 +0200 ---------------------------------------------------------------------- .../org/apache/flink/api/java/io/CsvReader.java | 2 +- .../flink/api/java/operators/JoinOperator.java | 2 +- .../org/apache/flink/api/java/tuple/Tuple.java | 2 - .../org/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 ++++- .../org/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 ++++- .../org/apache/flink/api/java/tuple/Tuple3.java | 14 ++++- .../org/apache/flink/api/java/tuple/Tuple4.java | 14 ++++- .../org/apache/flink/api/java/tuple/Tuple5.java | 14 ++++- .../org/apache/flink/api/java/tuple/Tuple6.java | 14 ++++- .../org/apache/flink/api/java/tuple/Tuple7.java | 14 ++++- .../org/apache/flink/api/java/tuple/Tuple8.java | 14 ++++- .../org/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(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/io/CsvReader.java ---------------------------------------------------------------------- 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 da5ee49..c5d6cb5 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 class CsvReader { } // END_OF_TUPLE_DEPENDENT_CODE -} \ No newline at end of file +} http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/operators/JoinOperator.java ---------------------------------------------------------------------- diff --git a/flink-java/src/main/java/org/apache/flink/api/java/operators/JoinOperator.java b/flink-java/src/main/java/org/apache/flink/api/java/operators/JoinOperator.java index 1e5baab..e76e3c9 100644 --- a/flink-java/src/main/java/org/apache/flink/api/java/operators/JoinOperator.java +++ b/flink-java/src/main/java/org/apache/flink/api/java/operators/JoinOperator.java @@ -1323,7 +1323,7 @@ public abstract class JoinOperator<I1, I2, OUT> extends TwoInputUdfOperator<I1, /** * 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. * http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple.java ---------------------------------------------------------------------- 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 9da50c7..145d215 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 abstract class Tuple implements java.io.Serializable { 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 } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple1.java ---------------------------------------------------------------------- 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 5d0a226..8e0e3dd 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 class Tuple1<T0> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple1<T0> copy(){ return new Tuple1<T0>(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<Integer, Double, String>(n, x, s)} + */ + public static <T0> Tuple1<T0> of(T0 value0) { + return new Tuple1<T0>(value0); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple10.java ---------------------------------------------------------------------- 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 04d4d66..7dd0e62 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 class Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> copy(){ return new Tuple10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>(this.f0, this.f1, @@ -272,4 +272,16 @@ public class Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> Tuple10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8, T9 value9) { + return new Tuple10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple11.java ---------------------------------------------------------------------- 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 eaa726d..f1eabe3 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 class Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> extends Tuple /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> copy(){ return new Tuple11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(this.f0, this.f1, @@ -287,4 +287,16 @@ public class Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> extends Tuple 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> Tuple11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple12.java ---------------------------------------------------------------------- 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 09de5b2..304ef1e 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 class Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> extends T /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> copy(){ return new Tuple12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(this.f0, this.f1, @@ -302,4 +302,16 @@ public class Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> extends T 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> Tuple12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple13.java ---------------------------------------------------------------------- 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 1667158..a546917 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 class Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> exte /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> copy(){ return new Tuple13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(this.f0, this.f1, @@ -317,4 +317,16 @@ public class Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> exte 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> Tuple13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple14.java ---------------------------------------------------------------------- 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 18c2a0d..5b0c8e4 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 class Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> copy(){ return new Tuple14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(this.f0, this.f1, @@ -332,4 +332,16 @@ public class Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> Tuple14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple15.java ---------------------------------------------------------------------- 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 f160f4f..cd9230a 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 class Tuple15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> copy(){ return new Tuple15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(this.f0, this.f1, @@ -347,4 +347,16 @@ public class Tuple15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> Tuple15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple16.java ---------------------------------------------------------------------- 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 86c3226..4f5c264 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 class Tuple16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> copy(){ return new Tuple16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(this.f0, this.f1, @@ -362,4 +362,16 @@ public class Tuple16<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> Tuple16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple17.java ---------------------------------------------------------------------- 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 8b48455..826ad0c 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 class Tuple17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple17<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> copy(){ return new Tuple17<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>(this.f0, this.f1, @@ -377,4 +377,16 @@ public class Tuple17<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> Tuple17<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple18.java ---------------------------------------------------------------------- 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 4706df9..a81bff8 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 class Tuple18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple18<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> copy(){ return new Tuple18<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>(this.f0, this.f1, @@ -392,4 +392,16 @@ public class Tuple18<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> Tuple18<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple19.java ---------------------------------------------------------------------- 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 2383348..6fed55c 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 class Tuple19<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple19<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> copy(){ return new Tuple19<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>(this.f0, this.f1, @@ -407,4 +407,16 @@ public class Tuple19<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f17, this.f18); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> Tuple19<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple2.java ---------------------------------------------------------------------- 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 99511e8e..51b3641 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 class Tuple2<T0, T1> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple2<T0,T1> copy(){ return new Tuple2<T0,T1>(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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1> Tuple2<T0,T1> of(T0 value0, T1 value1) { + return new Tuple2<T0,T1>(value0, value1); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple20.java ---------------------------------------------------------------------- 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 0e19aed..c743cb7 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 class Tuple20<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple20<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> copy(){ return new Tuple20<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>(this.f0, this.f1, @@ -422,4 +422,16 @@ public class Tuple20<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f18, this.f19); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> Tuple20<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple21.java ---------------------------------------------------------------------- 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 496d00f..5749a1e 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 class Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple21<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> copy(){ return new Tuple21<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>(this.f0, this.f1, @@ -437,4 +437,16 @@ public class Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f19, this.f20); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> Tuple21<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple22.java ---------------------------------------------------------------------- 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 0195263..7a60808 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 class Tuple22<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple22<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> copy(){ return new Tuple22<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>(this.f0, this.f1, @@ -452,4 +452,16 @@ public class Tuple22<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f20, this.f21); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> Tuple22<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple23.java ---------------------------------------------------------------------- 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 9a57e80..f0002fd 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 class Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple23<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> copy(){ return new Tuple23<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>(this.f0, this.f1, @@ -467,4 +467,16 @@ public class Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f21, this.f22); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> Tuple23<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21, value22); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple24.java ---------------------------------------------------------------------- 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 12a23a7..874c090 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 class Tuple24<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple24<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23> copy(){ return new Tuple24<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>(this.f0, this.f1, @@ -482,4 +482,16 @@ public class Tuple24<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f22, this.f23); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23> Tuple24<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23>(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13, value14, value15, value16, value17, value18, value19, value20, value21, value22, value23); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple25.java ---------------------------------------------------------------------- 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 f45e78f..1b86c0b 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 class Tuple25<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple25<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24> copy(){ return new Tuple25<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>(this.f0, this.f1, @@ -497,4 +497,16 @@ public class Tuple25<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, this.f23, this.f24); } + + /** + * 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24> Tuple25<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24> 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<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24>(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); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple3.java ---------------------------------------------------------------------- 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 3cf47bf..36824ac 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 class Tuple3<T0, T1, T2> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple3<T0,T1,T2> copy(){ return new Tuple3<T0,T1,T2>(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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2> Tuple3<T0,T1,T2> of(T0 value0, T1 value1, T2 value2) { + return new Tuple3<T0,T1,T2>(value0, value1, value2); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple4.java ---------------------------------------------------------------------- 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 6b8dbf9..4e24b1e 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 class Tuple4<T0, T1, T2, T3> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple4<T0,T1,T2,T3> copy(){ return new Tuple4<T0,T1,T2,T3>(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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3> Tuple4<T0,T1,T2,T3> of(T0 value0, T1 value1, T2 value2, T3 value3) { + return new Tuple4<T0,T1,T2,T3>(value0, value1, value2, value3); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple5.java ---------------------------------------------------------------------- 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 8f5b75a..c253e7e 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 class Tuple5<T0, T1, T2, T3, T4> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple5<T0,T1,T2,T3,T4> copy(){ return new Tuple5<T0,T1,T2,T3,T4>(this.f0, this.f1, @@ -197,4 +197,16 @@ public class Tuple5<T0, T1, T2, T3, T4> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4> Tuple5<T0,T1,T2,T3,T4> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4) { + return new Tuple5<T0,T1,T2,T3,T4>(value0, value1, value2, value3, value4); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple6.java ---------------------------------------------------------------------- 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 c3ec29b..079db12 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 class Tuple6<T0, T1, T2, T3, T4, T5> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple6<T0,T1,T2,T3,T4,T5> copy(){ return new Tuple6<T0,T1,T2,T3,T4,T5>(this.f0, this.f1, @@ -212,4 +212,16 @@ public class Tuple6<T0, T1, T2, T3, T4, T5> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5> Tuple6<T0,T1,T2,T3,T4,T5> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) { + return new Tuple6<T0,T1,T2,T3,T4,T5>(value0, value1, value2, value3, value4, value5); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple7.java ---------------------------------------------------------------------- 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 d211287..b77535c 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 class Tuple7<T0, T1, T2, T3, T4, T5, T6> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple7<T0,T1,T2,T3,T4,T5,T6> copy(){ return new Tuple7<T0,T1,T2,T3,T4,T5,T6>(this.f0, this.f1, @@ -227,4 +227,16 @@ public class Tuple7<T0, T1, T2, T3, T4, T5, T6> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6> Tuple7<T0,T1,T2,T3,T4,T5,T6> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6) { + return new Tuple7<T0,T1,T2,T3,T4,T5,T6>(value0, value1, value2, value3, value4, value5, value6); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple8.java ---------------------------------------------------------------------- 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 1e05ad9..12a6e9d 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 class Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple8<T0,T1,T2,T3,T4,T5,T6,T7> copy(){ return new Tuple8<T0,T1,T2,T3,T4,T5,T6,T7>(this.f0, this.f1, @@ -242,4 +242,16 @@ public class Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7> Tuple8<T0,T1,T2,T3,T4,T5,T6,T7> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7) { + return new Tuple8<T0,T1,T2,T3,T4,T5,T6,T7>(value0, value1, value2, value3, value4, value5, value6, value7); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/Tuple9.java ---------------------------------------------------------------------- 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 92d52c8..198360d 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 class Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8> extends Tuple { /** * Shallow tuple copy. * @return A new Tuple with the same fields as this. - */ + */ public Tuple9<T0,T1,T2,T3,T4,T5,T6,T7,T8> copy(){ return new Tuple9<T0,T1,T2,T3,T4,T5,T6,T7,T8>(this.f0, this.f1, @@ -257,4 +257,16 @@ public class Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8> extends Tuple { 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<Integer, Double, String>(n, x, s)} + */ + public static <T0,T1,T2,T3,T4,T5,T6,T7,T8> Tuple9<T0,T1,T2,T3,T4,T5,T6,T7,T8> of(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8) { + return new Tuple9<T0,T1,T2,T3,T4,T5,T6,T7,T8>(value0, value1, value2, value3, value4, value5, value6, value7, value8); + } } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/main/java/org/apache/flink/api/java/tuple/TupleGenerator.java ---------------------------------------------------------------------- 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 03826fc..a87fa0a 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 @@ class TupleGenerator { 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 <OUT extends Tuple> ProjectOperator<T, OUT> projectTupleX() {\n"); - sb.append("\t\t\tProjectOperator<T, OUT> projOperator = null;\n\n"); + sb.append("\t\t\tProjectOperator<T, OUT> 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<T, OUT>) projectTuple"+numFields+"(); break;\n"); @@ -328,6 +330,8 @@ class TupleGenerator { 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 @@ class TupleGenerator { } 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 @@ class TupleGenerator { 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 @@ class TupleGenerator { 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 @@ class TupleGenerator { 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 @@ class TupleGenerator { 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<Integer, Double, String>(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("}"); } http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/test/java/org/apache/flink/api/common/operators/base/CoGroupOperatorCollectionTest.java ---------------------------------------------------------------------- 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 a178a47..71a2eb7 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 class CoGroupOperatorCollectionTest implements Serializable { sumF1 += input.f1; } - out.collect(new Tuple2<String, Integer>(f0, sumF1)); + out.collect(Tuple2.of(f0, sumF1)); } @Override http://git-wip-us.apache.org/repos/asf/flink/blob/2d191ab0/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesPrecedenceTest.java ---------------------------------------------------------------------- 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 014a3ca..ed778c7 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 class SemanticPropertiesPrecedenceTest { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42)); + DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapperWithForwardAnnotation<Tuple3<Long, String, Integer>>()) .output(new DiscardingOutputFormat<Tuple3<Long, String, Integer>>()); @@ -74,7 +74,7 @@ public class SemanticPropertiesPrecedenceTest { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42)); + DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapperWithSkipAnnotation<Tuple3<Long, String, Integer>>()) .output(new DiscardingOutputFormat<Tuple3<Long, String, Integer>>()); @@ -102,7 +102,7 @@ public class SemanticPropertiesPrecedenceTest { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42)); + DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapper<Tuple3<Long, String, Integer>>()) .withForwardedFields("f0") @@ -131,7 +131,7 @@ public class SemanticPropertiesPrecedenceTest { env.getConfig().setCodeAnalysisMode(CodeAnalysisMode.OPTIMIZE); @SuppressWarnings("unchecked") - DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42)); + DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(Tuple3.of(3l, "test", 42)); input .map(new WildcardForwardedMapper<Tuple3<Long, String, Integer>>()) .output(new DiscardingOutputFormat<Tuple3<Long, String, Integer>>());
