How to use

allocSlice

method

in

org.apache.lucene.util.ByteBlockPool

/** Write byte into byte slice stream */
@Override
public void writeByte(byte b) {
 assert slice != null;
 if (slice[upto] != 0) {
  upto = pool.allocSlice(slice, upto);
  slice = pool.buffer;
  offset0 = pool.byteOffset;
  assert slice != null;
 }
 slice[upto++] = b;
 assert upto != slice.length;
}

void writeByte(int stream, byte b) {
 int upto = intUptos[intUptoStart+stream];
 byte[] bytes = bytePool.buffers[upto >> ByteBlockPool.BYTE_BLOCK_SHIFT];
 assert bytes != null;
 int offset = upto & ByteBlockPool.BYTE_BLOCK_MASK;
 if (bytes[offset] != 0) {
  // End of slice; allocate a new one
  offset = bytePool.allocSlice(bytes, offset);
  bytes = bytePool.buffer;
  intUptos[intUptoStart+stream] = offset + bytePool.byteOffset;
 }
 bytes[offset] = b;
 (intUptos[intUptoStart+stream])++;
}

@Override
public void writeBytes(final byte[] b, int offset, final int len) {
 final int offsetEnd = offset + len;
 while(offset < offsetEnd) {
  if (slice[upto] != 0) {
   // End marker
   upto = pool.allocSlice(slice, upto);
   slice = pool.buffer;
   offset0 = pool.byteOffset;
  }
  slice[upto++] = b[offset++];
  assert upto != slice.length;
 }
}

/** Write byte into byte slice stream */
@Override
public void writeByte(byte b) {
 assert slice != null;
 if (slice[upto] != 0) {
  upto = pool.allocSlice(slice, upto);
  slice = pool.buffer;
  offset0 = pool.byteOffset;
  assert slice != null;
 }
 slice[upto++] = b;
 assert upto != slice.length;
}

/** Write byte into byte slice stream */
@Override
public void writeByte(byte b) {
 assert slice != null;
 if (slice[upto] != 0) {
  upto = pool.allocSlice(slice, upto);
  slice = pool.buffer;
  offset0 = pool.byteOffset;
  assert slice != null;
 }
 slice[upto++] = b;
 assert upto != slice.length;
}

/** Write byte into byte slice stream */
@Override
public void writeByte(byte b) {
 assert slice != null;
 if (slice[upto] != 0) {
  upto = pool.allocSlice(slice, upto);
  slice = pool.buffer;
  offset0 = pool.byteOffset;
  assert slice != null;
 }
 slice[upto++] = b;
 assert upto != slice.length;
}

void writeByte(int stream, byte b) {
 int upto = intUptos[intUptoStart+stream];
 byte[] bytes = bytePool.buffers[upto >> ByteBlockPool.BYTE_BLOCK_SHIFT];
 assert bytes != null;
 int offset = upto & ByteBlockPool.BYTE_BLOCK_MASK;
 if (bytes[offset] != 0) {
  // End of slice; allocate a new one
  offset = bytePool.allocSlice(bytes, offset);
  bytes = bytePool.buffer;
  intUptos[intUptoStart+stream] = offset + bytePool.byteOffset;
 }
 bytes[offset] = b;
 (intUptos[intUptoStart+stream])++;
}

@Override
public void writeBytes(final byte[] b, int offset, final int len) {
 final int offsetEnd = offset + len;
 while(offset < offsetEnd) {
  if (slice[upto] != 0) {
   // End marker
   upto = pool.allocSlice(slice, upto);
   slice = pool.buffer;
   offset0 = pool.byteOffset;
  }
  slice[upto++] = b[offset++];
  assert upto != slice.length;
 }
}

@Override
public void writeBytes(final byte[] b, int offset, final int len) {
 final int offsetEnd = offset + len;
 while(offset < offsetEnd) {
  if (slice[upto] != 0) {
   // End marker
   upto = pool.allocSlice(slice, upto);
   slice = pool.buffer;
   offset0 = pool.byteOffset;
  }
  slice[upto++] = b[offset++];
  assert upto != slice.length;
 }
}

void writeByte(int stream, byte b) {
 int upto = intUptos[intUptoStart+stream];
 byte[] bytes = bytePool.buffers[upto >> ByteBlockPool.BYTE_BLOCK_SHIFT];
 assert bytes != null;
 int offset = upto & ByteBlockPool.BYTE_BLOCK_MASK;
 if (bytes[offset] != 0) {
  // End of slice; allocate a new one
  offset = bytePool.allocSlice(bytes, offset);
  bytes = bytePool.buffer;
  intUptos[intUptoStart+stream] = offset + bytePool.byteOffset;
 }
 bytes[offset] = b;
 (intUptos[intUptoStart+stream])++;
}

@Override
public void writeBytes(final byte[] b, int offset, final int len) {
 final int offsetEnd = offset + len;
 while(offset < offsetEnd) {
  if (slice[upto] != 0) {
   // End marker
   upto = pool.allocSlice(slice, upto);
   slice = pool.buffer;
   offset0 = pool.byteOffset;
  }
  slice[upto++] = b[offset++];
  assert upto != slice.length;
 }
}

void writeByte(int stream, byte b) {
 int upto = intUptos[intUptoStart+stream];
 byte[] bytes = bytePool.buffers[upto >> ByteBlockPool.BYTE_BLOCK_SHIFT];
 assert bytes != null;
 int offset = upto & ByteBlockPool.BYTE_BLOCK_MASK;
 if (bytes[offset] != 0) {
  // End of slice; allocate a new one
  offset = bytePool.allocSlice(bytes, offset);
  bytes = bytePool.buffer;
  intUptos[intUptoStart+stream] = offset + bytePool.byteOffset;
 }
 bytes[offset] = b;
 (intUptos[intUptoStart+stream])++;
}