How to use

first

method

in

org.apache.crunch.Pair

 @Override
 public Double map(Pair<Double, Long> input) {
  return input.first() / input.second();
 }
}, ptf.doubles());

 @Override
 public Double map(Pair<Double, Long> input) {
  return input.first() / input.second();
 }
}, ptf.doubles());

 /**
  * Split up the input record to make coding a bit more manageable.
  * 
  * @param input The input record.
  * @param emitter The emitter to send the output to.
  */
 @Override
 public void process(Pair<Pair<K, Integer>, Iterable<Pair<U, V>>> input,
   Emitter<Pair<K, Pair<U, V>>> emitter) {
  join(input.first().first(), input.first().second(), input.second(), emitter);
 }
}

public InMemoryJoinFn(Iterable<Pair<K, V>> iterable) {
 joinMap = HashMultimap.create();
 for (Pair<K, V> joinPair : iterable) {
  joinMap.put(joinPair.first(), joinPair.second());
 }
}

 @Override
 public Tuple2<K, V> apply(@Nullable Pair<K, V> kv) {
  return kv == null ? null : new Tuple2<K, V>(kv.first(), kv.second());
 }
};

private Map<K, V> delegate() {
 if (delegate == null) {
  delegate = new HashMap<K, V>();
  for (Pair<K, V> x : iterable) {
   delegate.put(x.first(), x.second());
  }
 }
 return delegate;
}

 @Override
 public void add(Pair<Pair<K, SK>, V> record) {
  K primary = record.first().first();
  if (!map.containsKey(primary)) {
   map.put(primary, Lists.<Pair<SK, V>>newArrayList());
  }
  map.get(primary).add(Pair.of(record.first().second(), record.second()));
 }
}

 @Override
 public void process(Pair<T, Pair<Collection<Boolean>, Collection<Boolean>>> input,
   Emitter<T> emitter) {
  Pair<Collection<Boolean>, Collection<Boolean>> groups = input.second();
  if (!groups.first().isEmpty() && !groups.second().isEmpty()) {
   emitter.emit(input.first());
  }
 }
}, coll1.getPType());

 @Override
 public void process(Pair<T, Pair<Collection<Boolean>, Collection<Boolean>>> input, Emitter<T> emitter) {
  Pair<Collection<Boolean>, Collection<Boolean>> groups = input.second();
  if (!groups.first().isEmpty() && groups.second().isEmpty()) {
   emitter.emit(input.first());
  }
 }
}, coll1.getPType());

 @Override
 public Pair<V2, V1> map(Pair<V1, V2> input) {
  if (input == null) {
   return null;
  }
  return Pair.of(input.second(), input.first());
 }
}

 @Override
 public Pair<Integer, T> map(Pair<Integer, Pair<Double, T>> p) {
  return Pair.of(p.first(), p.second().second());
 }
}, ptf.pairs(ptf.ints(), ttype));

 @Override
 public Pair<K, Long> map(Pair<K, Long> input) {
  return Pair.of(input.first(), -input.second());
 }
}, table.getPTableType());

 @Override
 public Pair<Pair<K, V1>, Pair<V1, V2>> map(Pair<K, Pair<V1, V2>> input) {
  return Pair.of(Pair.of(input.first(), input.second().first()), input.second());
 }
}  

 @Override
 public void process(Pair<T, Pair<Collection<Boolean>, Collection<Boolean>>> input,
   Emitter<Tuple3<T, T, T>> emitter) {
  Pair<Collection<Boolean>, Collection<Boolean>> groups = input.second();
  boolean inFirst = !groups.first().isEmpty();
  boolean inSecond = !groups.second().isEmpty();
  T t = input.first();
  emitter.emit(Tuple3.of(inFirst && !inSecond ? t : null, !inFirst && inSecond ? t : null, inFirst
    && inSecond ? t : null));
 }
}, typeFamily.triples(type, type, type));

 @Override
 public Result<V> map(Pair<Collection<Pair<Double, V>>, Long> input) {
  return new Result<V>(input.second(), input.first());
 }
}, new MapFn<Result<V>, Pair<Collection<Pair<Double, V>>, Long>>() {

 @Override
 public void process(Pair<T, Pair<Collection<Boolean>, Collection<Boolean>>> input,
   Emitter<Tuple3<T, T, T>> emitter) {
  Pair<Collection<Boolean>, Collection<Boolean>> groups = input.second();
  boolean inFirst = !groups.first().isEmpty();
  boolean inSecond = !groups.second().isEmpty();
  T t = input.first();
  emitter.emit(Tuple3.of(
    inFirst && !inSecond ? t : null,
      !inFirst && inSecond ? t : null,
        inFirst && inSecond ? t : null));
 }
}, typeFamily.triples(type, type, type));

 @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 Pair<K, Result<V>> map(Pair<K, Iterable<V>> input) {
  List<V> values = Lists.newArrayList(input.second().iterator());
  Collections.sort(values);
  return Pair.of(input.first(), new Result<V>(values.size(), findQuantiles(values.iterator(), values.size(), quantileList)));
 }
}

 @Override
 public Pair<K, Result<V>> map(Pair<K, Iterable<V>> input) {
  List<V> values = Lists.newArrayList(input.second().iterator());
  Collections.sort(values);
  return Pair.of(input.first(), new Result<V>(values.size(), findPercentiles(values.iterator(), values.size(), percentileList)));
 }
}

 @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()));