Java RoaringBitmap类代码示例

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
private Iterator<RoaringBitmap> toRoaringBitmapIterator(final Iterable<Bitmap> bitmaps) {
  return new Iterator<RoaringBitmap>() {
    final Iterator<Bitmap> i = bitmaps.iterator();

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


    @Override
    public void remove() {
      throw new UnsupportedOperationException();
    }


    @Override
    public RoaringBitmap next() {
      return ((RoaringBitmapWrapper) i.next()).bitmap;
    }
  };
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
private void matchOr(TagMatcher t, List<RoaringBitmap> resultantMap) {
  // TODO: Add more validation for this expression here.
  final String[] split = t.tag.value.split("\\|");
  List<RoaringBitmap> orMaps = new ArrayList<>();
  for (int i = 0; i < split.length; i++) {
    if (!split[i].isEmpty()) {
      final String tagValuePair = t.tag.key + "=" + split[i];
      if (metricIndex.containsKey(tagValuePair)) {
        orMaps.add(lookupMetricIndex(tagValuePair));
      }
    }
  }

  if (orMaps.isEmpty()) {
    resultantMap.add(EMPTY_BITMAP); // If no exact match is present, return empty result.
  } else {
    resultantMap.add(FastAggregation.or(orMaps.iterator()));
  }
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
private void matchCaseInsensitiveOr(TagMatcher t, Map<Integer, String> valuesWithMetricIds,
                                    List<RoaringBitmap> resultantMap) {

  RoaringBitmap iLiteralMatches = new RoaringBitmap();
  final String[] split = t.tag.value.split("\\|");

  if (split.length > 0) {
    valuesWithMetricIds.entrySet().stream()
        .filter(entry -> caseInsensitiveTagValueMatch(split, entry.getValue()))
        .forEach(entry -> iLiteralMatches.add(entry.getKey()));
  }

  if (iLiteralMatches.getCardinality() > 0) {
    resultantMap.add(iLiteralMatches);
  } else {
    resultantMap.add(EMPTY_BITMAP);
  }
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
/**
 * Given a metric name, extract all the values associated for the given key.
 */
@VisibleForTesting
public Map<Integer, String> getValuesForMetricKey(String metricName, String key) {
  List<RoaringBitmap> andBitMaps = new ArrayList<>();

  if (metricIndex.containsKey(metricName)) {
    andBitMaps.add(lookupMetricIndex(metricName));
  } else {
    andBitMaps.add(EMPTY_BITMAP);
  }

  if (metricIndex.containsKey(key)) {
    andBitMaps.add(lookupMetricIndex(key));
  } else {
    andBitMaps.add(EMPTY_BITMAP);
  }

  RoaringBitmap resultBitMap = FastAggregation.and(andBitMaps.iterator());
  HashMap<Integer, String> resultMap = new HashMap<>();
  for (int i : resultBitMap.toArray()) {
    resultMap.put(i, extractTagValueForTagKey(metricIdMap.get(i), key));
  }
  return resultMap;
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Override
final protected void writeValue(final Collection<V> collection, final ObjectOutput out)
		throws IOException, ReflectiveOperationException {
	final NullableArray array = getNullableArray(collection.size());
	final RoaringBitmap nullBitmap = new RoaringBitmap();
	int i = 0;
	for (final V value : collection) {
		if (value == null)
			nullBitmap.add(i);
		else
			array.set(i, value);
		i++;
	}
	nullBitmap.writeExternal(out);
	ArrayExternalizer.writeBytes(array.compress(), out);
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Override
final public Collection<Boolean> readObject(final ObjectInput in)
		throws IOException, ReflectiveOperationException {
	if (!in.readBoolean())
		return null;
	final Collection<Boolean> collection = constructor.newInstance();
	final boolean[] array = new boolean[in.readInt()];
	final RoaringBitmap nullBitmap = new RoaringBitmap();
	final RoaringBitmap booleanBitmap = new RoaringBitmap();
	nullBitmap.readExternal(in);
	booleanBitmap.readExternal(in);
	for (int i = 0; i < array.length; i++) {
		if (nullBitmap.contains(i))
			collection.add(null);
		else
			collection.add(booleanBitmap.contains(i));
	}
	return collection;
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Nonnull
private int[] variableIndex(@Nonnull final Matrix x, @Nonnull final int[] bags) {
    final IntReservoirSampler sampler = new IntReservoirSampler(_numVars, _rnd.nextLong());
    if (x.isSparse()) {
        final RoaringBitmap cols = new RoaringBitmap();
        final VectorProcedure proc = new VectorProcedure() {
            public void apply(final int col) {
                cols.add(col);
            }
        };
        for (final int row : bags) {
            x.eachColumnIndexInRow(row, proc);
        }
        cols.forEach(new IntConsumer() {
            public void accept(final int k) {
                sampler.add(k);
            }
        });
    } else {
        for (int i = 0, size = _attributes.length; i < size; i++) {
            sampler.add(i);
        }
    }
    return sampler.getSample();
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Test
public void testCanSerialiseAndDeserialise() throws IOException {
    final ByteArrayBuilder byteArrayBuilder = new ByteArrayBuilder();
    JsonGenerator jsonGenerator = JSON_FACTORY.createGenerator(byteArrayBuilder);
    RoaringBitmap testBitmap = new RoaringBitmap();
    testBitmap.add(2);
    testBitmap.add(3000);
    testBitmap.add(300000);
    for (int i=400000; i<500000; i+=2) {
        testBitmap.add(i);
    }
    SERIALISER.serialize(testBitmap, jsonGenerator, null);
    jsonGenerator.flush();
    byte[] serialisedBitmap = byteArrayBuilder.toByteArray();
    JsonParser parser = JSON_FACTORY.createParser(serialisedBitmap);
    parser.setCodec(new ObjectMapper());
    Object o = DESERIALISER.deserialize(parser, null);
    assertEquals(RoaringBitmap.class, o.getClass());
    assertEquals(testBitmap, o);
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Test
public void testCanSerialiseAndDeserialiseWithRuns() throws IOException {
    final ByteArrayBuilder byteArrayBuilder = new ByteArrayBuilder();
    JsonGenerator jsonGenerator = JSON_FACTORY.createGenerator(byteArrayBuilder);
    RoaringBitmap testBitmap = new RoaringBitmap();
    testBitmap.add(2);
    testBitmap.add(3000);
    testBitmap.add(300000);
    for (int i=400000; i<500000; i+=2) {
        testBitmap.add(i);
    }
    testBitmap.runOptimize();
    SERIALISER.serialize(testBitmap, jsonGenerator, null);
    jsonGenerator.flush();
    byte[] serialisedBitmap = byteArrayBuilder.toByteArray();
    JsonParser parser = JSON_FACTORY.createParser(serialisedBitmap);
    parser.setCodec(new ObjectMapper());
    Object o = DESERIALISER.deserialize(parser, null);
    assertEquals(RoaringBitmap.class, o.getClass());
    assertEquals(testBitmap, o);
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Test
public void testCanSerialiseWithCustomObjectMapper() throws IOException {
    //Bitmap of (2,3000,300000) serialised in 0.5.11 Roaring Bitmap base 64 encoded
    String serialisedComparisonBitmap = "{\"roaringBitmap\":{\"value\":\"OjAAAAIAAAAAAAEABAAAABgAAAAcAAAAAgC4C+CT\"}}";
    RoaringBitmap comparisonBitmap = new RoaringBitmap();
    comparisonBitmap.add(2);
    comparisonBitmap.add(3000);
    comparisonBitmap.add(300000);
    final ObjectMapper mapper = JSONSerialiser.createDefaultMapper();
    final SimpleModule bitmapModule = new SimpleModule(RoaringBitmapConstants.BITMAP_MODULE_NAME, new Version(1, 0, 9, null, null, null));
    bitmapModule.addSerializer(RoaringBitmap.class, new RoaringBitmapJsonSerialiser());
    bitmapModule.addDeserializer(RoaringBitmap.class, new RoaringBitmapJsonDeserialiser());
    mapper.registerModule(bitmapModule);
    RoaringBitmap testBitmap = mapper.readValue(serialisedComparisonBitmap, RoaringBitmap.class);
    assertEquals(comparisonBitmap, testBitmap);
    String serialisedBitmap = mapper.writeValueAsString(testBitmap);
    assertEquals(serialisedBitmap, serialisedComparisonBitmap);
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Override
public RBMBackedTimestampSet deserialise(final byte[] allBytes, final int offset, final int length) throws SerialisationException {
    if (allBytes.length == 0 || length == 0) {
        return null;
    }
    final int bucketInt = (int) CompactRawSerialisationUtils.readLong(allBytes, offset);
    final int numBytesForInt = CompactRawSerialisationUtils.decodeVIntSize(allBytes[offset]);
    final TimeBucket bucket = TimeBucket.values()[bucketInt];
    final RBMBackedTimestampSet rbmBackedTimestampSet = new RBMBackedTimestampSet(bucket);
    final RoaringBitmap rbm = new RoaringBitmap();
    try {
        // Deal with different versions of RoaringBitmap
        final byte[] convertedBytes = RoaringBitmapUtils.upConvertSerialisedForm(allBytes, offset + numBytesForInt, length - numBytesForInt);
        final ByteArrayInputStream baisConvertedBytes = new ByteArrayInputStream(convertedBytes);
        final DataInputStream disConvertedBytes = new DataInputStream(baisConvertedBytes);
        rbm.deserialize(disConvertedBytes);
    } catch (final IOException e) {
        throw new SerialisationException("IOException deserialising RoaringBitmap from byte array", e);
    }
    rbmBackedTimestampSet.setRbm(rbm);
    return rbmBackedTimestampSet;
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
private void generateEdgesInCommunity(RoaringBitmap community) {
    Iterator<Integer> iter = community.iterator();
    while (iter.hasNext()) {
        int nodeA = iter.next();
        Iterator<Integer> iter2 = community.iterator();
        while (iter2.hasNext()) {
            int nodeB = iter2.next();
            if (nodeA < nodeB) {
                double prob = random.nextDouble();
                if (prob < p[community.getCardinality() - 1]) {
                    adjacencyMatrix[nodeA].add(nodeB);
                    adjacencyMatrix[nodeB].add(nodeA);
                }
            }
        }
    }
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@Override
public void add(Object value)
{
    if (value == null)
    {
        if (!hasNullValues)
        {
            hasNullValues = true;
            isNullBitMap = new RoaringBitmap();
        }
        addFloat(0);
        isNullBitMap.add(size - 1);
        return;
    }
    addFloat(((Number) value).floatValue());
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
private boolean addInPlace(RoaringBitmap bitmap, int... indexes) {
    if (indexes.length == 1) {
        bitmap.add(indexes[0]);
    } else if (indexes.length > 1) {
        int rangeStart = 0;
        for (int rangeEnd = 1; rangeEnd < indexes.length; rangeEnd++) {
            if (indexes[rangeEnd - 1] + 1 != indexes[rangeEnd]) {
                if (rangeStart == rangeEnd - 1) {
                    bitmap.add(indexes[rangeStart]);
                } else {
                    bitmap.add(indexes[rangeStart], indexes[rangeEnd - 1] + 1);
                }
                rangeStart = rangeEnd;
            }
        }
        if (rangeStart == indexes.length - 1) {
            bitmap.add(indexes[rangeStart]);
        } else {
            bitmap.add(indexes[rangeStart], indexes[indexes.length - 1] + 1);
        }
    }
    return true;
}
 

import org.roaringbitmap.RoaringBitmap; //导入依赖的package包/类
@DataProvider(name = "singleEntryTimeIndexDataProvider")
public Object[][] singleEntryTimeIndexDataProvider() throws Exception {
    StackBuffer stackBuffer = new StackBuffer();

    final long[] timestamps = new long[] { System.currentTimeMillis() };
    MiruContext<RoaringBitmap, RoaringBitmap, RCVSSipCursor> chunkInMemoryTimeIndex = buildInMemoryTimeIndex(false);
    MiruContext<RoaringBitmap, RoaringBitmap, RCVSSipCursor> labInMemoryTimeIndex = buildInMemoryTimeIndex(true);
    MiruContext<RoaringBitmap, RoaringBitmap, RCVSSipCursor> chunkOnDiskTimeIndex = buildOnDiskTimeIndex(false);
    MiruContext<RoaringBitmap, RoaringBitmap, RCVSSipCursor> labOnDiskTimeIndex = buildOnDiskTimeIndex(true);

    int[] ids = new int[timestamps.length];
    long[] monotonics = new long[timestamps.length];
    Arrays.fill(ids, -1);
    Arrays.fill(monotonics, -1);
    chunkInMemoryTimeIndex.timeIndex.nextId(stackBuffer, timestamps, ids.clone(), monotonics.clone());
    labInMemoryTimeIndex.timeIndex.nextId(stackBuffer, timestamps, ids.clone(), monotonics.clone());
    chunkOnDiskTimeIndex.timeIndex.nextId(stackBuffer, timestamps, ids.clone(), monotonics.clone());
    labOnDiskTimeIndex.timeIndex.nextId(stackBuffer, timestamps, ids.clone(), monotonics.clone());

    return new Object[][] {
        { new MiruBitmapsRoaring(), chunkInMemoryTimeIndex },
        { new MiruBitmapsRoaring(), labInMemoryTimeIndex },
        { new MiruBitmapsRoaring(), chunkOnDiskTimeIndex },
        { new MiruBitmapsRoaring(), labOnDiskTimeIndex }
    };
}