/** Same as {@link #copy(Reader, int, Mutable, int, int, int)} but using a pre-allocated buffer. */ static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, long[] buf) { assert buf.length > 0; int remaining = 0; while (len > 0) { final int read = src.get(srcPos, buf, remaining, Math.min(len, buf.length - remaining)); assert read > 0; srcPos += read; len -= read; remaining += read; final int written = dest.set(destPos, buf, 0, remaining); assert written > 0; destPos += written; if (written < remaining) { System.arraycopy(buf, written, buf, 0, remaining - written); } remaining -= written; } while (remaining > 0) { final int written = dest.set(destPos, buf, 0, remaining); destPos += written; remaining -= written; System.arraycopy(buf, written, buf, 0, remaining); } }
void pack(long[] values, int numValues, int block, float acceptableOverheadRatio) { assert numValues > 0; // compute max delta long minValue = values[0]; long maxValue = values[0]; for (int i = 1; i < numValues; ++i) { minValue = Math.min(minValue, values[i]); maxValue = Math.max(maxValue, values[i]); } // build a new packed reader if (minValue == 0 && maxValue == 0) { this.values[block] = new PackedInts.NullReader(numValues); } else { final int bitsRequired = minValue < 0 ? 64 : PackedInts.bitsRequired(maxValue); final PackedInts.Mutable mutable = PackedInts.getMutable(numValues, bitsRequired, acceptableOverheadRatio); for (int i = 0; i < numValues; ) { i += mutable.set(i, values, i, numValues - i); } this.values[block] = mutable; } }
/** * Bulk set: set at least one and at most <code>len</code> longs starting * at <code>off</code> in <code>arr</code> into this mutable, starting at * <code>index</code>. Returns the actual number of values that have been * set. */ public int set(int index, long[] arr, int off, int len) { assert len > 0 : "len must be > 0 (got " + len + ")"; assert index >= 0 && index < size(); len = Math.min(len, size() - index); assert off + len <= arr.length; for (int i = index, o = off, end = index + len; i < end; ++i, ++o) { set(i, arr[o]); } return len; }
@Override public int set(int index, long[] arr, int off, int len) { long max = 0; for (int i = off, end = off + len; i < end; ++i) { // bitwise or is nice because either all values are positive and the // or-ed result will require as many bits per value as the max of the // values, or one of them is negative and the result will be negative, // forcing GrowableWriter to use 64 bits per value max |= arr[i]; } ensureCapacity(max); return current.set(index, arr, off, len); }
@Override public int set(int index, long[] arr, int off, int len) { long max = 0; for (int i = off, end = off + len; i < end; ++i) { // bitwise or is nice because either all values are positive and the // or-ed result will require as many bits per value as the max of the // values, or one of them is negative and the result will be negative, // forcing GrowableWriter to use 64 bits per value max |= arr[i]; } ensureCapacity(max); return current.set(index, arr, off, len); }
/** * Fill the mutable from <code>fromIndex</code> (inclusive) to * <code>toIndex</code> (exclusive) with <code>val</code>. */ public void fill(int fromIndex, int toIndex, long val) { assert val <= maxValue(getBitsPerValue()); assert fromIndex <= toIndex; for (int i = fromIndex; i < toIndex; ++i) { set(i, val); } }
/** * Fill the mutable from <code>fromIndex</code> (inclusive) to * <code>toIndex</code> (exclusive) with <code>val</code>. */ public void fill(int fromIndex, int toIndex, long val) { assert val <= maxValue(getBitsPerValue()); assert fromIndex <= toIndex; for (int i = fromIndex; i < toIndex; ++i) { set(i, val); } }
/** Set value at <code>index</code>. */ public final void set(long index, long value) { assert index >= 0 && index < size; final int pageIndex = pageIndex(index); final int indexInPage = indexInPage(index); subMutables[pageIndex].set(indexInPage, value); }
/** Set value at <code>index</code>. */ public final void set(long index, long value) { assert index >= 0 && index < size; final int pageIndex = pageIndex(index); final int indexInPage = indexInPage(index); subMutables[pageIndex].set(indexInPage, value); }
@Override public void set(int index, long value) { ensureCapacity(value); current.set(index, value); }
/** Set value at <code>index</code>. */ public final void set(long index, long value) { assert index >= 0 && index < size; final int pageIndex = pageIndex(index); final int indexInPage = indexInPage(index); subMutables[pageIndex].set(indexInPage, value); }
@Override public void set(int index, long value) { ensureCapacity(value); current.set(index, value); }
assert fieldNumOff >= 0 && fieldNumOff < fieldNums.length; final int fgs = (int) fieldFlags.get(fieldNumOff); f.set(i, fgs);
final PackedLongValues.Iterator it = deltas.iterator(); for (int ord = 0; ord < size; ++ord) { newDeltas.set(ord, it.next());
ref = base + (int) hashTable.get(h); assert PackedInts.bitsRequired(off - base) <= hashTable.getBitsPerValue(); hashTable.set(h, off - base); if (off - ref < MAX_DISTANCE && readInt(bytes, ref) == v) { break;
/** * Copy <code>src[srcPos:srcPos+len]</code> into * <code>dest[destPos:destPos+len]</code> using at most <code>mem</code> * bytes. */ public static void copy(Reader src, int srcPos, Mutable dest, int destPos, int len, int mem) { assert srcPos + len <= src.size(); assert destPos + len <= dest.size(); final int capacity = mem >>> 3; if (capacity == 0) { for (int i = 0; i < len; ++i) { dest.set(destPos++, src.get(srcPos++)); } } else if (len > 0) { // use bulk operations final long[] buf = new long[Math.min(capacity, len)]; copy(src, srcPos, dest, destPos, len, buf); } }
/** Set value at <code>index</code>. */ public final void set(long index, long value) { assert index >= 0 && index < size; final int pageIndex = pageIndex(index); final int indexInPage = indexInPage(index); subMutables[pageIndex].set(indexInPage, value); }
@Override public int set(int index, long[] arr, int off, int len) { long max = 0; for (int i = off, end = off + len; i < end; ++i) { // bitwise or is nice because either all values are positive and the // or-ed result will require as many bits per value as the max of the // values, or one of them is negative and the result will be negative, // forcing GrowableWriter to use 64 bits per value max |= arr[i]; } ensureCapacity(max); return current.set(index, arr, off, len); }
@Override public void set(int index, long value) { ensureCapacity(value); current.set(index, value); }
/** * Fill the mutable from <code>fromIndex</code> (inclusive) to * <code>toIndex</code> (exclusive) with <code>val</code>. */ public void fill(int fromIndex, int toIndex, long val) { assert val <= maxValue(getBitsPerValue()); assert fromIndex <= toIndex; for (int i = fromIndex; i < toIndex; ++i) { set(i, val); } }