void reset(int len) { final int bitsPerOffset = PackedInts.bitsRequired(len - LAST_LITERALS); final int bitsPerOffsetLog = 32 - Integer.numberOfLeadingZeros(bitsPerOffset - 1); hashLog = MEMORY_USAGE + 3 - bitsPerOffsetLog; if (hashTable == null || hashTable.size() < 1 << hashLog || hashTable.getBitsPerValue() < bitsPerOffset) { hashTable = PackedInts.getMutable(1 << hashLog, bitsPerOffset, PackedInts.DEFAULT); } else { hashTable.clear(); } }
/** 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); } }
final PackedLongValues.Iterator it = deltas.iterator(); for (int ord = 0; ord < size; ++ord) { newDeltas.set(ord, it.next()); ramBytesUsed += newDeltas.ramBytesUsed(); } else { segmentToGlobalOrds[i] = new LongValues() {
final PackedLongValues.Iterator it = deltas.iterator(); for (int ord = 0; ord < size; ++ord) { newDeltas.set(ord, it.next()); ramBytesUsed += newDeltas.ramBytesUsed(); } else { segmentToGlobalOrds[i] = new LongValues() {
final PackedLongValues.Iterator it = deltas.iterator(); for (int ord = 0; ord < size; ++ord) { newDeltas.set(ord, it.next()); ramBytesUsed += newDeltas.ramBytesUsed(); } else { segmentToGlobalOrds[i] = new LongValues() {
((PackedInts.Mutable) nodeRefToAddress).save(out);
((PackedInts.Mutable) nodeRefToAddress).save(out);
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;
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;
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;
/** * 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; }
/** Create a new copy of size <code>newSize</code> based on the content of * this buffer. This method is much more efficient than creating a new * instance and copying values one by one. */ public final T resize(long newSize) { final T copy = newUnfilledCopy(newSize); final int numCommonPages = Math.min(copy.subMutables.length, subMutables.length); final long[] copyBuffer = new long[1024]; for (int i = 0; i < copy.subMutables.length; ++i) { final int valueCount = i == copy.subMutables.length - 1 ? lastPageSize(newSize) : pageSize(); final int bpv = i < numCommonPages ? subMutables[i].getBitsPerValue() : this.bitsPerValue; copy.subMutables[i] = newMutable(valueCount, bpv); if (i < numCommonPages) { final int copyLength = Math.min(valueCount, subMutables[i].size()); PackedInts.copy(subMutables[i], 0, copy.subMutables[i], 0, copyLength, copyBuffer); } } return copy; }
/** * 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); } }
/** * 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 void clear() { current.clear(); }
/** * 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 size() { return current.size(); }
@Override public int get(int index, long[] arr, int off, int len) { return current.get(index, arr, off, len); }