public java.lang.String next() {
char[] buf = new char[length];
for (int i = 0; i < length; i++) {
buf[i] = cg.next();
}
return new java.lang.String(buf);
}
public K next() {
lock.lock();
try {
return generator.next();
} finally {
lock.unlock();
}
}
public static <T> void assertList(Generator<T> generator, T... expected) {
for (T x : expected) {
T c = generator.next();
System.out.print(c + " , ");
assert x.equals(c);
}
System.out.println("...");
}
public void run() {
try {
while (!Thread.interrupted()) {
for (int i = 0; i < ExchangerDemo.size; i++) holder.add(generator.next());
// Exchange full for empty:
holder = exchanger.exchange(holder);
}
} catch (InterruptedException e) {
// OK to terminate this way.
}
}
public static void test(Class<?> surroundingClass) {
for (Class<?> type : surroundingClass.getClasses()) {
System.out.print(type.getSimpleName() + ": ");
try {
Generator<?> g = (Generator<?>) type.newInstance();
for (int i = 0; i < size; i++) System.out.printf(g.next() + " ");
System.out.println();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public static void main(String[] args) {
Generator<CountedObject> gen = BasicGenerator.create(CountedObject.class);
for (int i = 0; i < 5; i++) System.out.println(gen.next());
}
@Override
RevCommit next() throws MissingObjectException, IncorrectObjectTypeException, IOException {
Generator g;
final RevWalk w = walker;
RevFilter rf = w.getRevFilter();
final TreeFilter tf = w.getTreeFilter();
AbstractRevQueue q = walker.queue;
if (rf == RevFilter.MERGE_BASE) {
// Computing for merge bases is a special case and does not
// use the bulk of the generator pipeline.
//
if (tf != TreeFilter.ALL)
throw new IllegalStateException(
"Cannot combine TreeFilter " + tf + " with RevFilter " + rf + ".");
final MergeBaseGenerator mbg = new MergeBaseGenerator(w);
walker.pending = mbg;
walker.queue = AbstractRevQueue.EMPTY_QUEUE;
mbg.init(q);
return mbg.next();
}
final boolean uninteresting = q.anybodyHasFlag(RevWalk.UNINTERESTING);
boolean boundary = walker.hasRevSort(RevSort.BOUNDARY);
if (!boundary && walker instanceof ObjectWalk) {
// The object walker requires boundary support to color
// trees and blobs at the boundary uninteresting so it
// does not produce those in the result.
//
boundary = true;
}
if (boundary && !uninteresting) {
// If we were not fed uninteresting commits we will never
// construct a boundary. There is no reason to include the
// extra overhead associated with that in our pipeline.
//
boundary = false;
}
final DateRevQueue pending;
int pendingOutputType = 0;
if (q instanceof DateRevQueue) pending = (DateRevQueue) q;
else pending = new DateRevQueue(q);
if (tf != TreeFilter.ALL) {
rf = AndRevFilter.create(rf, new RewriteTreeFilter(w, tf));
pendingOutputType |= HAS_REWRITE | NEEDS_REWRITE;
}
walker.queue = q;
g = new PendingGenerator(w, pending, rf, pendingOutputType);
if (boundary) {
// Because the boundary generator may produce uninteresting
// commits we cannot allow the pending generator to dispose
// of them early.
//
((PendingGenerator) g).canDispose = false;
}
if ((g.outputType() & NEEDS_REWRITE) != 0) {
// Correction for an upstream NEEDS_REWRITE is to buffer
// fully and then apply a rewrite generator that can
// pull through the rewrite chain and produce a dense
// output graph.
//
g = new FIFORevQueue(g);
g = new RewriteGenerator(g);
}
if (walker.hasRevSort(RevSort.TOPO) && (g.outputType() & SORT_TOPO) == 0)
g = new TopoSortGenerator(g);
if (walker.hasRevSort(RevSort.REVERSE)) g = new LIFORevQueue(g);
if (boundary) g = new BoundaryGenerator(w, g);
else if (uninteresting) {
// Try to protect ourselves from uninteresting commits producing
// due to clock skew in the commit time stamps. Delay such that
// we have a chance at coloring enough of the graph correctly,
// and then strip any UNINTERESTING nodes that may have leaked
// through early.
//
if (pending.peek() != null) g = new DelayRevQueue(g);
g = new FixUninterestingGenerator(g);
}
w.pending = g;
return g.next();
}
public CollectionData(Generator<T> gen, int quantity) {
for (int i = 0; i < quantity; i++) {
add(gen.next());
}
}
public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int n) {
for (int i = 0; i < n; i++) coll.add(gen.next());
return coll;
}
// Generator version:
public static <T> void fill(Addable<T> addable, Generator<T> generator, int size) {
for (int i = 0; i < size; i++) addable.add(generator.next());
}
// Fill an array using a generator:
public static void fill(Collection c, Generator gen, int count) {
for (int i = 0; i < count; i++) c.add(gen.next());
}
