Java IntIterator.hasNext方法代码示例

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public MiruIntIterator descendingIntIterator(ImmutableRoaringBitmap bitmap) {
    final IntIterator intIterator = bitmap.getReverseIntIterator();
    return new MiruIntIterator() {

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public int next() {
            return intIterator.next();
        }
    };
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public MiruIntIterator descendingIntIterator(RoaringBitmap bitmap) {
    final IntIterator intIterator = bitmap.getReverseIntIterator();
    return new MiruIntIterator() {

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public int next() {
            return intIterator.next();
        }
    };
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test(dataProvider = "miruAuthzIndexDataProviderWithData")
public void storeAndGetAuthz(MiruAuthzIndex<RoaringBitmap, RoaringBitmap> miruAuthzIndex,
    MiruAuthzUtils miruAuthzUtils,
    Map<String, List<Integer>> bitsIn) throws Exception {

    StackBuffer stackBuffer = new StackBuffer();
    for (Map.Entry<String, List<Integer>> entry : bitsIn.entrySet()) {
        String authz = entry.getKey();
        MiruAuthzExpression miruAuthzExpression = new MiruAuthzExpression(ImmutableList.of(authz));

        RoaringBitmap bitsOut = miruAuthzIndex.getCompositeAuthz(miruAuthzExpression, stackBuffer);
        List<Integer> actual = Lists.newArrayList();
        IntIterator iter = bitsOut.getIntIterator();
        while (iter.hasNext()) {
            actual.add(iter.next());
        }

        assertEquals(actual, entry.getValue());
    }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public void multiTxIndex(String name,
    int fieldId,
    MiruTermId[] termIds,
    int considerIfLastIdGreaterThanN,
    StackBuffer stackBuffer,
    MultiIndexTx<RoaringBitmap> indexTx) throws Exception {
    NavigableMap<MiruTermId, RoaringBitmap> terms = indexes[fieldId];
    for (int i = 0; i < termIds.length; i++) {
        MiruTermId termId = termIds[i];
        if (termId != null) {
            RoaringBitmap bitmap = terms.get(termId);
            if (bitmap != null) {
                IntIterator reverse = bitmap.getReverseIntIterator();
                int lastId = reverse.hasNext() ? reverse.next() : -1;
                indexTx.tx(i, lastId, bitmap, null, -1, stackBuffer);
            }
        }
    }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public MutableRoaringBitmap applyAnd(MutableRoaringBitmap answer) {

  MutableRoaringBitmap result = new MutableRoaringBitmap();
  if (evaluator.isAlwaysFalse()) {
    return result;
  }
  IntIterator intIterator = answer.getIntIterator();
  int docId = -1, length;
  while (intIterator.hasNext() && docId < endDocId) {
    docId = intIterator.next();
    if (docId >= startDocId) {
      valueIterator.skipTo(docId);
      _numEntriesScanned++;
      length = valueIterator.nextIntVal(intArray);
      if (evaluator.applyMV(intArray, length)) {
        result.add(docId);
      }
    }
  }
  return result;
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public MutableRoaringBitmap applyAnd(MutableRoaringBitmap answer) {
  MutableRoaringBitmap result = new MutableRoaringBitmap();
  if (_evaluator.isAlwaysFalse()) {
    return result;
  }
  IntIterator intIterator = answer.getIntIterator();
  int docId = -1;
  while (intIterator.hasNext() && docId < _endDocId) {
    docId = intIterator.next();
    if (docId >= _startDocId) {
      _valueIterator.skipTo(docId);
      _numEntriesScanned++;
      if (_valueMatcher.doesCurrentEntryMatch(_valueIterator)) {
        result.add(docId);
      }
    }
  }
  return result;
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
/**
 * A string describing the bitmap.
 *
 * @return the string
 */
@Override
public String toString() {
  final StringBuilder answer = new StringBuilder();
  final IntIterator i = this.getIntIterator();
  answer.append("{");
  if (i.hasNext()) {
    answer.append(i.next() & 0xFFFFFFFFL);
  }
  while (i.hasNext()) {
    answer.append(",");
    // to avoid using too much memory, we limit the size
    if(answer.length() > 0x80000) {
      answer.append("...");
      break;
    }
    answer.append(i.next() & 0xFFFFFFFFL);
  }
  answer.append("}");
  return answer.toString();
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test
public void testRunOpti() {
  MutableRoaringBitmap mrb = new MutableRoaringBitmap();
  for(int r = 0; r< 100000; r+=3 ) {
    mrb.add(r);
  }
  mrb.add(1000000);
  for(int r = 2000000; r < 3000000; ++r) {
    mrb.add(r);
  }
  MutableRoaringBitmap m2 = mrb.clone();
  m2.runOptimize();
  IntIterator x = m2.getReverseIntIterator();
  int count = 0;
  while(x.hasNext()) {
    x.next();
    count++;
  }
  Assert.assertTrue(m2.getCardinality() == count);
  Assert.assertTrue(mrb.getCardinality() == count);
  Assert.assertTrue(m2.serializedSizeInBytes() < mrb.serializedSizeInBytes());
  Assert.assertEquals(m2, mrb);
  Assert.assertEquals(toMapped(m2), mrb);
  Assert.assertEquals(toMapped(m2), toMapped(mrb));
  Assert.assertEquals(m2, toMapped(mrb));
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test
public void testToAndFromByteBuffer()
{
  BitmapFactory bf = new ConciseBitmapFactory();
  RTree tree = new RTree(2, new LinearGutmanSplitStrategy(0, 50, bf), bf);

  tree.insert(new float[]{0, 0}, 1);
  tree.insert(new float[]{1, 1}, 2);
  tree.insert(new float[]{2, 2}, 3);
  tree.insert(new float[]{3, 3}, 4);
  tree.insert(new float[]{4, 4}, 5);

  ImmutableRTree firstTree = ImmutableRTree.newImmutableFromMutable(tree);
  ByteBuffer buffer = ByteBuffer.wrap(firstTree.toBytes());
  ImmutableRTree secondTree = new ImmutableRTree(buffer, bf);
  Iterable<ImmutableBitmap> points = secondTree.search(new RadiusBound(new float[]{0, 0}, 10));
  ImmutableBitmap finalSet = bf.union(points);
  Assert.assertTrue(finalSet.size() >= 5);
  Set<Integer> expected = Sets.newHashSet(1, 2, 3, 4, 5);
  IntIterator iter = finalSet.iterator();
  while (iter.hasNext()) {
    Assert.assertTrue(expected.contains(iter.next()));
  }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test
public void testToAndFromByteBufferRoaring()
{
  BitmapFactory bf = new RoaringBitmapFactory();
  RTree tree = new RTree(2, new LinearGutmanSplitStrategy(0, 50, bf), bf);

  tree.insert(new float[]{0, 0}, 1);
  tree.insert(new float[]{1, 1}, 2);
  tree.insert(new float[]{2, 2}, 3);
  tree.insert(new float[]{3, 3}, 4);
  tree.insert(new float[]{4, 4}, 5);

  ImmutableRTree firstTree = ImmutableRTree.newImmutableFromMutable(tree);
  ByteBuffer buffer = ByteBuffer.wrap(firstTree.toBytes());
  ImmutableRTree secondTree = new ImmutableRTree(buffer, bf);
  Iterable<ImmutableBitmap> points = secondTree.search(new RadiusBound(new float[]{0, 0}, 10));
  ImmutableBitmap finalSet = bf.union(points);

  Assert.assertTrue(finalSet.size() >= 5);

  Set<Integer> expected = Sets.newHashSet(1, 2, 3, 4, 5);
  IntIterator iter = finalSet.iterator();
  while (iter.hasNext()) {
    Assert.assertTrue(expected.contains(iter.next()));
  }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public Instant getEarliest() {
    final IntIterator it = rbm.getIntIterator();
    if (!it.hasNext()) {
        return null;
    }
    return getInstantFromInt(it.next());
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Override
public Instant getLatest() {
    final IntIterator it = rbm.getReverseIntIterator();
    if (!it.hasNext()) {
        return null;
    }
    return getInstantFromInt(it.next());
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
private void validate(File invertedIndex, Set<Integer>[] postingLists) throws IOException {
  try (PinotDataBuffer dataBuffer = PinotDataBuffer.fromFile(invertedIndex, ReadMode.mmap,
      FileChannel.MapMode.READ_ONLY, "BitmapInvertedIndexCreatorTest")) {
    BitmapInvertedIndexReader reader = new BitmapInvertedIndexReader(dataBuffer, CARDINALITY);
    for (int dictId = 0; dictId < CARDINALITY; dictId++) {
      ImmutableRoaringBitmap bitmap = reader.getDocIds(dictId);
      Set<Integer> expected = postingLists[dictId];
      Assert.assertEquals(bitmap.getCardinality(), expected.size());
      IntIterator intIterator = bitmap.getIntIterator();
      while (intIterator.hasNext()) {
        Assert.assertTrue(expected.contains(intIterator.next()));
      }
    }
  }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test
public void testSearchWithSplit3()
{
  BitmapFactory bf = new ConciseBitmapFactory();
  RTree tree = new RTree(2, new LinearGutmanSplitStrategy(0, 50, bf), bf);
  tree.insert(new float[]{0.0f, 0.0f}, 0);
  tree.insert(new float[]{1.0f, 3.0f}, 1);
  tree.insert(new float[]{4.0f, 2.0f}, 2);
  tree.insert(new float[]{7.0f, 3.0f}, 3);
  tree.insert(new float[]{8.0f, 6.0f}, 4);

  Random rand = new Random();
  for (int i = 5; i < 5000; i++) {
    tree.insert(
        new float[]{(float) (rand.nextFloat() * 10 + 10.0), (float) (rand.nextFloat() * 10 + 10.0)},
        i
    );
  }

  ImmutableRTree searchTree = ImmutableRTree.newImmutableFromMutable(tree);
  Iterable<ImmutableBitmap> points = searchTree.search(
      new RadiusBound(new float[]{0.0f, 0.0f}, 5)
  );
  ImmutableBitmap finalSet = bf.union(points);
  Assert.assertTrue(finalSet.size() >= 3);

  Set<Integer> expected = Sets.newHashSet(0, 1, 2);
  IntIterator iter = finalSet.iterator();
  while (iter.hasNext()) {
    Assert.assertTrue(expected.contains(iter.next()));
  }
}
 

import org.roaringbitmap.IntIterator; //导入方法依赖的package包/类
@Test
public void testSearchWithSplit3Roaring()
{
  BitmapFactory bf = new RoaringBitmapFactory();
  RTree tree = new RTree(2, new LinearGutmanSplitStrategy(0, 50, bf), bf);
  tree.insert(new float[]{0.0f, 0.0f}, 0);
  tree.insert(new float[]{1.0f, 3.0f}, 1);
  tree.insert(new float[]{4.0f, 2.0f}, 2);
  tree.insert(new float[]{7.0f, 3.0f}, 3);
  tree.insert(new float[]{8.0f, 6.0f}, 4);

  Random rand = new Random();
  for (int i = 5; i < 5000; i++) {
    tree.insert(
        new float[]{(float) (rand.nextFloat() * 10 + 10.0), (float) (rand.nextFloat() * 10 + 10.0)},
        i
    );
  }

  ImmutableRTree searchTree = ImmutableRTree.newImmutableFromMutable(tree);
  Iterable<ImmutableBitmap> points = searchTree.search(
      new RadiusBound(new float[]{0.0f, 0.0f}, 5)
  );
  ImmutableBitmap finalSet = bf.union(points);
  Assert.assertTrue(finalSet.size() >= 3);

  Set<Integer> expected = Sets.newHashSet(0, 1, 2);
  IntIterator iter = finalSet.iterator();
  while (iter.hasNext()) {
    Assert.assertTrue(expected.contains(iter.next()));
  }
}