/** * Shallow tuple copy. * @return A new Tuple with the same fields as this. */ @Override @SuppressWarnings("unchecked") public Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> copy() { return new Tuple8<>(this.f0, this.f1, this.f2, this.f3, this.f4, this.f5, 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<>(value0, value1, value2, value3, value4, value5, value6, value7); } }
public Tuple8Builder<T0, T1, T2, T3, T4, T5, T6, T7> add(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7){ tuples.add(new Tuple8<>(value0, value1, value2, value3, value4, value5, value6, value7)); return this; }
@Override public Tuple8<Boolean, Character, Byte, Short, Integer, Long, Float, Double> map( Tuple8<Boolean, Character, Byte, Short, Integer, Long, Float, Double> value) throws Exception { boolean f0 = value.f0; char f1 = value.f1; byte f2 = value.f2; short f3 = value.f3; int f4 = value.f4; long f5 = value.f5; float f6 = value.f6; double f7 = value.f7; return new Tuple8<Boolean, Character, Byte, Short, Integer, Long, Float, Double>( f0, f1, f2, f3, f4, f5, f6, f7); } }
@Override public Tuple8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> map( Tuple8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> value) throws Exception { Tuple8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> tuple = new Tuple8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>(); // non-input content if (tuple.f0 == null) { tuple.setField(123456, 0); } else { tuple.setField(value.f0, 0); } // forwarding tuple.setField(value.f2, 3); tuple.setField(value.f3, 7); // TODO multiple mapping is unsupported yet //tuple.setField(value.f1, 3); return tuple; } }
data.add(new Tuple8<>((short) 1, 1, 100L, 0.1f, 1.012376, "hello", false, new DoubleValue(50.0))); data.add(new Tuple8<>((short) 2, 2, 1000L, 0.2f, 2.003453, "hello", true, new DoubleValue(50.0))); data.add(new Tuple8<>((short) 4, 10, 10000L, 0.2f, 75.00005, "null", true, new DoubleValue(50.0))); data.add(new Tuple8<>((short) 10, 4, 100L, 0.9f, 79.5, "", true, new DoubleValue(50.0))); data.add(new Tuple8<>((short) 5, 5, 1000L, 0.2f, 10.0000001, "a", false, new DoubleValue(50.0))); data.add(new Tuple8<>((short) 6, 6, 10L, 0.1f, 0.0000000000023, "", true, new DoubleValue(100.0))); data.add(new Tuple8<>((short) 7, 7, 1L, 0.2f, Double.POSITIVE_INFINITY, "abcdefghijklmnop", true, new DoubleValue(100.0))); data.add(new Tuple8<>((short) 8, 8, -100L, 0.001f, Double.NaN, "abcdefghi", true, new DoubleValue(100.0)));
case 6: return new Tuple6(); case 7: return new Tuple7(); case 8: return new Tuple8(); case 9: return new Tuple9(); case 10: return new Tuple10();
/** * Shallow tuple copy. * @return A new Tuple with the same fields as this. */ @Override @SuppressWarnings("unchecked") public Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> copy() { return new Tuple8<>(this.f0, this.f1, this.f2, this.f3, this.f4, this.f5, this.f6, this.f7); }
/** * Shallow tuple copy. * @return A new Tuple with the same fields as this. */ @Override @SuppressWarnings("unchecked") public Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> copy() { return new Tuple8<>(this.f0, this.f1, this.f2, this.f3, this.f4, this.f5, 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<>(value0, value1, value2, value3, value4, value5, value6, value7); } }
/** * 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<>(value0, value1, value2, value3, value4, value5, value6, value7); } }
public Tuple8Builder<T0, T1, T2, T3, T4, T5, T6, T7> add(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7){ tuples.add(new Tuple8<>(value0, value1, value2, value3, value4, value5, value6, value7)); return this; }
public Tuple8Builder<T0, T1, T2, T3, T4, T5, T6, T7> add(T0 value0, T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7){ tuples.add(new Tuple8<>(value0, value1, value2, value3, value4, value5, value6, value7)); return this; }
case 6: return new Tuple6(); case 7: return new Tuple7(); case 8: return new Tuple8(); case 9: return new Tuple9(); case 10: return new Tuple10();
return setTupleValue(new Tuple7(), row); case 8: return setTupleValue(new Tuple8(), row); case 9: return setTupleValue(new Tuple9(), row);
return setTupleValue(new Tuple7(), row); case 8: return setTupleValue(new Tuple8(), row); case 9: return setTupleValue(new Tuple9(), row);