public void accumulate(TaggedLogAPIEntity entity) throws Exception{ List<String> groupbyFieldValues = createGroup(entity); List<Double> preAggregatedValues = createPreAggregatedValues(entity); bucket.addDatapoint(groupbyFieldValues, preAggregatedValues); }
@Override public Function createFunction(){ return new Max(); } }
public HierarchicalAggregateEntity result(){ finalizeHierarchicalAggregateEntity(root); return this.root; } }
private void finalizeHierarchicalAggregateEntity(HierarchicalAggregateEntity entity){ for(GroupbyBucket.Function f : entity.getTmpValues()){ entity.getValues().add(f.result()); } for(HierarchicalAggregateEntity child : entity.getChildren().values()){ finalizeHierarchicalAggregateEntity(child); } entity.setTmpValues(null); }
private void addDatapoint(HierarchicalAggregateEntity entity, List<Double> values){ List<GroupbyBucket.Function> functions = entity.getTmpValues(); // initialize list of function if(functions.isEmpty()){ for(AggregateFunctionType type : aggregateFunctionTypes){ functions.add(GroupbyBucket._functionFactories.get(type.name()).createFunction()); } } int functionIndex = 0; for(Double v : values){ functions.get(functionIndex).run(v); functionIndex++; } }
private static void processIndex(List<SortOption> sortOptions) { for (int i = 0; i < sortOptions.size(); ++i) { SortOption so = sortOptions.get(i); so.setIndex(i); } }
public Map<List<String>, List<Double>> result(){ return bucket.result(); }
@Override public void run(double v){ this.incrCount(); this.summary += v; }
@Override public Function createFunction(){ return new Min(); } }
@Override public Function createFunction(){ return new Count(); } }
@Override public Function createFunction(){ return new Sum(); } }
@Override public void run(double v){ if(v < minimum){ minimum = v; } this.incrCount(); }
@Override public void run(double v){ if(v > maximum){ maximum = v; } this.incrCount(); }
@Override public Function createFunction(){ return new Avg(); } }
@Override public void accumulate(TaggedLogAPIEntity entity) throws Exception{ synchronized(mutex){ agg.accumulate(entity); } } }
/** * @param groupbyFields * @param aggregateFuntionTypes * @param aggregatedFields */ public FlatAggregator(List<String> groupbyFields, List<AggregateFunctionType> aggregateFuntionTypes, List<String> aggregatedFields){ super(groupbyFields, aggregateFuntionTypes, aggregatedFields); bucket = new GroupbyBucket(this.aggregateFunctionTypes); }
@Override public void run(double v){ total += v; this.incrCount(); } @Override
@Override public void entityCreated(TaggedLogAPIEntity entity) throws Exception{ accumulate(entity); }
public static EntityCreationListener synchronizedEntityCreationListener(EntityCreationListener listener){ return new SynchronizedEntityCreationListener(listener); } }
public Map<List<String>, List<Double>> result(){ if(this.ignoredEntityCounter > 0) LOG.warn("Ignored "+this.ignoredEntityCounter+" entities for reason: timestamp > "+this.endTime+" or < "+this.startTime); return bucket.result(); }