/** * @param path path to first element * @param pathTo path to second element * @return environment in which the generic parameters in the path to the first element are bound * to those in the path to the second element, or null type on error */ public static ResolvedName mapGenericParameters( final Deque<? extends INamedElement> path, final Deque<? extends INamedElement> pathTo) { // Construct an environment in which the current function's generic parameters // are bound to those of the eventual override. final Deque<List<? extends ResolvedName>> tableau = new LinkedList<>(ResolvedName.fromNamedElement(path.getLast()).tableau()); final Iterator<? extends INamedElement> pathIt = path.descendingIterator(); while (pathIt.hasNext()) { pathIt.next(); tableau.removeLast(); } CachedIterator<? extends INamedElement> itPathTo = null; CachedIterator<? extends IGenericParameter> itGPTo = null; boolean end = false; { // Initialise iterators into direct override's generic parameters. boolean foundValid = false; itPathTo = Iterators.cached(pathTo.iterator()); while (!foundValid && itPathTo.hasItem()) { itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator()); while (!foundValid && itGPTo.hasItem()) { foundValid = true; if (!foundValid) itGPTo.next(); } if (!foundValid) itPathTo.next(); } if (!foundValid) end = true; } for (final INamedElement elt : path) { final List<ResolvedName> row = new ArrayList<>(); for (@SuppressWarnings("unused") final IGenericParameter genericParameter : elt.genericParameters()) { if (end) return null; row.add(ResolvedName.fromNamedElement(itGPTo.item())); { // Increment iterators into direct override's generic parameters. boolean init = true; boolean foundValid = false; if (!init) itPathTo = Iterators.cached(pathTo.iterator()); while (!foundValid && itPathTo.hasItem()) { if (!init) itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator()); while (!foundValid && itGPTo.hasItem()) { if (!init) foundValid = true; init = false; if (!foundValid) itGPTo.next(); } if (!foundValid) itPathTo.next(); } if (!foundValid) end = true; } } tableau.add(row); } if (!end) return null; return ResolvedName.newNameReference(path.getLast(), tableau); }
@Test(expected = NoSuchElementException.class) public void Deque_iterator_throwsNoSuchElement() { deque.addFirst("firstString"); deque.addFirst("secondString"); Iterator<String> dequeIterator = deque.iterator(); dequeIterator.next(); dequeIterator.next(); dequeIterator.next(); }
@Test public void Deque_iterator_hasNextIsFalse() { deque.addFirst("firstString"); deque.addFirst("secondString"); Iterator<String> dequeIterator = deque.iterator(); dequeIterator.next(); dequeIterator.next(); assertFalse(dequeIterator.hasNext()); }
@Test(expected = NoSuchElementException.class) public void testNextFromEmptyIterator() { Deque<String> deque = new Deque<String>(); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.next(); i.next(); // should throw exception }
@Test(expected = UnsupportedOperationException.class) public void testRemoveFromIterator() { Deque<String> deque = new Deque<String>(); deque.addFirst("middle"); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.remove(); // should throw exception }
@Test public void Deque_iterator_iterates() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.addLast("thirdString"); Iterator<String> dequeIterator = deque.iterator(); assertEquals(dequeIterator.next(), "secondString"); assertEquals(dequeIterator.next(), "firstString"); assertEquals(dequeIterator.next(), "thirdString"); }
/** * Delete log segments whose contents have been turned into SSTables. NOT threadsafe. * * <p>param @ context The commitLog context . param @ id id of the columnFamily being flushed to * disk. */ private void discardCompletedSegmentsInternal( CommitLogSegment.CommitLogContext context, Integer id) throws IOException { if (logger.isDebugEnabled()) logger.debug("discard completed log segments for " + context + ", column family " + id + "."); /* * log replay assumes that we only have to look at entries past the last * flush position, so verify that this flush happens after the last. See CASSANDRA-936 */ assert context.position >= context.getSegment().getHeader().getPosition(id) : "discard at " + context + " is not after last flush at " + context.getSegment().getHeader().getPosition(id); /* * Loop through all the commit log files in the history. Now process * all files that are older than the one in the context. For each of * these files the header needs to modified by resetting the dirty * bit corresponding to the flushed CF. */ Iterator<CommitLogSegment> iter = segments.iterator(); while (iter.hasNext()) { CommitLogSegment segment = iter.next(); CommitLogHeader header = segment.getHeader(); if (segment.equals(context.getSegment())) { // we can't just mark the segment where the flush happened clean, // since there may have been writes to it between when the flush // started and when it finished. so mark the flush position as // the replay point for this CF, instead. if (logger.isDebugEnabled()) logger.debug("Marking replay position " + context.position + " on commit log " + segment); header.turnOn(id, context.position); segment.writeHeader(); break; } header.turnOff(id); if (header.isSafeToDelete()) { logger.info("Discarding obsolete commit log:" + segment); segment.close(); DeletionService.submitDelete(segment.getHeaderPath()); DeletionService.submitDelete(segment.getPath()); // usually this will be the first (remaining) segment, but not always, if segment A contains // writes to a CF that is unflushed but is followed by segment B whose CFs are all flushed. iter.remove(); } else { if (logger.isDebugEnabled()) logger.debug( "Not safe to delete commit log " + segment + "; dirty is " + header.dirtyString()); segment.writeHeader(); } } }
public static void main(String[] args) { Deque<String> myDeque = new Deque<String>(); String[] str = new String[] {"Jrui", "Long", "Jason"}; myDeque.addFirst(str[0]); myDeque.addLast(str[2]); myDeque.addFirst(str[1]); Iterator<String> test = myDeque.iterator(); while (test.hasNext()) { String s = test.next(); StdOut.println(s); } }
@Test public void testIterator() { deque.addBack(3); deque.addBack(7); deque.addBack(4); Iterator<Integer> iterator = deque.iterator(); assertTrue(iterator.hasNext()); assertEquals(new Integer(3), iterator.next()); assertTrue(iterator.hasNext()); assertEquals(new Integer(7), iterator.next()); assertTrue(iterator.hasNext()); assertEquals(new Integer(4), iterator.next()); assertFalse(iterator.hasNext()); // The deque should not have been modified by the iteration assertEquals("<3, 7, 4>", deque.toString()); }
public static void main(String args[]) { Deque<Integer> d = new Deque<Integer>(); Iterator<Integer> a = d.iterator(); while (a.hasNext()) { StdOut.println(a.next()); } for (int i = 0; i < 10; i++) { d.addFirst(i); } for (int i = 0; i < 10; i++) { StdOut.println(d.removeFirst()); } }
@Test public void testIterator() { deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); deque.addFirst("5"); deque.removeFirst(); Iterator<String> iterator = deque.iterator(); int i = 4; while (iterator.hasNext()) { String s = iterator.next(); assertEquals(s, "" + i); i--; } }