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