How to use

setLength

method

in

org.apache.lucene.util.BytesRefBuilder

/**
 * Reset this builder to the empty state.
 */
public void clear() {
 setLength(0);
}

 private void fillTerm() {
  final int termLength = prefix + suffix;
  ste.term.setLength(termLength);
  ste.term.grow(termLength);
  System.arraycopy(suffixBytes, startBytePos, ste.term.bytes(), prefix, suffix);
 }
}

@Override
protected void setPivot(int i) {
 pivot.setLength(0);
 for (int o = k; o < maxLength; ++o) {
  final int b = byteAt(i, o);
  if (b == -1) {
   break;
  }
  pivot.append((byte) b);
 }
}

@Override
protected void setPivot(int i) {
 pivot.setLength(0);
 for (int o = d; o < maxLength; ++o) {
  final int b = byteAt(i, o);
  if (b == -1) {
   break;
  }
  pivot.append((byte) b);
 }
}

 /**
  * Attempts to backtrack thru the string after encountering a dead end
  * at some given position. Returns false if no more possible strings 
  * can match.
  * 
  * @param position current position in the input String
  * @return {@code position >= 0} if more possible solutions exist for the DFA
  */
 private int backtrack(int position) {
  while (position-- > 0) {
   int nextChar = seekBytesRef.byteAt(position) & 0xff;
   // if a character is 0xff it's a dead-end too,
   // because there is no higher character in binary sort order.
   if (nextChar++ != 0xff) {
    seekBytesRef.setByteAt(position, (byte) nextChar);
    seekBytesRef.setLength(position+1);
    return position;
   }
  }
  return -1; /* all solutions exhausted */
 }
}

@Override
public int nextDoc() throws IOException {
 int docID = docsWithField.nextDoc();
 if (docID != NO_MORE_DOCS) {
  int length = Math.toIntExact(lengthsIterator.next());
  value.setLength(length);
  bytesIterator.readBytes(value.bytes(), 0, length);
 }
 return docID;
}

private void readTermBytes(int prefix, int suffix) throws IOException {
 builder.grow(prefix + suffix);
 input.readBytes(builder.bytes(), prefix, suffix);
 builder.setLength(prefix + suffix);
}

/** Just converts IntsRef to BytesRef; you must ensure the
 *  int values fit into a byte. */
public static BytesRef toBytesRef(IntsRef input, BytesRefBuilder scratch) {
 scratch.grow(input.length);
 for(int i=0;i<input.length;i++) {
  int value = input.ints[i+input.offset];
  // NOTE: we allow -128 to 255
  assert value >= Byte.MIN_VALUE && value <= 255: "value " + value + " doesn't fit into byte";
  scratch.setByteAt(i, (byte) value);
 }
 scratch.setLength(input.length);
 return scratch.get();
}

public void nextLeaf() {
 //if (DEBUG) System.out.println("  frame.next ord=" + ord + " nextEnt=" + nextEnt + " entCount=" + entCount);
 assert nextEnt != -1 && nextEnt < entCount: "nextEnt=" + nextEnt + " entCount=" + entCount + " fp=" + fp;
 nextEnt++;
 suffix = suffixesReader.readVInt();
 startBytePos = suffixesReader.getPosition();
 ste.term.setLength(prefix + suffix);
 ste.term.grow(ste.term.length());
 suffixesReader.readBytes(ste.term.bytes(), prefix, suffix);
 ste.termExists = true;
}

/**
 * Returns the <i>n'th</i> element of this {@link BytesRefArray}
 * @param spare a spare {@link BytesRef} instance
 * @param index the elements index to retrieve 
 * @return the <i>n'th</i> element of this {@link BytesRefArray}
 */
public BytesRef get(BytesRefBuilder spare, int index) {
 FutureObjects.checkIndex(index, lastElement);
 int offset = offsets[index];
 int length = index == lastElement - 1 ? currentOffset - offset
   : offsets[index + 1] - offset;
 spare.grow(length);
 spare.setLength(length);
 pool.readBytes(offset, spare.bytes(), 0, spare.length());
 return spare.get();
}

/**
 * Reads the next entry into the provided {@link BytesRef}. The internal
 * storage is resized if needed.
 * 
 * @return Returns <code>false</code> if EOF occurred when trying to read
 * the header of the next sequence. Returns <code>true</code> otherwise.
 * @throws EOFException if the file ends before the full sequence is read.
 */
public BytesRef next() throws IOException {
 if (in.getFilePointer() >= end) {
  return null;
 }
 short length = in.readShort();
 ref.grow(length);
 ref.setLength(length);
 in.readBytes(ref.bytes(), 0, length);
 return ref.get();
}

output.setLength(input.length);
if (numTransitions == 0) {
 assert runAutomaton.isAccept(state);
 output.setLength(idx);
   output.setLength(idx);

@Override
public int nextPosition() throws IOException {
 assert posLeft > 0;
 posLeft--;
 int code = posReader.readVInt();
 pos += code >>> 1;
 if ((code & 1) != 0) {
  hasPayload = true;
  // has a payload
  payload.setLength(posReader.readVInt());
  payload.grow(payload.length());
  posReader.readBytes(payload.bytes(), 0, payload.length());
 } else {
  hasPayload = false;
 }
 if (readOffsets) {
  startOffset += posReader.readVInt();
  endOffset = startOffset + posReader.readVInt();
 }
 return pos;
}

suffix = code >>> 1;
startBytePos = suffixesReader.getPosition();
ste.term.setLength(prefix + suffix);
ste.term.grow(ste.term.length());
suffixesReader.readBytes(ste.term.bytes(), prefix, suffix);

   scratch.setLength(scratch.length() - 1);
   return scratch.get();
scratch.setLength(scratch.length() + 1);
scratch.grow(scratch.length());

 payload.setLength(payloadLength);
 thisPayload = payload.get();
} else {

term.setLength(idx);

seekBytesRef.setLength(position);
visited[state] = curGen;

  termExists = false;
  term.setByteAt(targetUpto, (byte) targetLabel);
  term.setLength(1+targetUpto);
term.setLength(targetUpto);

/**
 * Computes a strong hash value for small files. Note that this method should only be used for files < 1MB
 */
public static void hashFile(BytesRefBuilder fileHash, InputStream in, long size) throws IOException {
  final int len = (int) Math.min(1024 * 1024, size); // for safety we limit this to 1MB
  fileHash.grow(len);
  fileHash.setLength(len);
  final int readBytes = Streams.readFully(in, fileHash.bytes(), 0, len);
  assert readBytes == len : Integer.toString(readBytes) + " != " + Integer.toString(len);
  assert fileHash.length() == len : Integer.toString(fileHash.length()) + " != " + Integer.toString(len);
}