@Override public T createOrReuseInstance(Object[] fields, T reuse) { for (int i = 0; i < arity; i++) { reuse.setField(fields[i], i); } return reuse; }
@Override public T set(T record, F fieldValue) { record.setField(fieldValue, pos); return record; } }
@Override public T createInstance(Object[] fields) { try { T t = tupleClass.newInstance(); for (int i = 0; i < arity; i++) { t.setField(fields[i], i); } return t; } catch (Exception e) { throw new RuntimeException("Cannot instantiate tuple.", e); } }
public R cross(T1 in1, T2 in2) { for (int i = 0; i < fields.length; i++) { if (isFromFirst[i]) { if (fields[i] >= 0) { outTuple.setField(((Tuple) in1).getField(fields[i]), i); } else { outTuple.setField(in1, i); } } else { if (fields[i] >= 0) { outTuple.setField(((Tuple) in2).getField(fields[i]), i); } else { outTuple.setField(in2, i); } } } return outTuple; }
@SuppressWarnings("unchecked") @Override public R map(Tuple inTuple) throws Exception { for (int i = 0; i < fields.length; i++) { outTuple.setField(inTuple.getField(fields[i]), i); } return (R) outTuple; } }
@Override public Tuple getKey(IN value) { Tuple key = Tuple.newInstance(fields.length); for (int i = 0; i < fields.length; i++) { key.setField(Array.get(value, fields[i]), i); } return key; }
public void join(T1 in1, T2 in2, Collector<R> out) { for (int i = 0; i < fields.length; i++) { if (isFromFirst[i]) { if (fields[i] >= 0 && in1 != null) { outTuple.setField(((Tuple) in1).getField(fields[i]), i); } else { outTuple.setField(in1, i); } } else { if (fields[i] >= 0 && in2 != null) { outTuple.setField(((Tuple) in2).getField(fields[i]), i); } else { outTuple.setField(in2, i); } } } out.collect(outTuple); }
@Override public T createInstance() { try { T t = tupleClass.newInstance(); for (int i = 0; i < arity; i++) { t.setField(fieldSerializers[i].createInstance(), i); } return t; } catch (Exception e) { throw new RuntimeException("Cannot instantiate tuple.", e); } }
@Override @SuppressWarnings("unchecked") public R result() { try { Class tupleClass = Tuple.getTupleClass(columnAggregators.length); R tuple = (R) tupleClass.newInstance(); for (int i = 0; i < columnAggregators.length; i++) { tuple.setField(columnAggregators[i].result(), i); } return tuple; } catch (InstantiationException | IllegalAccessException e) { throw new RuntimeException("Unexpected error instantiating Tuple class for aggregation results", e); } } }
@Override public T deserialize(T reuse, DataInputView source) throws IOException { for (int i = 0; i < arity; i++) { Object field = fieldSerializers[i].deserialize(reuse.getField(i), source); reuse.setField(field, i); } return reuse; }
@Override public Tuple getKey(IN value) { Tuple key = Tuple.newInstance(keyLength); comparator.extractKeys(value, keyArray, 0); for (int i = 0; i < keyLength; i++) { key.setField(keyArray[i], i); } return key; }
@Override public T deserialize(DataInputView source) throws IOException { T tuple = instantiateRaw(); for (int i = 0; i < arity; i++) { Object field = fieldSerializers[i].deserialize(source); tuple.setField(field, i); } return tuple; }
@Override public T set(T record, F fieldValue) { final R inner = record.getField(pos); record.setField(innerAccessor.set(inner, fieldValue), pos); return record; } }
@Override public T copy(T from) { T target = instantiateRaw(); for (int i = 0; i < arity; i++) { Object copy = fieldSerializers[i].copy(from.getField(i)); target.setField(copy, i); } return target; }
@Override public Tuple deserialize(boolean normalized) throws IOException { Tuple result = createTuple(deserializer.length); for (int x = 0; x < result.getArity(); x++) { result.setField(deserializer[x].deserialize(normalized), x); } return result; } }
@Override public T copy(T from, T reuse) { for (int i = 0; i < arity; i++) { Object copy = fieldSerializers[i].copy((Object)from.getField(i), reuse.getField(i)); reuse.setField(copy, i); } return reuse; }
@Override public OUT nextRecord(OUT reuse) throws IOException { final Row item = resultSet.one(); for (int i = 0; i < reuse.getArity(); i++) { reuse.setField(item.getObject(i), i); } return reuse; } }
@Override public void processElement(StreamRecord<IN> element) throws Exception { for (int i = 0; i < this.numFields; i++) { outTuple.setField(((Tuple) element.getValue()).getField(fields[i]), i); } output.collect(element.replace(outTuple)); }
@Test public void testConvertFromTupleToArray() throws InstantiationException, IllegalAccessException { for (int i = 0; i < Tuple.MAX_ARITY; i++) { Tuple currentTuple = (Tuple) CLASSES[i].newInstance(); String[] currentArray = new String[i + 1]; for (int j = 0; j <= i; j++) { currentTuple.setField(testStrings[j], j); currentArray[j] = testStrings[j]; } arrayEqualityCheck(currentArray, new ArrayFromTuple().extract(currentTuple)); } }
@Test public void testSingleFieldExtraction() throws InstantiationException, IllegalAccessException { // extract single fields for (int i = 0; i < Tuple.MAX_ARITY; i++) { Tuple current = (Tuple) CLASSES[i].newInstance(); for (int j = 0; j < i; j++) { current.setField(testStrings[j], j); } for (int j = 0; j < i; j++) { assertEquals(testStrings[j], new FieldFromTuple<String>(j).extract(current)); } } }