protected void grow(int newLen) { docs = ArrayUtil.growExact(docs, newLen); }
private void growBuffer(Buffer buffer, int additionalCapacity) { buffer.array = ArrayUtil.growExact(buffer.array, buffer.array.length + additionalCapacity); totalAllocated += additionalCapacity; }
/** * Create a new outgoing transition labeled <code>label</code> and return * the newly created target state for this transition. */ State newState(int label) { assert Arrays.binarySearch(labels, label) < 0 : "State already has transition labeled: " + label; labels = ArrayUtil.growExact(labels, labels.length + 1); states = ArrayUtil.growExact(states, states.length + 1); labels[labels.length - 1] = label; return states[states.length - 1] = new State(); }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static <T> T[] grow(T[] array, int minSize) { assert minSize >= 0 : "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { final int newLength = oversize(minSize, RamUsageEstimator.NUM_BYTES_OBJECT_REF); return growExact(array, newLength); } else return array; }
@Override protected void grow(int newLen) { super.grow(newLen); scores = ArrayUtil.growExact(scores, newLen); }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static double[] grow(double[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Double.BYTES)); } else return array; }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static int[] grow(int[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Integer.BYTES)); } else return array; }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static short[] grow(short[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Short.BYTES)); } else return array; }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static byte[] grow(byte[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Byte.BYTES)); } else return array; }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static long[] grow(long[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Long.BYTES)); } else return array; }
/** Returns an array whose size is at least {@code minSize}, generally over-allocating exponentially */ public static char[] grow(char[] array, int minSize) { assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?"; if (array.length < minSize) { return growExact(array, oversize(minSize, Character.BYTES)); } else return array; }
@Override public void append(byte[] packedValue, long ord, int docID) { assert closed == false; assert packedValue.length == packedBytesLength; if (docIDs.length == nextWrite) { int nextSize = Math.min(maxSize, ArrayUtil.oversize(nextWrite+1, Integer.BYTES)); assert nextSize > nextWrite: "nextSize=" + nextSize + " vs nextWrite=" + nextWrite; docIDs = ArrayUtil.growExact(docIDs, nextSize); if (singleValuePerDoc == false) { if (ordsLong != null) { ordsLong = ArrayUtil.growExact(ordsLong, nextSize); } else { ords = ArrayUtil.growExact(ords, nextSize); } } } writePackedValue(nextWrite, packedValue); if (singleValuePerDoc == false) { if (ordsLong != null) { ordsLong[nextWrite] = ord; } else { assert ord <= Integer.MAX_VALUE; ords[nextWrite] = (int) ord; } } docIDs[nextWrite] = docID; nextWrite++; }
void grow(int newBlockCount) { ramBytesUsed -= RamUsageEstimator.shallowSizeOf(values); values = ArrayUtil.growExact(values, newBlockCount); ramBytesUsed += RamUsageEstimator.shallowSizeOf(values); }
@Override public void finishDocument() throws IOException { if (numBufferedDocs == this.numStoredFields.length) { final int newLength = ArrayUtil.oversize(numBufferedDocs + 1, 4); this.numStoredFields = ArrayUtil.growExact(this.numStoredFields, newLength); endOffsets = ArrayUtil.growExact(endOffsets, newLength); } this.numStoredFields[numBufferedDocs] = numStoredFieldsInDoc; numStoredFieldsInDoc = 0; endOffsets[numBufferedDocs] = bufferedDocs.getPosition(); ++numBufferedDocs; if (triggerFlush()) { flush(); } }
void addPosition(int position, int startOffset, int length, int payloadLength) { if (hasPositions) { if (posStart + totalPositions == positionsBuf.length) { positionsBuf = ArrayUtil.grow(positionsBuf); } positionsBuf[posStart + totalPositions] = position; } if (hasOffsets) { if (offStart + totalPositions == startOffsetsBuf.length) { final int newLength = ArrayUtil.oversize(offStart + totalPositions, 4); startOffsetsBuf = ArrayUtil.growExact(startOffsetsBuf, newLength); lengthsBuf = ArrayUtil.growExact(lengthsBuf, newLength); } startOffsetsBuf[offStart + totalPositions] = startOffset; lengthsBuf[offStart + totalPositions] = length; } if (hasPayloads) { if (payStart + totalPositions == payloadLengthsBuf.length) { payloadLengthsBuf = ArrayUtil.grow(payloadLengthsBuf); } payloadLengthsBuf[payStart + totalPositions] = payloadLength; } ++totalPositions; } }
/** * Concatenate the buffers in any order, leaving at least one empty slot in * the end * NOTE: this method might reuse one of the arrays */ private static Buffer concat(List<Buffer> buffers) { int totalLength = 0; Buffer largestBuffer = null; for (Buffer buffer : buffers) { totalLength += buffer.length; if (largestBuffer == null || buffer.array.length > largestBuffer.array.length) { largestBuffer = buffer; } } if (largestBuffer == null) { return new Buffer(1); } int[] docs = largestBuffer.array; if (docs.length < totalLength + 1) { docs = ArrayUtil.growExact(docs, totalLength + 1); } totalLength = largestBuffer.length; for (Buffer buffer : buffers) { if (buffer != largestBuffer) { System.arraycopy(buffer.array, 0, docs, totalLength, buffer.length); totalLength += buffer.length; } } return new Buffer(docs, totalLength); }
@Override void grow(int newBlockCount) { super.grow(newBlockCount); ramBytesUsed -= RamUsageEstimator.sizeOf(mins); mins = ArrayUtil.growExact(mins, newBlockCount); ramBytesUsed += RamUsageEstimator.sizeOf(mins); }
@Override void grow(int newBlockCount) { super.grow(newBlockCount); ramBytesUsed -= RamUsageEstimator.sizeOf(averages); averages = ArrayUtil.growExact(averages, newBlockCount); ramBytesUsed += RamUsageEstimator.sizeOf(averages); }
docBases = ArrayUtil.growExact(docBases, newSize); startPointers = ArrayUtil.growExact(startPointers, newSize); avgChunkDocs = ArrayUtil.growExact(avgChunkDocs, newSize); avgChunkSizes = ArrayUtil.growExact(avgChunkSizes, newSize); docBasesDeltas = ArrayUtil.growExact(docBasesDeltas, newSize); startPointersDeltas = ArrayUtil.growExact(startPointersDeltas, newSize);