Java Aggregation类代码示例

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
public static void printAggregation(String name, String format, Collection<Aggregation> aggregationList) {
    Aggregation[] aggregationArray = new Aggregation[aggregationList.size()];
    int index = 0;
    for (Aggregation a : aggregationList) {
            aggregationArray[index] = a;
            index++;
    }
    BTraceRuntime.printAggregation(name, format, aggregationArray);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
/**
 * Precondition: Only values from the first Aggregation are printed. If the subsequent aggregations have 
 * values for keys which the first aggregation does not have, these rows are ignored. 
 * @param name
 * @param format
 * @param aggregationArray
 */
static void printAggregation(String name, String format, Aggregation[] aggregationArray) {
	if (aggregationArray.length > 1 && aggregationArray[0].getKeyData().size() > 1) {
		int aggregationDataSize = aggregationArray[0].getKeyData().get(0).getElements().length + aggregationArray.length;
		
		List<Object[]> aggregationData = new ArrayList<Object[]>();
		
		//Iterate through all keys in the first Aggregation and build up an array of aggregationData
		for (AggregationKey aggKey : aggregationArray[0].getKeyData()) {
			int aggDataIndex = 0;
			Object[] currAggregationData = new Object[aggregationDataSize];
			
			//Add the key to the from of the current aggregation Data
			for (Object obj : aggKey.getElements()) {
				currAggregationData[aggDataIndex] = obj;
				aggDataIndex++;
			}
			
			for (Aggregation agg : aggregationArray) {
				currAggregationData[aggDataIndex] = agg.getValueForKey(aggKey);
				aggDataIndex++;
        	}
			
			aggregationData.add(currAggregationData);
		}
			
		getCurrent().send(new GridDataCommand(name, aggregationData, format));
	}
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
static Aggregation newAggregation(AggregationFunction type) {
    return new Aggregation(type);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
static void addToAggregation(Aggregation aggregation, long value) {
    aggregation.add(value);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
static void clearAggregation(Aggregation aggregation) {
    aggregation.clear();
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
static void truncateAggregation(Aggregation aggregation, int count) {
    aggregation.truncate(count);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
/**
 * Creates a new aggregation based on the given aggregation function type.
 *
 * @param type the aggregating function to be performed on the data being added to the aggregation.
 */
public static Aggregation newAggregation(AggregationFunction type) {
    return Aggregations.newAggregation(type);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
/**
 * Adds a value to the aggregation with no grouping key. This method should be used when the aggregation
 * is to calculate only a single aggregated value.
 *
 * @param aggregation the aggregation to which the value should be added
 */
public static void addToAggregation(Aggregation aggregation, long value) {
    Aggregations.addToAggregation(aggregation, value);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
/**
 * Resets values within the aggregation to the default. This will affect all values within the aggregation
 * when multiple aggregation keys have been used.
 *
 * @param aggregation the aggregation to be cleared
 */
public static void clearAggregation(Aggregation aggregation) {
    Aggregations.clearAggregation(aggregation);
}
 

import com.sun.btrace.aggregation.Aggregation; //导入依赖的package包/类
/**
 * Removes all aggregated values from the aggregation except for the largest or smallest
 * <code>abs(count)</code> elements.
 *
 * <p>If <code>count</code> is positive, the largest aggregated values in the aggregation will be
 * preserved. If <code>count</code> is negative the smallest values will be preserved. If <code>count</code>
 * is zero then all elements will be removed.
 *
 * <p>Behavior is intended to be similar to the dtrace <code>trunc()</code> function.
 *
 * @param aggregation the aggregation to be truncated
 * @param count the number of elements to preserve. If negative, the smallest <code>abs(count)</code> elements are preserved.
 */
public static void truncateAggregation(Aggregation aggregation, int count) {
    Aggregations.truncateAggregation(aggregation, count);
}