Class AbstractSkippingIterator<T>

    • Field Detail

      • mComparator

        protected final java.util.Comparator<T> mComparator
        The comparator which defines the order for skipping
    • Constructor Detail

      • AbstractSkippingIterator

        public AbstractSkippingIterator​(java.util.Comparator<T> theComparator)
    • Method Detail

      • comparator

        public java.util.Comparator<T> comparator()
        Returns the comparator for this iterator that specifies the order in which the elements are returned.
        Specified by:
        comparator in interface SkippingIterator<T>
      • estimatedSize

        public long estimatedSize()
        Returns the estimated size of this iterator without advancing the iterator or SkippingIterator.UNKNOWN_SIZE if the estimate is not known. The estimate is for the whole iterator and will not change after the iterator is advanced. There is no guarantee about the accuracy of the estimate.
        Specified by:
        estimatedSize in interface SkippingIterator<T>
      • remove

        public void remove()
        Specified by:
        remove in interface java.util.Iterator<T>
        Specified by:
        remove in interface<T>
      • computeNext

        protected abstract T computeNext()
        Return the next element to be returned by the iterator
        the next element
      • computeSkipTo

        protected abstract T computeSkipTo​(T theTarget)
        Returns the element that this iteration has skipped to or null if it ran off the end.
        theTarget - the skipping target
        the first element that is greater or equal to the skipping target, or null if it doesn't exist.
      • computeSkipTo

        protected T computeSkipTo​(T theTarget,
                                  T theBound)
      • isLessOrEqualThan

        public boolean isLessOrEqualThan​(T theElement,
                                         T theBound)
      • next

        public final T next()
        Specified by:
        next in interface java.util.Iterator<T>
        Specified by:
        next in interface<T>
      • endOfData

        protected final T endOfData()
        Signal that you're done iterating.
        nothing, the result is ignored
      • hasNext

        public final boolean hasNext()
        Specified by:
        hasNext in interface java.util.Iterator<T>
      • close

        public void close()
        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface CloseableIterator<T>
      • peek

        public final T peek()
        Implementation of peeking to the next item returned by the iterator. Anyone wishing to expose this method simply need to also implement the PeekingIterator interface.
        Specified by:
        peek in interface<T>
        the next element to be returned
      • skipTo

        public final T skipTo​(T theElement)
        Description copied from interface: SkippingIterator
        Returns the element which is equal or greater to theElement based on the ordering of the elements in the underlying data source, i.e., for two elements A, B s.t. B comes after A during iteration, theComparator should return A <= B. Note that skips are always in the forward direction. if theElement compares to less than the last returned element (or less than the bounding start of the iterator), then no skip will occur, and the returned value is the same as if `next()` was called.
        Specified by:
        skipTo in interface SkippingIterator<T>
        the smallest element A s.t. A <= theElement, if theElement > last seen element, or the output of next() if not.
      • skipTo

        public final T skipTo​(T theElement,
                              T theBound)
        Same contract as SkippingIterator.skipTo(Object) but skipping is bounded: if the next element that is greater than or equal to the target is greater than the bound, the method returns null. Implementations are free to not move their internal cursor beyond the bound which may enable them to make less work or skip IO. However, they must maintain their internal state to ensure that the smallest element that is greater than theBound is not consumed and is returned for the next call.
        Specified by:
        skipTo in interface SkippingIterator<T>
        theElement - the target
        theBound - the bound. null means no upper bound.
        the smallest element that's greater than or equal to the target but not greater than the bound.
      • validateSkipTarget

        protected void validateSkipTarget​(T theTarget)
      • reset

        public final void reset()
        Resets the iterator to the beginning so the following call will return the first element in this iteration.
        Specified by:
        reset in interface ResettableIterator<T>
      • isClosed

        protected boolean isClosed()
      • assertOpen

        protected void assertOpen()
      • resetState

        protected final void resetState()
      • performReset

        protected abstract void performReset()