Class Roaring64Bitmap.PeekableIterator

    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      void advanceIfNeeded​(long minval)
      If needed, for a forwards iterator advance as long as the next value is smaller than thresholdVal For a reverse iterator advance as long as the next value is greater than thresholdVal The advanceIfNeeded method is used for performance reasons, to skip over unnecessary repeated calls to next.
      PeekableLongIterator clone()
      Creates a copy of the iterator.
      (package private) abstract boolean compare​(long next, long val)  
      (package private) abstract boolean compareHigh​(byte[] next, byte[] val)  
      (package private) abstract PeekableCharIterator getIterator​(Container container)  
      boolean hasNext()  
      long next()  
      long peekNext()
      Look at the next value without advancing The peek is useful when working with several iterators at once.
      • Methods inherited from class java.lang.Object

        equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Method Detail

      • compare

        abstract boolean compare​(long next,
                                 long val)
      • compareHigh

        abstract boolean compareHigh​(byte[] next,
                                     byte[] val)
      • hasNext

        public boolean hasNext()
        Specified by:
        hasNext in interface LongIterator
        Returns:
        whether there is another value
      • next

        public long next()
        Specified by:
        next in interface LongIterator
        Returns:
        next long value
      • advanceIfNeeded

        public void advanceIfNeeded​(long minval)
        Description copied from interface: PeekableLongIterator
        If needed, for a forwards iterator advance as long as the next value is smaller than thresholdVal For a reverse iterator advance as long as the next value is greater than thresholdVal The advanceIfNeeded method is used for performance reasons, to skip over unnecessary repeated calls to next. Suppose for example that you wish to compute the intersection between an ordered list of longs (e.g., longs[] x = {1,4,5}) and a PeekableIntIterator. You might do it as follows...
        
             PeekableLongIterator j = // get an iterator
             long val = // first value from my other data structure
             j.advanceIfNeeded(val);
             while ( j.hasNext() ) {
               if(j.next() == val) {
                 // ah! ah! val is in the intersection...
                 // do something here
                 val = // get next value?
               }
               j.advanceIfNeeded(val);
             }
             
        The benefit of calling advanceIfNeeded is that each such call can be much faster than repeated calls to "next". The underlying implementation can "skip" over some data.
        Specified by:
        advanceIfNeeded in interface PeekableLongIterator
        Parameters:
        minval - threshold
      • peekNext

        public long peekNext()
        Description copied from interface: PeekableLongIterator
        Look at the next value without advancing The peek is useful when working with several iterators at once. Suppose that you have 100 iterators, and you want to compute their intersections without materializing the result. You might do it as follows...
        
            PriorityQueue pq = new PriorityQueue(100,
              new Comparator<PeekableIntIterator>() {
                     public int compare(PeekableIntIterator a,
                                        PeekableIntIterator b) {
                         return a.peek() - b.peek();
                     }
                 });
         
            //...  populate pq
            
            while(! pq.isEmpty() ) {
              // get iterator with a smallest value
              PeekableLongIterator pi = pq.poll();
              long x = pi.next(); // advance
              // do something with x
              if(pi.hasNext()) pq.add(pi)
            }
            
        Notice how the peek method allows you to compare iterators in a way that the next method could not do.
        Specified by:
        peekNext in interface PeekableLongIterator
        Returns:
        next value