protected void closeCurrent() { close( iterators[ currentIterator ] ); }
/** * Method hasNext returns true if there is a next TupleEntry * * @return boolean */ public boolean hasNext() { if( iterators.length < currentIterator + 1 ) // past the end return false; if( iterators[ currentIterator ].hasNext() ) return true; closeCurrent(); currentIterator++; return iterators.length != currentIterator && hasNext(); }
public void accept( Tuple key, Iterator<Tuple>[] values ) { key = unwrapGrouping( key ); closure.reset( key, values ); // Buffer is using JoinerClosure directly if( !isBufferJoin ) tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); else tupleEntryIterator.reset( values ); keyEntry.setTuple( closure.getGroupTuple( key ) ); next.receive( this, 0, grouping ); }
/** * Method entryIterator return a TupleEntry iterator for this collection. * <p> * Note the same TupleEntry will be returned on each next() call. * * @return Iterator */ public Iterator<TupleEntry> entryIterator() { return new TupleEntryChainIterator( tupleEntry.getFields(), tuples.iterator() ); } }
/** * Method next returns the next TupleEntry. * * @return TupleEntry */ public TupleEntry next() { hasNext(); // force roll to next iterator entry.setTuple( iterators[ currentIterator ].next() ); return entry; }
/** Method close closes all underlying resources. */ public void close() { if( iterators.length != currentIterator ) closeCurrent(); }
Collections.sort( tuples, valueComparators[ 0 ] ); tupleEntryIterator.reset( tuples.iterator() );
@Override public void prepare() { int numJoinInputs = this.splice.isSelfJoin() ? this.splice.getNumSelfJoins() + 1 : this.splice.getPrevious().length; Fields[] keyFields = new Fields[numJoinInputs]; Fields[] valueFields = new Fields[numJoinInputs]; Scope outgoingScope = outgoingScopes.get( 0 ); if(!this.splice.isSelfJoin()) { for(int i=0; i < numJoinInputs; i++) { Scope incomingScope = incomingScopes.get( i ); int ordinal = incomingScope.getOrdinal(); keyFields[ordinal] = outgoingScope.getKeySelectors().get(incomingScope.getName()); valueFields[ordinal] = incomingScope.getIncomingSpliceFields(); } } else { Scope incomingScope = incomingScopes.get(0); keyFields[0] = outgoingScope.getKeySelectors().get(incomingScope.getName()); valueFields[0] = incomingScope.getIncomingSpliceFields(); for (int i = 1; i < numJoinInputs; i++) { keyFields[i] = keyFields[0]; valueFields[i] = valueFields[0]; } } this.closure = new JoinClosure(this.flowProcess, keyFields, valueFields); this.joiner = this.splice.getJoiner(); this.entryIterator = new TupleEntryChainIterator(outgoingScope.getOutValuesFields()); }
public void accept( Tuple key, Iterator<Tuple>[] values ) { key = unwrapGrouping( key ); closure.reset( key, values ); // Buffer is using JoinerClosure directly if( !isBufferJoin ) tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); else tupleEntryIterator.reset( values ); keyEntry.setTuple( closure.getGroupTuple( key ) ); next.receive( this, 0, grouping ); }
@Override public TupleEntryIterator openForRead( FlowProcess<? extends Config> flowProcess, Input input ) throws IOException { if( input != null ) return findMatchingTap( flowProcess ).openForRead( flowProcess, input ); Iterator iterators[] = new Iterator[ getTaps().length ]; for( int i = 0; i < getTaps().length; i++ ) iterators[ i ] = new TupleIterator( getTaps()[ i ].openForRead( flowProcess ) ); return new TupleEntryChainIterator( getSourceFields(), iterators ); }
private void performJoinWith( Tuple keyTuple ) { // never replace the first array, pos == 0 for( int i = 1; i < keyValues.length; i++ ) { // if key does not exist, #get will create an empty array list, // and store the key, which is not a copy if( keyValues[ i ].containsKey( keyTuple ) ) collections[ i ] = keyValues[ i ].get( keyTuple ); else collections[ i ] = Collections.EMPTY_LIST; } closure.reset( collections ); keyEntry.setTuple( keyTuple ); tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); next.receive( this, 0, grouping ); }
tupleEntryIterator = new TupleEntryChainIterator( outgoingScope.getOutValuesFields() );
@SuppressWarnings("unchecked") @Override public void run(Object input) { KeyPeekingIterator keyPeekingIt; try { keyPeekingIt = new KeyPeekingIterator((Iterator<Tuple>)input, keyBuilder[0]); } catch(ClassCastException cce) { throw new RuntimeException("GroupByInGate requires Iterator<Tuple>.", cce); } closure.reset(keyPeekingIt); // Buffer is using JoinerClosure directly if( !isBufferJoin ) { tupleEntryIterator.reset(splice.getJoiner().getIterator(closure)); } else { tupleEntryIterator.reset(keyPeekingIt); } Tuple groupTuple = keyPeekingIt.peekNextKey(); keyEntry.setTuple( groupTuple ); next.receive( this, grouping ); }
@Override public void run(Object input) { Iterator<Tuple2<Tuple, Tuple[]>> iterator; try { iterator = (Iterator<Tuple2<Tuple, Tuple[]>>) input; } catch(ClassCastException cce) { throw new RuntimeException("CoGroupInGate requires Iterator<Tuple2<Tuple, Tuple[]>", cce); } resultIterator.reset(iterator); resultIterator.hasNext(); // load first element into closure tupleEntryIterator.reset(resultIterator); keyEntry.setTuple( this.closure.getGroupTuple(null) ); next.receive( this, grouping ); }
private void push( Collection<Tuple>[] collections, Tuple keysTuple ) { closure.reset( collections ); keyEntry.setTuple( closure.getGroupTuple( keysTuple ) ); // create Closure type here tupleEntryIterator.reset( splice.getJoiner().getIterator( closure ) ); next.receive( this, 0, grouping ); } }
@SuppressWarnings("unchecked") @Override public void run(Object input) { KeyPeekingIterator iterator; try { iterator = new KeyPeekingIterator((Iterator<Tuple3<Tuple, Integer, Tuple>>)input); } catch(ClassCastException cce) { throw new RuntimeException("CoGroupBufferInGate requires Iterator<Tuple3<Tuple, Integer, Tuple>", cce); } Tuple key = iterator.peekNextKey(); closure.reset(iterator); // Buffer is using JoinerClosure directly if( !isBufferJoin ) { tupleEntryIterator.reset(splice.getJoiner().getIterator(closure)); } keyEntry.setTuple( this.closure.getGroupTuple(key) ); next.receive( this, grouping ); }