List<Object> elements = Tuple.elements(entry.getTuple()); elements.clear(); elements.addAll(data.values());
List<Object> elements = Tuple.elements(entry.getTuple()); elements.clear(); elements.addAll(data.values());
@Override public void reset( Tuple value ) { elements = Tuple.elements( value ); } }
public DelegatedTuple( Tuple wrapped ) { // pass it in to prevent one being allocated super( Tuple.elements( wrapped ) ); }
@Override public void reset( Tuple value ) { elements = Tuple.elements( value ); } }
public WrappedTuple( TupleHasher tupleHasher, Tuple input ) { super( Tuple.elements( input ) ); this.tupleHasher = tupleHasher; }
/** * Method format uses the {@link Formatter} class for formatting this tuples values into a new string. * * @param format of type String * @return String */ public String format( String format ) { return String.format( format, elements() ); }
public void writeWith( TupleElementWriter[] writers, Tuple tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); for( int i = 0; i < writers.length; i++ ) writers[ i ].write( this, elements.get( i ) ); }
public void writeTyped( Class[] classes, Tuple tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); for( int i = 0; i < classes.length; i++ ) { Class type = classes[ i ]; writeTypedElement( type, elements.get( i ) ); } }
public static <V> Tuple reset( Tuple tuple, V... values ) { ( (Resettable<V>) Tuple.elements( tuple ) ).reset( values ); return tuple; } }
public <T extends Tuple> T readWith( TupleElementReader[] readers, T tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); elements.clear(); for( int i = 0; i < readers.length; i++ ) { Object element = readers[ i ].read( this ); elements.add( element ); } return tuple; }
public <T extends Tuple> T readTyped( Class[] classes, T tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); elements.clear(); for( int i = 0; i < classes.length; i++ ) { Class type = classes[ i ]; elements.add( readType( type ) ); } return tuple; }
@Override public Object[] current() { if( current == DUMMY ) throw new NoSuchElementException(); return Tuple.elements( current ).toArray( new Object[ current.size() ] ); } }
@Override public int hash( Tuple tuple, Hasher[] hashers ) { int hash = 1; List<Object> elements = Tuple.elements( tuple ); for( int i = 0; i < elements.size(); i++ ) { Object element = elements.get( i ); hash = 31 * hash + ( element != null ? hashers[ i % hashers.length ].hashCode( element ) : 0 ); } return hash; } }
public <T extends Tuple> T readUnTyped( T tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); elements.clear(); int len = getNumElements(); for( int i = 0; i < len; i++ ) elements.add( getNextElement() ); return tuple; }
public void writeUnTyped( Tuple tuple ) throws IOException { List<Object> elements = Tuple.elements( tuple ); writeIntInternal( elements.size() ); for( Object element : elements ) writeElement( element ); }
/** Creates a new {@link Tuple} with the specified values. */ public DataBuilder addTuple(Tuple tuple) { newTuple(); List<Object> elements = Tuple.elements(tuple); setTuple(elements.toArray(new Object[elements.size()])); return this; }
/** * Method add will add the given {@link cascading.tuple.Tuple} to this list. * * @param tuple of type Tuple */ @Override public boolean add( Tuple tuple ) { doSpill(); // spill if we break over the threshold current.add( Tuple.elements( tuple ).toArray( new Object[ tuple.size() ] ) ); size++; return true; }
public int hash( Tuple tuple, Hasher[] hashers ) { int hash = Murmur3.SEED; List<Object> elements = Tuple.elements( tuple ); for( int i = 0; i < elements.size(); i++ ) { Object element = elements.get( i ); int hashCode = hashers[ i % hashers.length ].hashCode( element ); hash = Murmur3.mixH1( hash, Murmur3.mixK1( hashCode ) ); } return Murmur3.fmix( hash, elements.size() ); } }
/** * Method asArray copies the elements of the given Tuple instance to the given Object array. * * @param tuple of type Tuple * @param destination of type Object[] * @return Object[] */ public static <T> T[] asArray( Tuple tuple, T[] destination ) { if( tuple.size() != destination.length ) throw new OperationException( "number of input tuple values: " + tuple.size() + ", does not match destination array size: " + destination.length ); return tuple.elements( destination ); }