flink-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From fhue...@apache.org
Subject flink git commit: [FLINK-2359] [java api] Add factory methods to the Java TupleX types
Date Fri, 17 Jul 2015 13:22:09 GMT
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 <ggab90@gmail.com>
Authored: Tue Jul 14 18:34:05 2015 +0200
Committer: Fabian Hueske <fhueske@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>>());


Mime
View raw message