// Calls the Combiner object on each element to combine
// it with a running result, which is finally returned:
public static <T> T reduce(Iterable<T> seq, Combiner<T> combiner) {
Iterator<T> it = seq.iterator();
if (it.hasNext()) {
T result = it.next();
while (it.hasNext()) result = combiner.combine(result, it.next());
return result;
}
// If seq is the empty list:
return null; // Or throw exception
}
/**
* Remaps the stratifications from one stratification set to another, combining the values in V
* according to the combiner function.
*
* <p>stratifierToReplace defines a set of states S1, while newStratifier defines a new set S2.
* remappedStates is a map from all of S1 into at least some of S2. This function creates a new,
* fully initialized manager where all of the data in this new manager is derived from the
* original data in this object combined according to the mapping remappedStates. When multiple
* elements of S1 can map to the same value in S2, these are sequentially combined by the function
* combiner. Suppose for example at states s1, s2, and s3 all map to N1. Eventually the value
* associated with state N1 would be
*
* <p>value(N1) = combine(value(s1), combine(value(s2), value(s3))
*
* <p>in some order for s1, s2, and s3, which is not defined. Note that this function only
* supports combining one stratification at a time, but in principle a loop over stratifications
* and this function could do the multi-dimensional collapse.
*
* @param stratifierToReplace
* @param newStratifier
* @param combiner
* @param remappedStates
* @return
*/
public StratificationManager<K, V> combineStrats(
final K stratifierToReplace,
final K newStratifier,
final Combiner<V> combiner,
final Map<Object, Object> remappedStates) {
// make sure the mapping is reasonable
if (!newStratifier.getAllStates().containsAll(remappedStates.values()))
throw new ReviewedGATKException(
"combineStrats: remapped states contains states not found in newStratifer state set");
if (!remappedStates.keySet().containsAll(stratifierToReplace.getAllStates()))
throw new ReviewedGATKException(
"combineStrats: remapped states missing mapping for some states");
// the new strats are the old ones with the single replacement
final List<K> newStrats = new ArrayList<K>(getStratifiers());
final int stratOffset = newStrats.indexOf(stratifierToReplace);
if (stratOffset == -1)
throw new ReviewedGATKException(
"Could not find strat to replace "
+ stratifierToReplace
+ " in existing strats "
+ newStrats);
newStrats.set(stratOffset, newStratifier);
// create an empty but fully initialized new manager
final StratificationManager<K, V> combined = new StratificationManager<K, V>(newStrats);
// for each key, get its state, update it according to the map, and update the combined manager
for (int key = 0; key < size(); key++) {
// the new state is just the old one with the replacement
final List<Object> newStates = new ArrayList<Object>(getStatesForKey(key));
final Object oldState = newStates.get(stratOffset);
final Object newState = remappedStates.get(oldState);
newStates.set(stratOffset, newState);
// look up the new key given the new state
final int combinedKey = combined.getKey(newStates);
if (combinedKey == -1)
throw new ReviewedGATKException(
"Couldn't find key for states: " + Utils.join(",", newStates));
// combine the old value with whatever new value is in combined already
final V combinedValue = combiner.combine(combined.get(combinedKey), get(key));
// update the value associated with combined key
combined.set(combinedKey, combinedValue);
}
return combined;
}
/**
* Write partial content, only
*
* @param out
* @param start
* @param finish
* @throws IOException
*/
public void writeContent(OutputStream out, long start, Long finish) throws IOException {
Combiner combiner = new Combiner();
List<String> fanoutCrcs = getFanout().getHashes();
combiner.combine(fanoutCrcs, hashStore, blobStore, out, start, finish);
out.flush();
}