Package org.roaringbitmap.buffer

Class RoaringBatchIterator

java.lang.Object

org.roaringbitmap.buffer.RoaringBatchIterator

All Implemented Interfaces:

Cloneable, BatchIterator

public final class RoaringBatchIterator
extends Object
implements BatchIterator

Constructor Summary

Constructors

Constructor	Description
RoaringBatchIterator(MappeableContainerPointer containerPointer)

Method Summary

Modifier and Type	Method	Description
void	advanceIfNeeded(int target)	If needed, advance as long as the next value is smaller than minval The advanceIfNeeded method is used for performance reasons, to skip over unnecessary repeated calls to next.
BatchIterator	clone()	Creates a copy of the iterator.
boolean	hasNext()	Returns true is there are more values to get.
int	nextBatch(int[] buffer)	Writes the next batch of integers onto the buffer, and returns how many were written.

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.roaringbitmap.BatchIterator

asIntIterator

Constructor Details

RoaringBatchIterator

public RoaringBatchIterator(MappeableContainerPointer containerPointer)

Method Details

nextBatch

public int nextBatch(int[] buffer)

Description copied from interface: BatchIterator

Writes the next batch of integers onto the buffer, and returns how many were written. Aims to fill the buffer.

Specified by:

nextBatch in interface BatchIterator

Parameters:

buffer - - the target to write onto

Returns:

how many values were written during the call.

hasNext

public boolean hasNext()

Description copied from interface: BatchIterator

Returns true is there are more values to get.

Specified by:

hasNext in interface BatchIterator

Returns:

whether the iterator is exhaused or not.

advanceIfNeeded

public void advanceIfNeeded(int target)

Description copied from interface: BatchIterator

If needed, advance as long as the next value is smaller than minval 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 integers (e.g., int[] x = {1,4,5}) and a BatchIterator. You might do it as follows...

     int[] buffer = new int[128];
     BatchIterator j = // get an iterator
     int val = // first value from my other data structure
     j.advanceIfNeeded(val);
     while ( j.hasNext() ) {
       int limit = j.nextBatch(buffer);
       for (int i = 0; i < limit; i++) {
         if (buffer[i] == val) {
           // got it!
           // 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 BatchIterator

Parameters:

target - threshold

clone

public BatchIterator clone()

Description copied from interface: BatchIterator

Creates a copy of the iterator.

Specified by:

clone in interface BatchIterator

Overrides:

clone in class Object

Returns:

a clone of the current iterator