/** * 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(short[]) */ public ShortPointer(ShortBuffer buffer) { super(buffer); if (buffer != null && !buffer.isDirect() && buffer.hasArray()) { short[] array = buffer.array(); allocateArray(array.length - buffer.arrayOffset()); put(array, buffer.arrayOffset(), array.length - buffer.arrayOffset()); position(buffer.position()); limit(buffer.limit()); } } /**
RawArrayContainerShortIterator(MappeableArrayContainer p) { parent = p; if (!p.isArrayBacked()) { throw new RuntimeException("internal bug"); } content = p.content.array(); pos = 0; }
RawReverseArrayContainerShortIterator(MappeableArrayContainer p) { parent = p; if (!p.isArrayBacked()) { throw new RuntimeException("internal bug"); } content = p.content.array(); pos = parent.cardinality - 1; }
protected static void arraycopy(ShortBuffer src, int srcPos, ShortBuffer dest, int destPos, int length) { if (BufferUtil.isBackedBySimpleArray(src) && BufferUtil.isBackedBySimpleArray(dest)) { System.arraycopy(src.array(), srcPos, dest.array(), destPos, length); } else { if (srcPos < destPos) { for (int k = length - 1; k >= 0; --k) { dest.put(destPos + k, src.get(k + srcPos)); } } else { for (int k = 0; k < length; ++k) { dest.put(destPos + k, src.get(k + srcPos)); } } } }
protected void loadData(final MappeableBitmapContainer bitmapContainer) { this.cardinality = bitmapContainer.cardinality; if (!BufferUtil.isBackedBySimpleArray(this.content)) { throw new RuntimeException("Should not happen. Internal bug."); } bitmapContainer.fillArray(content.array()); }
@Override public MappeableArrayContainer iandNot(MappeableBitmapContainer value2) { if (!BufferUtil.isBackedBySimpleArray(this.content)) { throw new RuntimeException("Should not happen. Internal bug."); } short[] c = this.content.array(); int pos = 0; for (int k = 0; k < cardinality; ++k) { short v = c[k]; c[pos] = v; pos += 1 - value2.bitValue(v); } this.cardinality = pos; return this; }
@Override protected void writeArray(DataOutput out) throws IOException { // little endian if (BufferUtil.isBackedBySimpleArray(content)) { short[] a = content.array(); for (int k = 0; k < this.cardinality; ++k) { out.writeShort(Short.reverseBytes(a[k])); } } else { for (int k = 0; k < this.cardinality; ++k) { out.writeShort(Short.reverseBytes(content.get(k))); } } }
@Override public void trim() { if (valueslength.limit() == 2 * nbrruns) { return; } if (BufferUtil.isBackedBySimpleArray(valueslength)) { this.valueslength = ShortBuffer.wrap(Arrays.copyOf(valueslength.array(), 2 * nbrruns)); } else { final ShortBuffer co = ShortBuffer.allocate(2 * nbrruns); short[] a = co.array(); for (int k = 0; k < 2 * nbrruns; ++k) { a[k] = this.valueslength.get(k); } this.valueslength = co; } }
@Override public MappeableArrayContainer iandNot(final MappeableArrayContainer value2) { if (!BufferUtil.isBackedBySimpleArray(this.content)) { throw new RuntimeException("Should not happen. Internal bug."); } if (BufferUtil.isBackedBySimpleArray(value2.content)) { this.cardinality = org.roaringbitmap.Util.unsignedDifference(this.content.array(), this.getCardinality(), value2.content.array(), value2.getCardinality(), this.content.array()); } else { this.cardinality = BufferUtil.unsignedDifference(this.content, this.getCardinality(), value2.content, value2.getCardinality(), this.content.array()); } return this; }
@Override public void fillLeastSignificant16bits(int[] x, int i, int mask) { if (BufferUtil.isBackedBySimpleArray(this.content)) { short[] c = this.content.array(); for (int k = 0; k < this.cardinality; ++k) { x[k + i] = toIntUnsigned(c[k]) | mask; } } else { for (int k = 0; k < this.cardinality; ++k) { x[k + i] = toIntUnsigned(this.content.get(k)) | mask; } } }
@Override public void forEach(short msb, IntConsumer ic) { int high = ((int) msb) << 16; if (BufferUtil.isBackedBySimpleArray(content)) { short[] c = content.array(); for (int k = 0; k < cardinality; ++k) { ic.accept((c[k] & 0xFFFF) | high); } } else { for (int k = 0; k < cardinality; ++k) { ic.accept((content.get(k) & 0xFFFF) | high); } } }
@Override public MappeableArrayContainer iand(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; if (!BufferUtil.isBackedBySimpleArray(value1.content)) { throw new RuntimeException("Should not happen. Internal bug."); } value1.cardinality = BufferUtil.unsignedIntersect2by2(value1.content, value1.getCardinality(), value2.content, value2.getCardinality(), value1.content.array()); return this; }
@Override public int andCardinality(MappeableArrayContainer value2) { if (BufferUtil.isBackedBySimpleArray(content) && BufferUtil.isBackedBySimpleArray(value2.content)) { return Util.unsignedLocalIntersect2by2Cardinality(content.array(), cardinality, value2.content.array(), value2.getCardinality()); } return BufferUtil.unsignedLocalIntersect2by2Cardinality(content, cardinality, value2.content, value2.getCardinality()); }
@Override public MappeableArrayContainer andNot(final MappeableArrayContainer value2) { final MappeableArrayContainer value1 = this; final int desiredCapacity = value1.getCardinality(); final MappeableArrayContainer answer = new MappeableArrayContainer(desiredCapacity); if (BufferUtil.isBackedBySimpleArray(value1.content) && BufferUtil.isBackedBySimpleArray(value2.content)) { answer.cardinality = org.roaringbitmap.Util.unsignedDifference(value1.content.array(), value1.getCardinality(), value2.content.array(), value2.getCardinality(), answer.content.array()); } else { answer.cardinality = BufferUtil.unsignedDifference(value1.content, value1.getCardinality(), value2.content, value2.getCardinality(), answer.content.array()); } return answer; }
@Override public void writeExternal(ObjectOutput out) throws IOException { out.write(this.cardinality & 0xFF); out.write((this.cardinality >>> 8) & 0xFF); if (BufferUtil.isBackedBySimpleArray(content)) { short[] a = content.array(); for (int k = 0; k < this.cardinality; ++k) { out.writeShort(Short.reverseBytes(a[k])); } } else { for (int k = 0; k < this.cardinality; ++k) { out.writeShort(Short.reverseBytes(content.get(k))); } } }
@Override public MappeableArrayContainer and(final MappeableArrayContainer value2) { MappeableArrayContainer value1 = this; final int desiredCapacity = Math.min(value1.getCardinality(), value2.getCardinality()); MappeableArrayContainer answer = new MappeableArrayContainer(desiredCapacity); if (BufferUtil.isBackedBySimpleArray(this.content) && BufferUtil.isBackedBySimpleArray(value2.content)) { answer.cardinality = org.roaringbitmap.Util.unsignedIntersect2by2(value1.content.array(), value1.getCardinality(), value2.content.array(), value2.getCardinality(), answer.content.array()); } else { answer.cardinality = BufferUtil.unsignedIntersect2by2(value1.content, value1.getCardinality(), value2.content, value2.getCardinality(), answer.content.array()); } return answer; }
void wrap(MappeableRunContainer p) { parent = p; if (!parent.isArrayBacked()) { throw new RuntimeException("internal error"); } vl = parent.valueslength.array(); pos = 0; le = 0; if (pos < parent.nbrruns) { maxlength = toIntUnsigned(getLength(pos)); base = toIntUnsigned(getValue(pos)); } }
void wrap(MappeableRunContainer p) { parent = p; if (!parent.isArrayBacked()) { throw new RuntimeException("internal error"); } vl = parent.valueslength.array(); pos = parent.nbrruns - 1; le = 0; if (pos >= 0) { maxlength = toIntUnsigned(getLength(pos)); base = toIntUnsigned(getValue(pos)); } }
@Override public int getCardinality() { int sum = nbrruns; // lengths are stored -1 if (isArrayBacked()) { short[] vl = valueslength.array(); for (int k = 0; k < nbrruns; ++k) { sum = sum + toIntUnsigned(vl[2 * k + 1])/* + 1 */; } } else { for (int k = 0; k < nbrruns; ++k) { sum = sum + toIntUnsigned(getLength(k))/* + 1 */; } } return sum; }