/** * 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; }
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(); } }
/** * 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; }
/** * Save this mutable into <code>out</code>. Instantiating a reader from * the generated data will return a reader with the same number of bits * per value. */ public void save(DataOutput out) throws IOException { Writer writer = getWriterNoHeader(out, getFormat(), size(), getBitsPerValue(), DEFAULT_BUFFER_SIZE); writer.writeHeader(); for (int i = 0; i < size(); ++i) { writer.add(get(i)); } writer.finish(); }
@Override public int size() { return current.size(); }
/** * Save this mutable into <code>out</code>. Instantiating a reader from * the generated data will return a reader with the same number of bits * per value. */ public void save(DataOutput out) throws IOException { Writer writer = getWriterNoHeader(out, getFormat(), size(), getBitsPerValue(), DEFAULT_BUFFER_SIZE); writer.writeHeader(); for (int i = 0; i < size(); ++i) { writer.add(get(i)); } writer.finish(); }
/** * Save this mutable into <code>out</code>. Instantiating a reader from * the generated data will return a reader with the same number of bits * per value. */ public void save(DataOutput out) throws IOException { Writer writer = getWriterNoHeader(out, getFormat(), size(), getBitsPerValue(), DEFAULT_BUFFER_SIZE); writer.writeHeader(); for (int i = 0; i < size(); ++i) { writer.add(get(i)); } writer.finish(); }
@Override public int size() { return current.size(); }
@Override public int size() { return current.size(); }
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(); } }
/** * Sets all values to 0. */ public void clear() { fill(0, size(), 0); }
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(); } }
/** * Sets all values to 0. */ public void clear() { fill(0, size(), 0); }
/** * Sets all values to 0. */ public void clear() { fill(0, size(), 0); }
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(); } }
/** * 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); } }
@Override public int size() { return current.size(); }
/** * Save this mutable into <code>out</code>. Instantiating a reader from * the generated data will return a reader with the same number of bits * per value. */ public void save(DataOutput out) throws IOException { Writer writer = getWriterNoHeader(out, getFormat(), size(), getBitsPerValue(), DEFAULT_BUFFER_SIZE); writer.writeHeader(); for (int i = 0; i < size(); ++i) { writer.add(get(i)); } writer.finish(); }
/** * Sets all values to 0. */ public void clear() { fill(0, size(), 0); }