import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
private static ImmutableRoaringBitmap or(List<ImmutableRoaringBitmap> bitMaps) {
  if (bitMaps.size() == 1) {
    return bitMaps.get(0);
  }
  MutableRoaringBitmap answer = ImmutableRoaringBitmap.or(bitMaps.get(0), bitMaps.get(1));
  long start = System.currentTimeMillis();
  for (int i = 2; i < bitMaps.size(); i++) {
    answer.or(bitMaps.get(i));
  }

  long end = System.currentTimeMillis();

  bitMaps.get(0).getCardinality();
  System.out.println("OR operation Took " + (end - start));
  System.out.println("\toutput cardinality:" + answer.getCardinality());
  System.out.println("\toutout sizes:" + answer.getSizeInBytes());
  return answer;

}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
private static ImmutableRoaringBitmap and(List<ImmutableRoaringBitmap> bitMaps) {
  if (bitMaps.size() == 1) {
    return bitMaps.get(0);
  }
  MutableRoaringBitmap answer = ImmutableRoaringBitmap.and(bitMaps.get(0), bitMaps.get(1));
  long start = System.currentTimeMillis();
  for (int i = 2; i < bitMaps.size(); i++) {
    answer.and(bitMaps.get(i));
  }

  long end = System.currentTimeMillis();
  int[] cardinality = new int[bitMaps.size()];
  int[] sizes = new int[bitMaps.size()];
  for (int i = 0; i < bitMaps.size(); i++) {
    ImmutableRoaringBitmap immutableRoaringBitmap = bitMaps.get(i);
    cardinality[i] = immutableRoaringBitmap.getCardinality();
    sizes[i] = immutableRoaringBitmap.getSizeInBytes();
  }
  bitMaps.get(0).getCardinality();
  System.out.println("AND operation Took " + (end - start));
  System.out.println("\toutput cardinality:" + answer.getCardinality());
  System.out.println("\toutout sizes:" + answer.getSizeInBytes());
  return answer;

}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
public static ImmutableRoaringBitmap getOrBitmap(InvertedIndexReader invertedIndex, List<Integer> idsToOr) {
  if (idsToOr.size() == 0) {
    return new MutableRoaringBitmap();
  }

  if (idsToOr.size() == 1) {
    return invertedIndex.getImmutable(idsToOr.get(0));
  }

  MutableRoaringBitmap b = new MutableRoaringBitmap();
  for (int i = 0; i < idsToOr.size(); i++) {
    b.or(invertedIndex.getImmutable(idsToOr.get(i)));
  }

  return b;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public ImmutableRoaringBitmap buildIndexMask(int largestIndex,
    MiruInvertedIndex<MutableRoaringBitmap, ImmutableRoaringBitmap> removalIndex,
    BitmapAndLastId<MutableRoaringBitmap> container,
    StackBuffer stackBuffer) throws Exception {

    MutableRoaringBitmap mask = new MutableRoaringBitmap();
    if (largestIndex < 0) {
        return mask;
    }

    mask.flip(0, largestIndex + 1);
    if (removalIndex != null) {
        if (container == null) {
            container = new BitmapAndLastId<>();
        }
        removalIndex.getIndex(container, stackBuffer);
        if (container.isSet()) {
            mask.andNot(container.getBitmap());
        }
    }
    return mask;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的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.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
static ImmutableRoaringBitmap[] getRoaring() {
    ImmutableRoaringBitmap[] answer = new ImmutableRoaringBitmap[roaringoffsets
            .size()];
    int i_rb = 0;
    for (int k = 0; k < roaringoffsets.size() - 1; k++) {
        roaringmbb.position((int) roaringoffsets.get(k).longValue());
        final ByteBuffer bb = roaringmbb.slice();
        bb.limit((int) (roaringoffsets.get(k + 1) - roaringoffsets.get(k)));
        ImmutableRoaringBitmap irb = new ImmutableRoaringBitmap(bb);
        answer[i_rb] = irb;
        i_rb++;
    }
    answer = Arrays.copyOfRange(answer, 0, i_rb);

    return answer;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Test
public void intersectionTest() {
    System.out
            .println("Testing that intersections give the same results...");

    ArrayList<ImmutableConciseSet> x = getConcise();
    ImmutableRoaringBitmap[] y = getRoaring();

    for (int k = 1; k < y.length; k += 50) {
        ImmutableRoaringBitmap[] yk = Arrays.copyOf(y, k);
        List<ImmutableConciseSet> xk = x.subList(0, k);
        ImmutableConciseSet ax = ImmutableConciseSet.intersection(xk
                .iterator());
        ImmutableRoaringBitmap ay = BufferFastAggregation.and(yk);
        Assert.assertArrayEquals(ay.toArray(), toArray(ax));
    }
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
public BitmapDocIdSet(BlockMetadata blockMetadata, ImmutableRoaringBitmap... bitmaps) {
  this.blockMetadata = blockMetadata;
  raw = bitmaps;
  IntIterator[] iterators = new IntIterator[bitmaps.length];
  for (int i = 0; i < bitmaps.length; i++) {
    iterators[i] = bitmaps[i].getIntIterator();
  }
  bitmapBasedBlockIdSetIterator = new BitmapBasedBlockIdSetIterator(iterators);
  bitmapBasedBlockIdSetIterator.setStartDocId(blockMetadata.getStartDocId());
  bitmapBasedBlockIdSetIterator.setEndDocId(blockMetadata.getEndDocId());
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public BaseFilterBlock nextFilterBlock(BlockId BlockId) {
  Predicate predicate = getPredicate();
  InvertedIndexReader invertedIndex = dataSource.getInvertedIndex();
  Block dataSourceBlock = dataSource.nextBlock();
  Dictionary dictionary = dataSource.getDictionary();
  PredicateEvaluator evaluator = PredicateEvaluatorProvider.getPredicateFunctionFor(predicate, dictionary);
  int[] dictionaryIds = evaluator.getDictionaryIds();
  ImmutableRoaringBitmap[] bitmaps = new ImmutableRoaringBitmap[dictionaryIds.length];
  for (int i = 0; i < dictionaryIds.length; i++) {
    bitmaps[i] = invertedIndex.getImmutable(dictionaryIds[i]);
  }
  bitmapBlock = new BitmapBlock(dataSourceBlock.getMetadata(), bitmaps);
  return bitmapBlock;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
private ImmutableRoaringBitmap buildRoaringBitmapForIndex(final int index) {
  final int currentOffset = getOffset(index);
  final int nextOffset = getOffset(index + 1);
  final int bufferLength = nextOffset - currentOffset;

  // Slice the buffer appropriately for Roaring Bitmap
  buffer.position(currentOffset);
  final ByteBuffer bb = buffer.slice();
  bb.limit(bufferLength);

  return new ImmutableRoaringBitmap(bb);
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public ImmutableRoaringBitmap getImmutable(int idx) {
  if (idx >= cardinality) {
    return new MutableRoaringBitmap();
  }
  MutableRoaringBitmap rr = new MutableRoaringBitmap();
  int min = indexReader.getInt(idx, 0);
  int max = indexReader.getInt(idx, 1);
  for (int i = min; i <= max; i++) {
    rr.add(i);
  }
  return rr;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public void readFields(ByteBuffer in) throws IOException {
    int size = peekLength(in);
    // make a copy of the content to be safe
    byte[] dst = new byte[size];
    in.get(dst);

    // ImmutableRoaringBitmap only maps the buffer, thus faster than constructing a MutableRoaringBitmap.
    // we'll convert to MutableRoaringBitmap later when mutate is needed
    bitmap = new ImmutableRoaringBitmap(ByteBuffer.wrap(dst));
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public MutableRoaringBitmap set(ImmutableRoaringBitmap bitmap, int... indexes) {
    MutableRoaringBitmap container = copy(bitmap);
    for (int index : indexes) {
        container.add(index);
    }
    return container;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public MutableRoaringBitmap remove(ImmutableRoaringBitmap bitmap, int... indexes) {
    MutableRoaringBitmap container = copy(bitmap);
    for (int index : indexes) {
        container.remove(index);
    }
    return container;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public MutableRoaringBitmap orTx(List<MiruTxIndex<ImmutableRoaringBitmap>> indexes, StackBuffer stackBuffer) throws Exception {
    if (indexes.isEmpty()) {
        return new MutableRoaringBitmap();
    }

    MutableRoaringBitmap container = indexes.get(0).txIndex((bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            MutableRoaringBitmap mutable = new MutableRoaringBitmap();
            mutable.or(bitmap);
            return mutable;
        } else if (filer != null) {
            return bitmapFromFiler(filer, offset, stackBuffer1);
        } else {
            return new MutableRoaringBitmap();
        }
    }, stackBuffer);

    for (MiruTxIndex<ImmutableRoaringBitmap> index : indexes.subList(1, indexes.size())) {
        index.txIndex((bitmap, filer, offset, stackBuffer1) -> {
            if (bitmap != null) {
                container.or(bitmap);
            } else if (filer != null) {
                container.or(bitmapFromFiler(filer, offset, stackBuffer1));
            }
            return null;
        }, stackBuffer);
    }

    return container;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public MutableRoaringBitmap orMultiTx(MiruMultiTxIndex<ImmutableRoaringBitmap> multiTermTxIndex, StackBuffer stackBuffer) throws Exception {
    MutableRoaringBitmap container = new MutableRoaringBitmap();
    multiTermTxIndex.txIndex((index, lastId, bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            container.or(bitmap);
        } else if (filer != null) {
            container.or(bitmapFromFiler(filer, offset, stackBuffer1));
        }
    }, stackBuffer);
    return container;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public void inPlaceAndNot(MutableRoaringBitmap original,
    MiruInvertedIndex<MutableRoaringBitmap, ImmutableRoaringBitmap> not,
    StackBuffer stackBuffer) throws Exception {

    not.txIndex((bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            original.andNot(bitmap);
        } else if (filer != null) {
            original.andNot(bitmapFromFiler(filer, offset, stackBuffer1));
        }
        return null;
    }, stackBuffer);
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public MutableRoaringBitmap andNotMultiTx(MutableRoaringBitmap original,
    MiruMultiTxIndex<ImmutableRoaringBitmap> multiTermTxIndex,
    long[] counts,
    Optional<MutableRoaringBitmap> counter,
    StackBuffer stackBuffer) throws Exception {

    MutableRoaringBitmap container = copy(original);
    inPlaceAndNotMultiTx(container, multiTermTxIndex, counts, counter, stackBuffer);
    return container;
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public void inPlaceAndNotMultiTx(MutableRoaringBitmap original,
    MiruMultiTxIndex<ImmutableRoaringBitmap> multiTermTxIndex,
    long[] counts,
    Optional<MutableRoaringBitmap> counter,
    StackBuffer stackBuffer) throws Exception {
    long[] originalCardinality = (counts == null) ? null : new long[] { cardinality(counter.or(original)) };
    multiTermTxIndex.txIndex((index, lastId, bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            original.andNot(bitmap);
            if (counter.isPresent()) {
                counter.get().andNot(bitmap);
            }
        } else if (filer != null) {
            MutableRoaringBitmap bitmapFromFiler = bitmapFromFiler(filer, offset, stackBuffer1);
            original.andNot(bitmapFromFiler);
            if (counter.isPresent()) {
                counter.get().andNot(bitmapFromFiler);
            }
        }
        if (counts != null) {
            long nextCardinality = cardinality(counter.or(original));
            counts[index] = originalCardinality[0] - nextCardinality;
            originalCardinality[0] = nextCardinality;
        }
    }, stackBuffer);
}
 

import org.roaringbitmap.buffer.ImmutableRoaringBitmap; //导入依赖的package包/类
@Override
public void multiTx(MiruMultiTxIndex<ImmutableRoaringBitmap> multiTermTxIndex,
    IndexAlignedBitmapStream<MutableRoaringBitmap> stream,
    StackBuffer stackBuffer) throws Exception {

    multiTermTxIndex.txIndex((index, lastId, bitmap, filer, offset, stackBuffer1) -> {
        if (bitmap != null) {
            stream.stream(index, lastId, copy(bitmap));
        } else if (filer != null) {
            stream.stream(index, lastId, bitmapFromFiler(filer, offset, stackBuffer1));
        }
    }, stackBuffer);
}