@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { BatchState state = (BatchState) processorContext.state[_context.getStateIndex()]; state.tuples.add(tuple); state.args.add(_projection.create(tuple)); }
@Override public void execute(Map<TridentTuple, Object> state, int streamIndex, TridentTuple full, TridentCollector collector) { ProjectionFactory groupFactory = _groupFactories.get(streamIndex); ProjectionFactory inputFactory = _inputFactories.get(streamIndex); TridentTuple group = groupFactory.create(full); TridentTuple input = inputFactory.create(full); Object curr; if (!state.containsKey(group)) { curr = _reducer.init(collector, group); state.put(group, curr); } else { curr = state.get(group); } _reducer.execute(curr, streamIndex, group, input, collector); }
@Override public void updateState(MapState map, List<TridentTuple> tuples, TridentCollector collector) { Map<List<Object>, List<TridentTuple>> grouped = new HashMap<>(); for(TridentTuple t: tuples) { List<Object> group = _groupFactory.create(t); List<TridentTuple> groupTuples = grouped.get(group); if(groupTuples==null) { groupTuples = new ArrayList<>(); grouped.put(group, groupTuples); } groupTuples.add(_inputFactory.create(t)); } List<List<Object>> uniqueGroups = new ArrayList<>(grouped.keySet()); List<ValueUpdater> updaters = new ArrayList<>(uniqueGroups.size()); for(List<Object> group: uniqueGroups) { updaters.add(new ReducerValueUpdater(_agg, grouped.get(group))); } List<Object> results = map.multiUpdate(uniqueGroups, updaters); for (int i = 0; i < uniqueGroups.size(); i++) { List<Object> group = uniqueGroups.get(i); Object result = results.get(i); collector.emit(_factory.create(new List[] { group, new Values(result) })); } }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext, tuple); _function.execute(_projection.create(tuple), _collector); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); _agg.aggregate(processorContext.state[_context.getStateIndex()], _projection.create(tuple), _collector); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); int i = _streamToIndex.get(streamId); _reducer.execute(processorContext.state[_context.getStateIndex()], i, _projectionFactories[i].create(tuple), _collector); }
public void aggregate(ChainedResult val, TridentTuple tuple, TridentCollector collector) { val.setFollowThroughCollector(collector); for (int i = 0; i < _aggs.length; i++) { TridentTuple projected = _inputFactories[i].create((TridentTupleView) tuple); _aggs[i].aggregate(val.objs[i], projected, val.collectors[i]); } }
public void receive(ProcessorContext context, Tuple tuple) { TridentTuple t = _project.create(_factory.create(tuple)); for (TridentProcessor r : _receivers) { r.execute(context, _stream, t); } }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); _agg.aggregate(processorContext.state[_context.getStateIndex()], _projection.create(tuple), _collector); }
@Override public void aggregate(Object[] arr, TridentTuple tuple, TridentCollector collector) { GroupCollector groupColl = (GroupCollector) arr[0]; Map<List, Object> val = (Map) arr[1]; TridentTuple group = _groupFactory.create((TridentTupleView) tuple); TridentTuple input = _inputFactory.create((TridentTupleView) tuple); Object curr; if (!val.containsKey(group)) { curr = _agg.init(arr[2], groupColl); val.put((List) group, curr); } else { curr = val.get(group); } groupColl.currGroup = group; _agg.aggregate(curr, input, groupColl); }
@Override public void updateState(MapState map, List<TridentTuple> tuples, TridentCollector collector) { List<List<Object>> groups = new ArrayList<List<Object>>(tuples.size()); List<ValueUpdater> updaters = new ArrayList<ValueUpdater>(tuples.size()); for (TridentTuple t : tuples) { groups.add(_groupFactory.create(t)); updaters.add(new CombinerValueUpdater(_agg, _inputFactory.create(t).getValue(0))); } List<Object> newVals = map.multiUpdate(groups, updaters); for (int i = 0; i < tuples.size(); i++) { List<Object> key = groups.get(i); Object result = newVals.get(i); collector.emit(_factory.create(new List[] { key, new Values(result) })); } }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { ((List) processorContext.state[_context.getStateIndex()]).add(_projection.create(tuple)); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); _function.execute(_projection.create(tuple), _collector); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { // add tuple to the batch state Object state = processorContext.state[tridentContext.getStateIndex()]; ((List<TridentTuple>) state).add(projection.create(tuple)); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { TridentTuple toEmit = _factory.create(tuple); for (TupleReceiver r : _context.getReceivers()) { r.execute(processorContext, _context.getOutStreamId(), toEmit); } }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); _agg.aggregate(processorContext.state[_context.getStateIndex()], _projection.create(tuple), _collector); }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext); int i = _streamToIndex.get(streamId); _reducer.execute(processorContext.state[_context.getStateIndex()], i, _projectionFactories[i].create(tuple), _collector); }
public void aggregate(ChainedResult val, TridentTuple tuple, TridentCollector collector) { val.setFollowThroughCollector(collector); for (int i = 0; i < _aggs.length; i++) { TridentTuple projected = _inputFactories[i].create((TridentTupleView) tuple); _aggs[i].aggregate(val.objs[i], projected, val.collectors[i]); } }
public void receive(ProcessorContext context, Tuple tuple) { TridentTuple t = _project.create(_factory.create(tuple)); for (TridentProcessor r : _receivers) { r.execute(context, _stream, t); } }
@Override public void execute(ProcessorContext processorContext, String streamId, TridentTuple tuple) { _collector.setContext(processorContext, tuple); _function.execute(_projection.create(tuple), _collector); }