public GrowableWriter resize(int newSize) { GrowableWriter next = new GrowableWriter(getBitsPerValue(), newSize, acceptableOverheadRatio); final int limit = Math.min(size(), newSize); PackedInts.copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE); return next; }
/** * 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); } }
/** 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; }
private void ensureCapacity(long value) { if ((value & currentMask) == value) { return; } final int bitsRequired = PackedInts.unsignedBitsRequired(value); assert bitsRequired > current.getBitsPerValue(); final int valueCount = size(); PackedInts.Mutable next = PackedInts.getMutable(valueCount, bitsRequired, acceptableOverheadRatio); PackedInts.copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); current = next; currentMask = mask(current.getBitsPerValue()); }
public SinglePackedOrdinals(OrdinalsBuilder builder, float acceptableOverheadRatio) { assert builder.getNumMultiValuesDocs() == 0; this.valueCount = (int) builder.getValueCount(); // We don't reuse the builder as-is because it might have been built with a higher overhead ratio final PackedInts.Mutable reader = PackedInts.getMutable(builder.maxDoc(), PackedInts.bitsRequired(valueCount), acceptableOverheadRatio); PackedInts.copy(builder.getFirstOrdinals(), 0, reader, 0, builder.maxDoc(), 8 * 1024); this.reader = reader; }
public GrowableWriter resize(int newSize) { GrowableWriter next = new GrowableWriter(getBitsPerValue(), newSize, acceptableOverheadRatio); final int limit = Math.min(size(), newSize); PackedInts.copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE); return next; }
public GrowableWriter resize(int newSize) { GrowableWriter next = new GrowableWriter(getBitsPerValue(), newSize, acceptableOverheadRatio); final int limit = Math.min(size(), newSize); PackedInts.copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE); return next; }
public GrowableWriter resize(int newSize) { GrowableWriter next = new GrowableWriter(getBitsPerValue(), newSize, acceptableOverheadRatio); final int limit = Math.min(size(), newSize); PackedInts.copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE); return next; }
/** * 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); } }
/** * 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); } }
/** 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; }
/** 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; }
/** 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; }
private void ensureCapacity(long value) { if ((value & currentMask) == value) { return; } final int bitsRequired = PackedInts.unsignedBitsRequired(value); assert bitsRequired > current.getBitsPerValue(); final int valueCount = size(); PackedInts.Mutable next = PackedInts.getMutable(valueCount, bitsRequired, acceptableOverheadRatio); PackedInts.copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); current = next; currentMask = mask(current.getBitsPerValue()); }
private void ensureCapacity(long value) { if ((value & currentMask) == value) { return; } final int bitsRequired = PackedInts.unsignedBitsRequired(value); assert bitsRequired > current.getBitsPerValue(); final int valueCount = size(); PackedInts.Mutable next = PackedInts.getMutable(valueCount, bitsRequired, acceptableOverheadRatio); PackedInts.copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); current = next; currentMask = mask(current.getBitsPerValue()); }
private void ensureCapacity(long value) { if ((value & currentMask) == value) { return; } final int bitsRequired = PackedInts.unsignedBitsRequired(value); assert bitsRequired > current.getBitsPerValue(); final int valueCount = size(); PackedInts.Mutable next = PackedInts.getMutable(valueCount, bitsRequired, acceptableOverheadRatio); PackedInts.copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); current = next; currentMask = mask(current.getBitsPerValue()); }
public SinglePackedOrdinals(OrdinalsBuilder builder, float acceptableOverheadRatio) { assert builder.getNumMultiValuesDocs() == 0; this.valueCount = (int) builder.getValueCount(); // We don't reuse the builder as-is because it might have been built with a higher overhead ratio final PackedInts.Mutable reader = PackedInts.getMutable(builder.maxDoc(), PackedInts.bitsRequired(valueCount), acceptableOverheadRatio); PackedInts.copy(builder.getFirstOrdinals(), 0, reader, 0, builder.maxDoc(), 8 * 1024); this.reader = reader; }
public SinglePackedOrdinals(OrdinalsBuilder builder, float acceptableOverheadRatio) { assert builder.getNumMultiValuesDocs() == 0; this.valueCount = (int) builder.getValueCount(); // We don't reuse the builder as-is because it might have been built with a higher overhead ratio final PackedInts.Mutable reader = PackedInts.getMutable(builder.maxDoc(), PackedInts.bitsRequired(valueCount), acceptableOverheadRatio); PackedInts.copy(builder.getFirstOrdinals(), 0, reader, 0, builder.maxDoc(), 8 * 1024); this.reader = reader; }
public SinglePackedOrdinals(OrdinalsBuilder builder, float acceptableOverheadRatio) { assert builder.getNumMultiValuesDocs() == 0; this.valueCount = (int) builder.getValueCount(); // We don't reuse the builder as-is because it might have been built with a higher overhead ratio final PackedInts.Mutable reader = PackedInts.getMutable(builder.maxDoc(), PackedInts.bitsRequired(valueCount), acceptableOverheadRatio); PackedInts.copy(builder.getFirstOrdinals(), 0, reader, 0, builder.maxDoc(), 8 * 1024); this.reader = reader; }
public SinglePackedOrdinals(OrdinalsBuilder builder, float acceptableOverheadRatio) { assert builder.getNumMultiValuesDocs() == 0; this.valueCount = (int) builder.getValueCount(); // We don't reuse the builder as-is because it might have been built with a higher overhead ratio final PackedInts.Mutable reader = PackedInts.getMutable(builder.maxDoc(), PackedInts.bitsRequired(valueCount), acceptableOverheadRatio); PackedInts.copy(builder.getFirstOrdinals(), 0, reader, 0, builder.maxDoc(), 8 * 1024); this.reader = reader; }