How to use org.apache.crunch

 @Override
 public void process(Pair<K, Iterable<V>> input, Emitter<Pair<K, V>> emitter) {
  aggregator.reset();
  for (V v : input.second()) {
   aggregator.update(v);
  }
  for (V v : aggregator.results()) {
   emitter.emit(Pair.of(input.first(), v));
  }
 }    
}

 @Override
 public void process(
   Pair<Pair<Integer, Integer>, Pair<Collection<U>, Collection<V>>> input,
   Emitter<Pair<U,V>> emitter) {
  for (U l: input.second().first()) {
   for (V r: input.second().second()) {
    emitter.emit(Pair.of(l, r));
   }
  }
 }
}, ctf.pairs(left.getPType(), right.getPType()));

 @Override
 public void process(Pair<T, Void> input, Emitter<T> emitter) {
  emitter.emit(input.first());
 }
}, collection.getPType());

 @Override
 public void process(TupleN input,
   Emitter<Pair<TupleN, Void>> emitter) {
  emitter.emit(Pair.of(input, (Void) null));
 }
}, type);

 public void process(Pair<Integer, Pair<K, V>> input,
   Emitter<Pair<K, V>> emitter) {
  emitter.emit(input.second()); 
 }
}, base);

@Override
public void process(T input, Emitter<T> emitter) {
 if (accept(input)) {
  emitter.emit(input);
 }
}

 @Override
 public Collect<V1, V2, V3, V4> map(
   Tuple4<Collection<V1>, Collection<V2>, Collection<V3>, Collection<V4>> in) {
  return new Collect<V1, V2, V3, V4>(in.first(), in.second(), in.third(), in.fourth());
 }
},

 @Override
 public Collect<V1, V2, V3> map(
   Tuple3<Collection<V1>, Collection<V2>, Collection<V3>> in) {
  return new Collect<V1, V2, V3>(in.first(), in.second(), in.third());
 }
},

public static final <K, A, B, C, D> CombineFn<K, Tuple4<A, B, C, D>> quadAggregator(
  AggregatorFactory<A> a1, AggregatorFactory<B> a2, AggregatorFactory<C> a3,
  AggregatorFactory<D> a4) {
 return aggregator(new QuadAggregator<A, B, C, D>(a1.create(), a2.create(), a3.create(),
   a4.create()));
}

/**
 * @deprecated Use {@link Aggregators#MIN_FLOATS(int)}
 */
public static final <K> CombineFn<K, Float> MIN_FLOATS(int n) {
 return aggregator(new MinNAggregator<Float>(n));
}

/**
 * @deprecated Use {@link Aggregators#FIRST_N(int)}
 */
public static final <K, V> CombineFn<K, V> FIRST_N(int n) {
 return aggregator(new FirstNAggregator<V>(n));
}

 @Override
 public void process(
   Pair<Pair<Integer, Integer>, Pair<Collection<Pair<K1, U>>, Collection<Pair<K2, V>>>> input,
   Emitter<Pair<Pair<K1, K2>, Pair<U, V>>> emitter) {
  for (Pair<K1, U> l: input.second().first()) {
   for (Pair<K2, V> r: input.second().second()) {
    emitter.emit(Pair.of(Pair.of(l.first(), r.first()), Pair.of(l.second(), r.second())));
   }
  }
 }
},

 @Override
 public void process(Pair<Tuple4<V1, V2, V3, V4>, Void> input,
   Emitter<Tuple4<V1, V2, V3, V4>> emitter) {
  emitter.emit(input.first());
 }
}, collection.getPType());

 public void cleanup(Emitter<Pair<Integer, Pair<K, V>>> emitter) {
  for (Pair<K, V> p : values) {
   emitter.emit(Pair.of(0, p));
  }
 }
}

 @Override
 public void process(Pair<K, V> input, Emitter<V> emitter) {
  emitter.emit(input.second());
 }
}, ptable.getValueType());

 @Override
 public void process(Pair<TupleN, Void> input,
   Emitter<TupleN> emitter) {
  emitter.emit(input.first());
 }
}, collection.getPType());

 @Override
 public void process(Pair<U, V> input,
   Emitter<Pair<Pair<U, V>, Void>> emitter) {
  emitter.emit(Pair.of(input, (Void) null));
 }
}, type);

 @Override
 public void process(Pair<T, U> input, Emitter<U> emitter) {
  U second = input.second();
  if (second != null) {
   emitter.emit(second);
  }
 }
}

 @Override
 public void process(Pair<K, V> input, Emitter<K> emitter) {
  emitter.emit(input.first());
 }
}, ptable.getKeyType());

 @Override
 public void process(Pair<K, V> input, Emitter<K> emitter) {
  emitter.emit(input.first());
 }
}, ptable.getKeyType());