@Override public Iterator<T> iterator() { final ListIterator<T> listIter = list.listIterator(list.size()); return new Iterator<T>() { @Override public boolean hasNext() { return listIter.hasPrevious(); } @Override public T next() { return listIter.previous(); } @Override public void remove() { listIter.remove(); } }; } };
/** * Delete removed documents from the internal container. */ void refresh() { ListIterator<Document<K>> listIterator = documents_.listIterator(); while (listIterator.hasNext()) { if (listIterator.next() == null) listIterator.remove(); } }
public static <E> void fill(List<E> list, E value) { if (list == null) return; ListIterator<E> listIterator = list.listIterator(); while (listIterator.hasNext()) listIterator.set(value); }
private static DefaultWebFilterChain initChain(List<WebFilter> filters, WebHandler handler) { DefaultWebFilterChain chain = new DefaultWebFilterChain(filters, handler, null, null); ListIterator<? extends WebFilter> iterator = filters.listIterator(filters.size()); while (iterator.hasPrevious()) { chain = new DefaultWebFilterChain(filters, handler, iterator.previous(), chain); } return chain; }
List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size()); for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) { RLock lock = iterator.next(); boolean lockAcquired; try { acquiredLocks.add(lock); } else { if (locks.size() - acquiredLocks.size() == failedLocksLimit()) { break; acquiredLocks.clear(); while (iterator.hasPrevious()) { iterator.previous(); for (RLock rLock : acquiredLocks) { RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS); futures.add(future);
assertEquals(0, list.size()); assertFalse(list.contains(1)); assertFalse(list.remove((Integer)1)); assertTrue(list.add(1)); assertTrue(list.addAll(Arrays.asList(3, 4, 7))); list.add(1, 2); assertTrue(list.addAll(4, Arrays.asList(5, 6))); assertEquals(7, list.size()); assertEquals(7, list.size()); ListIterator<Integer> lit = list.listIterator(7); for (int i = 7; i > 0; i--) { assertEquals(i, lit.previous().intValue()); assertFalse(list.equals(list3)); list3.add(7); assertTrue(list3.equals(list)); assertTrue(list.equals(list3));
public void add(Object o) { checkMod(); int i = nextIndex(); get().add(i, o); last++; expected = list; iter = get().listIterator(i + 1); lastReturnedIndex = -1; }
ContentGroup(final LottieDrawable lottieDrawable, BaseLayer layer, String name, boolean hidden, List<Content> contents, @Nullable AnimatableTransform transform) { this.name = name; this.lottieDrawable = lottieDrawable; this.hidden = hidden; this.contents = contents; if (transform != null) { transformAnimation = transform.createAnimation(); transformAnimation.addAnimationsToLayer(layer); transformAnimation.addListener(this); } List<GreedyContent> greedyContents = new ArrayList<>(); for (int i = contents.size() - 1; i >= 0; i--) { Content content = contents.get(i); if (content instanceof GreedyContent) { greedyContents.add((GreedyContent) content); } } for (int i = greedyContents.size() - 1; i >= 0; i--) { greedyContents.get(i).absorbContent(contents.listIterator(contents.size())); } }
@Test public void testNoArguments() throws IOException { Tokenizer tokenizer = new Tokenizer(new Context("function myFunc(){}")); SyntaxAnalyzer analyzer = new SyntaxAnalyzer(environment, tokenizer); Assert.assertTrue(analyzer.getTree().size() == 1); Assert.assertTrue(analyzer.getTree().get(0) instanceof FunctionStmtToken); FunctionStmtToken func = (FunctionStmtToken)analyzer.getTree().listIterator().next(); Assert.assertTrue(func.getArguments().size() == 0); }
public void testBugCollections447() { final List treeList = new TreeList(); treeList.add("A"); treeList.add("B"); treeList.add("C"); treeList.add("D"); final ListIterator li = treeList.listIterator(); assertEquals("A", li.next()); assertEquals("B", li.next()); assertEquals("B", li.previous()); li.remove(); // Deletes "B" // previous() after remove() should move to // the element before the one just removed assertEquals("A", li.previous()); } }
private void replaceValue(List<Entry<K, V>> expected, Entry<K, V> newEntry) { for (ListIterator<Entry<K, V>> i = expected.listIterator(); i.hasNext(); ) { if (Helpers.equal(i.next().getKey(), newEntry.getKey())) { i.set(newEntry); return; } } throw new IllegalArgumentException( Platform.format("key %s not found in entries %s", newEntry.getKey(), expected)); }
void appendWhereClause(StringBuilder builder, String tablePrefixOrNull, List<Object> values) { ListIterator<WhereCondition> iter = whereConditions.listIterator(); while (iter.hasNext()) { if (iter.hasPrevious()) { builder.append(" AND "); } WhereCondition condition = iter.next(); condition.appendTo(builder, tablePrefixOrNull); condition.appendValuesTo(values); } }
/** An implementation of {@link List#indexOf(Object)}. */ static int indexOfImpl(List<?> list, @Nullable Object element) { if (list instanceof RandomAccess) { return indexOfRandomAccess(list, element); } else { ListIterator<?> listIterator = list.listIterator(); while (listIterator.hasNext()) { if (Objects.equal(element, listIterator.next())) { return listIterator.previousIndex(); } } return -1; } }
private static void assertTransformListIterator(List<String> list) { ListIterator<String> iterator = list.listIterator(1); assertEquals(1, iterator.nextIndex()); assertEquals("2", iterator.next()); assertEquals("3", iterator.next()); assertEquals("4", iterator.next()); assertEquals(4, iterator.nextIndex()); try { assertEquals("4", iterator.previous()); assertEquals("3", iterator.previous()); assertEquals("2", iterator.previous()); assertTrue(iterator.hasPrevious()); assertEquals("1", iterator.previous()); assertFalse(iterator.hasPrevious()); assertEquals(-1, iterator.previousIndex()); try { } catch (NoSuchElementException expected) { iterator.remove(); assertEquals(asList("2", "3", "4"), list); assertFalse(list.isEmpty());
/** * Remove a document from this cluster. * * @param index the index of vector container of documents */ void remove_document(int index) { ListIterator<Document<K>> listIterator = documents_.listIterator(index); Document<K> document = listIterator.next(); listIterator.set(null); composite_.sub_vector(document.feature()); }
@Override public int indexOf(Object o) { if (!(o instanceof List)) { return -1; } List<?> list = (List<?>) o; if (list.size() != axes.size()) { return -1; } ListIterator<?> itr = list.listIterator(); int computedIndex = 0; while (itr.hasNext()) { int axisIndex = itr.nextIndex(); int elemIndex = axes.get(axisIndex).indexOf(itr.next()); if (elemIndex == -1) { return -1; } computedIndex += elemIndex * axesSizeProduct[axisIndex + 1]; } return computedIndex; }
/** An implementation of {@link List#lastIndexOf(Object)}. */ static int lastIndexOfImpl(List<?> list, @Nullable Object element) { if (list instanceof RandomAccess) { return lastIndexOfRandomAccess(list, element); } else { ListIterator<?> listIterator = list.listIterator(list.size()); while (listIterator.hasPrevious()) { if (Objects.equal(element, listIterator.previous())) { return listIterator.nextIndex(); } } return -1; } }
List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size()); for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) { RLock lock = iterator.next(); boolean lockAcquired; try { acquiredLocks.add(lock); } else { if (locks.size() - acquiredLocks.size() == failedLocksLimit()) { break; acquiredLocks.clear(); while (iterator.hasPrevious()) { iterator.previous(); for (RLock rLock : acquiredLocks) { RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS); futures.add(future);
public void add(Object o) { checkMod(); int i = nextIndex(); get().add(i, o); expected = list; iter = get().listIterator(i + 1); lastReturnedIndex = -1; }
public Iterator<T> iterator() { final ListIterator<T> itr = lst.listIterator(lst.size()); return new Iterator<T>() { public boolean hasNext() { return itr.hasPrevious(); } public T next() { return itr.previous(); } public void remove() { itr.remove(); } }; } };