protected MappeableContainer lazyor(MappeableBitmapContainer x) { MappeableBitmapContainer answer = new MappeableBitmapContainer(); answer.cardinality = -1;// invalid if (!BufferUtil.isBackedBySimpleArray(answer.bitmap)) { throw new RuntimeException("Should not happen. Internal bug."); } long[] b = answer.bitmap.array(); for (int k = 0; k < b.length; k++) { b[k] = this.bitmap.get(k) | x.bitmap.get(k); } return answer; }
/** * For direct buffers, calls {@link Pointer#Pointer(Buffer)}, while for buffers * backed with an array, allocates enough memory for the array and copies it. * * @param buffer the Buffer to reference or copy * @see #put(long[]) */ public LongPointer(LongBuffer buffer) { super(buffer); if (buffer != null && !buffer.isDirect() && buffer.hasArray()) { long[] array = buffer.array(); allocateArray(array.length - buffer.arrayOffset()); put(array, buffer.arrayOffset(), array.length - buffer.arrayOffset()); position(buffer.position()); limit(buffer.limit()); } } /**
@Override protected void writeArray(DataOutput out) throws IOException { // little endian int len = this.bitmap.limit(); if (BufferUtil.isBackedBySimpleArray(bitmap)) { long[] b = bitmap.array(); for (int k = 0; k < len; ++k) { out.writeLong(Long.reverseBytes(b[k])); } } else { for (int k = 0; k < len; ++k) { final long w = bitmap.get(k); out.writeLong(Long.reverseBytes(w)); } } }
/** * Fill a buffer with a repeated value. * * @param buffer the buffer to fill * @param value the value to fill * @param count the number of longs to fill * @return the buffer instance */ public static LongBuffer fill(LongBuffer buffer, long value, int count) { if (count > buffer.remaining()) { throw msg.bufferUnderflow(); } if (buffer.hasArray()) { final int offs = buffer.arrayOffset(); Arrays.fill(buffer.array(), offs + buffer.position(), offs + buffer.limit(), value); skip(buffer, count); } else { for (int i = count; i > 0; i--) { buffer.put(value); } } return buffer; }
protected MappeableContainer ilazyor(MappeableArrayContainer value2) { this.cardinality = -1;// invalid if (!BufferUtil.isBackedBySimpleArray(bitmap)) { throw new RuntimeException("Should not happen. Internal bug."); } long[] b = this.bitmap.array(); int c = value2.cardinality; for (int k = 0; k < c; ++k) { short v2 = value2.content.get(k); final int i = toIntUnsigned(v2) >>> 6; b[i] |= (1L << v2); } return this; }
protected MappeableContainer ilazyor(MappeableBitmapContainer x) { if (BufferUtil.isBackedBySimpleArray(x.bitmap)) { long[] b = this.bitmap.array(); long[] b2 = x.bitmap.array(); for (int k = 0; k < b.length; k++) { b[k] |= b2[k]; } } else { final int m = this.bitmap.limit(); for (int k = 0; k < m; k++) { this.bitmap.put(k, this.bitmap.get(k) | x.bitmap.get(k)); } } this.cardinality = -1;// invalid return this; }
@Override public int andCardinality(final MappeableBitmapContainer value2) { int newCardinality = 0; if (BufferUtil.isBackedBySimpleArray(this.bitmap) && BufferUtil.isBackedBySimpleArray(value2.bitmap)) { long[] b1 = this.bitmap.array(); long[] b2 = value2.bitmap.array(); for (int k = 0; k < b1.length; ++k) { newCardinality += Long.bitCount(b1[k] & b2[k]); } } else { final int size = this.bitmap.limit(); for (int k = 0; k < size; ++k) { newCardinality += Long.bitCount(this.bitmap.get(k) & value2.bitmap.get(k)); } } return newCardinality; }
/** * Recomputes the cardinality of the bitmap. */ protected void computeCardinality() { this.cardinality = 0; if (BufferUtil.isBackedBySimpleArray(bitmap)) { long[] b = this.bitmap.array(); for (int k = 0; k < b.length; k++) { this.cardinality += Long.bitCount(b[k]); } } else { int m = this.bitmap.limit(); for (int k = 0; k < m; k++) { this.cardinality += Long.bitCount(this.bitmap.get(k)); } } }
/** * Create a bitmap container with a run of ones from firstOfRun to lastOfRun, inclusive caller * must ensure that the range isn't so small that an ArrayContainer should have been created * instead * * @param firstOfRun first index * @param lastOfRun last index (range is exclusive) */ public MappeableBitmapContainer(final int firstOfRun, final int lastOfRun) { // TODO: this can be optimized for performance this.cardinality = lastOfRun - firstOfRun; this.bitmap = LongBuffer.allocate(MAX_CAPACITY / 64); Util.setBitmapRange(bitmap.array(), firstOfRun, lastOfRun); }
protected MappeableContainer lazyor(MappeableArrayContainer value2) { MappeableBitmapContainer answer = clone(); answer.cardinality = -1;// invalid if (!BufferUtil.isBackedBySimpleArray(answer.bitmap)) { throw new RuntimeException("Should not happen. Internal bug."); } long[] b = answer.bitmap.array(); int c = value2.cardinality; for (int k = 0; k < c; ++k) { short v2 = value2.content.get(k); final int i = toIntUnsigned(v2) >>> 6; b[i] |= 1L << v2; } return answer; }
@Override public int last() { assertNonEmpty(cardinality == 0); long lastNonZeroWord; int i = bitmap.limit() - 1; if(BufferUtil.isBackedBySimpleArray(bitmap)) { long[] array = this.bitmap.array(); while(i > 0 && array[i] == 0) { --i; } lastNonZeroWord = array[i]; } else { while(i > 0 && bitmap.get(i) == 0) { --i; } lastNonZeroWord = bitmap.get(i); } return (i + 1) * 64 - Long.numberOfLeadingZeros(lastNonZeroWord) - 1; }
@Override public int first() { assertNonEmpty(cardinality == 0); long firstNonZeroWord; int i = 0; if(BufferUtil.isBackedBySimpleArray(bitmap)) { long[] array = bitmap.array(); while(array[i] == 0) { ++i; } firstNonZeroWord = array[i]; } else { i = bitmap.position(); while(bitmap.get(i) == 0) { ++i; } firstNonZeroWord = bitmap.get(i); } return i * 64 + numberOfTrailingZeros(firstNonZeroWord); }
protected static void fillArrayXOR(short[] container, LongBuffer bitmap1, LongBuffer bitmap2) { int pos = 0; if (bitmap1.limit() != bitmap2.limit()) { throw new IllegalArgumentException("not supported"); } if (BufferUtil.isBackedBySimpleArray(bitmap1) && BufferUtil.isBackedBySimpleArray(bitmap2)) { org.roaringbitmap.Util.fillArrayXOR(container, bitmap1.array(), bitmap2.array()); } else { int len = bitmap1.limit(); for (int k = 0; k < len; ++k) { long bitset = bitmap1.get(k) ^ bitmap2.get(k); while (bitset != 0) { container[pos++] = (short) (k * 64 + numberOfTrailingZeros(bitset)); bitset &= (bitset - 1); } } } }
@Override public PeekableShortIterator getShortIterator() { if (this.isArrayBacked()) { return BitmapContainer.getShortIterator(bitmap.array()); } return new MappeableBitmapContainerShortIterator(this); }
@Override public ShortIterator getReverseShortIterator() { if (this.isArrayBacked()) { return BitmapContainer.getReverseShortIterator(bitmap.array()); } return new ReverseMappeableBitmapContainerShortIterator(this); }
/** * flip bits at start, start+1,..., end-1 and report the cardinality change * * @param bitmap array of words to be modified * @param start first index to be modified (inclusive) * @param end last index to be modified (exclusive) * @return cardinality change */ @Deprecated public static int flipBitmapRangeAndCardinalityChange(LongBuffer bitmap, int start, int end) { if (BufferUtil.isBackedBySimpleArray(bitmap)) { return Util.flipBitmapRangeAndCardinalityChange(bitmap.array(), start, end); } int cardbefore = cardinalityInBitmapWordRange(bitmap, start, end); flipBitmapRange(bitmap, start, end); int cardafter = cardinalityInBitmapWordRange(bitmap, start, end); return cardafter - cardbefore; }
/** * reset bits at start, start+1,..., end-1 and report the cardinality change * * @param bitmap array of words to be modified * @param start first index to be modified (inclusive) * @param end last index to be modified (exclusive) * @return cardinality change */ @Deprecated public static int resetBitmapRangeAndCardinalityChange(LongBuffer bitmap, int start, int end) { if (BufferUtil.isBackedBySimpleArray(bitmap)) { return Util.resetBitmapRangeAndCardinalityChange(bitmap.array(), start, end); } int cardbefore = cardinalityInBitmapWordRange(bitmap, start, end); resetBitmapRange(bitmap, start, end); int cardafter = cardinalityInBitmapWordRange(bitmap, start, end); return cardafter - cardbefore; }
/** * set bits at start, start+1,..., end-1 and report the cardinality change * * @param bitmap array of words to be modified * @param start first index to be modified (inclusive) * @param end last index to be modified (exclusive) * @return cardinality change */ @Deprecated public static int setBitmapRangeAndCardinalityChange(LongBuffer bitmap, int start, int end) { if (BufferUtil.isBackedBySimpleArray(bitmap)) { return Util.setBitmapRangeAndCardinalityChange(bitmap.array(), start, end); } int cardbefore = cardinalityInBitmapWordRange(bitmap, start, end); setBitmapRange(bitmap, start, end); int cardafter = cardinalityInBitmapWordRange(bitmap, start, end); return cardafter - cardbefore; }
protected MappeableContainer lazyor(MappeableRunContainer x) { MappeableBitmapContainer bc = clone(); bc.cardinality = -1; long[] b = bc.bitmap.array(); for (int rlepos = 0; rlepos < x.nbrruns; ++rlepos) { int start = toIntUnsigned(x.getValue(rlepos)); int end = start + toIntUnsigned(x.getLength(rlepos)) + 1; Util.setBitmapRange(b, start, end); } return bc; }
@Override public MappeableContainer andNot(final MappeableRunContainer value2) { MappeableBitmapContainer answer = this.clone(); long[] b = answer.bitmap.array(); for (int rlepos = 0; rlepos < value2.nbrruns; ++rlepos) { int start = toIntUnsigned(value2.getValue(rlepos)); int end = toIntUnsigned(value2.getValue(rlepos)) + toIntUnsigned(value2.getLength(rlepos)) + 1; int prevOnesInRange = Util.cardinalityInBitmapRange(b, start, end); Util.resetBitmapRange(b, start, end); answer.updateCardinality(prevOnesInRange, 0); } if (answer.getCardinality() > MappeableArrayContainer.DEFAULT_MAX_SIZE) { return answer; } else { return answer.toArrayContainer(); } }