org.apache.lucene.util.ByteBlockPool.allocSlice java code examples

Common ways to obtain ByteBlockPool

private void myMethod () {
 ByteBlockPool b =new ByteBlockPool(new DirectAllocator())
Counter bytesUsed;new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(bytesUsed))
ByteBlockPool.Allocator allocator;new ByteBlockPool(allocator)
Smart code suggestions by Tabnine
}

/** 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])++;
}

Javadoc

Creates a new byte slice with the given starting size and returns the slices offset in the pool.

Popular methods of ByteBlockPool

<init>
reset
Expert: Resets the pool to its initial state reusing the first buffer. Calling ByteBlockPool#nextBuf
nextBuffer
Advances the pool to its next buffer. This method should be called once after the constructor to ini
append
Appends the bytes in the provided BytesRef at the current position.
newSlice
Allocates a new slice with the given size.
readBytes
Reads bytes bytes out of the pool starting at the given offset with the given length into the given
setBytesRef
Fill the provided BytesRef with the bytes at the specified offset/length slice. This will avoid copy
readByte
Read a single byte at the given offset.
setRawBytesRef
Set the given BytesRef so that its content is equal to the ref.length bytes starting at offset. Most
copy
copyFrom

copyFrom

Popular in Java

Start an intent from android
getContentResolver (Context)
onCreateOptionsMenu (Activity)
notifyDataSetChanged (ArrayAdapter)
Window (java.awt)
A Window object is a top-level window with no borders and no menubar. The default layout for a windo
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
Collectors (java.util.stream)
ServletException (javax.servlet)
Defines a general exception a servlet can throw when it encounters difficulty.
Logger (org.apache.log4j)
This is the central class in the log4j package. Most logging operations, except configuration, are d
Runner (org.openjdk.jmh.runner)
21 Best Atom Packages for 2021

How to use allocSlicemethodin org.apache.lucene.util.ByteBlockPool

Best Java code snippets using org.apache.lucene.util.ByteBlockPool.allocSlice (Showing top 12 results out of 315)

How to use
allocSlice
method
in
org.apache.lucene.util.ByteBlockPool