@Override public Iterator<T> iterator() { return Iterators.concat( /* lazily generate the iterators on each input only as needed */ new AbstractIndexedListIterator<Iterator<? extends T>>(inputs.length) { @Override public Iterator<? extends T> get(int i) { return inputs[i].iterator(); } }); } };
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver(), iterateOver()); } }.test();
@SuppressWarnings("unchecked") @Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(); } }.test();
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver(1), iterateOver(2)); } }.test();
/** Concats a varargs array of iterators without making a defensive copy of the array. */ static <T> Iterator<T> concatNoDefensiveCopy(Iterator<? extends T>... inputs) { for (Iterator<? extends T> input : checkNotNull(inputs)) { checkNotNull(input); } return concat(consumingForArray(inputs)); }
@Override public Iterator<T> iterator() { return Iterators.concat(Iterators.transform(inputs.iterator(), Iterables.<T>toIterator())); } };
@SuppressWarnings("unchecked") @Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver()); } }.test();
@SuppressWarnings("unchecked") @Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver(1)); } }.test();
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver(), iterateOver(1), iterateOver()); } }.test();
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat(iterateOver(1), iterateOver(), iterateOver(), iterateOver(2)); } }.test();
/** * Combines two iterators into a single iterator. The returned iterator iterates across the * elements in {@code a}, followed by the elements in {@code b}. The source iterators are not * polled until necessary. * * <p>The returned iterator supports {@code remove()} when the corresponding input iterator * supports it. */ public static <T> Iterator<T> concat(Iterator<? extends T> a, Iterator<? extends T> b) { checkNotNull(a); checkNotNull(b); return concat(consumingForArray(a, b)); }
/** * Combines three iterators into a single iterator. The returned iterator iterates across the * elements in {@code a}, followed by the elements in {@code b}, followed by the elements in * {@code c}. The source iterators are not polled until necessary. * * <p>The returned iterator supports {@code remove()} when the corresponding input iterator * supports it. */ public static <T> Iterator<T> concat( Iterator<? extends T> a, Iterator<? extends T> b, Iterator<? extends T> c) { checkNotNull(a); checkNotNull(b); checkNotNull(c); return concat(consumingForArray(a, b, c)); }
/** * Gets an iterator representing an immutable snapshot of all subscribers to the given event at * the time this method is called. */ Iterator<Subscriber> getSubscribers(Object event) { ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass()); List<Iterator<Subscriber>> subscriberIterators = Lists.newArrayListWithCapacity(eventTypes.size()); for (Class<?> eventType : eventTypes) { CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); if (eventSubscribers != null) { // eager no-copy snapshot subscriberIterators.add(eventSubscribers.iterator()); } } return Iterators.concat(subscriberIterators.iterator()); }
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.concat( asList(1).iterator(), Arrays.<Integer>asList().iterator(), asList(2).iterator()); } }.test();
public void testConcatPartiallyAdvancedSecond() { Iterator<String> itr1 = Iterators.concat(Iterators.singletonIterator("a"), Iterators.forArray("b", "c")); assertEquals("a", itr1.next()); assertEquals("b", itr1.next()); Iterator<String> itr2 = Iterators.concat(Iterators.singletonIterator("d"), itr1); assertEquals("d", itr2.next()); assertEquals("c", itr2.next()); }
public void testConcatPartiallyAdvancedFirst() { Iterator<String> itr1 = Iterators.concat(Iterators.singletonIterator("a"), Iterators.forArray("b", "c")); assertEquals("a", itr1.next()); assertEquals("b", itr1.next()); Iterator<String> itr2 = Iterators.concat(itr1, Iterators.singletonIterator("d")); assertEquals("c", itr2.next()); assertEquals("d", itr2.next()); }
/** Illustrates the somewhat bizarre behavior when a null is passed in. */ public void testConcatContainingNull() { @SuppressWarnings("unchecked") Iterator<Iterator<Integer>> input = asList(iterateOver(1, 2), null, iterateOver(3)).iterator(); Iterator<Integer> result = Iterators.concat(input); assertEquals(1, (int) result.next()); assertEquals(2, (int) result.next()); try { result.hasNext(); fail("no exception thrown"); } catch (NullPointerException e) { } try { result.next(); fail("no exception thrown"); } catch (NullPointerException e) { } // There is no way to get "through" to the 3. Buh-bye }
public void testConcatNested_appendToBeginning() { final int nestingDepth = 128; Iterator<Integer> iterator = iterateOver(); for (int i = 0; i < nestingDepth; i++) { iterator = Iterators.concat(iterateOver(1), iterator); } assertEquals(nestingDepth, Iterators.size(iterator)); }
public void testConcatNested_appendToEnd() { final int nestingDepth = 128; Iterator<Integer> iterator = iterateOver(); for (int i = 0; i < nestingDepth; i++) { iterator = Iterators.concat(iterator, iterateOver(1)); } assertEquals(nestingDepth, Iterators.size(iterator)); }
@SuppressWarnings("unchecked") public void testConcatVarArgsContainingNull() { try { Iterators.concat(iterateOver(1, 2), null, iterateOver(3), iterateOver(4), iterateOver(5)); fail("no exception thrown"); } catch (NullPointerException e) { } }