org.apache.lucene.util.ByteBlockPool.nextBuffer 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
}

/**
 * Allocates a new slice with the given size. 
 * @see ByteBlockPool#FIRST_LEVEL_SIZE
 */
public int newSlice(final int size) {
 if (byteUpto > BYTE_BLOCK_SIZE-size)
  nextBuffer();
 final int upto = byteUpto;
 byteUpto += size;
 buffer[byteUpto-1] = 16;
 return upto;
}

/**
 * Creates a new byte slice with the given starting size and 
 * returns the slices offset in the pool.
 */
public int allocSlice(final byte[] slice, final int upto) {
 final int level = slice[upto] & 15;
 final int newLevel = NEXT_LEVEL_ARRAY[level];
 final int newSize = LEVEL_SIZE_ARRAY[newLevel];
 // Maybe allocate another block
 if (byteUpto > BYTE_BLOCK_SIZE-newSize) {
  nextBuffer();
 }
 final int newUpto = byteUpto;
 final int offset = newUpto + byteOffset;
 byteUpto += newSize;
 // Copy forward the past 3 bytes (which we are about
 // to overwrite with the forwarding address):
 buffer[newUpto] = slice[upto-3];
 buffer[newUpto+1] = slice[upto-2];
 buffer[newUpto+2] = slice[upto-1];
 // Write forwarding address at end of last slice:
 slice[upto-3] = (byte) (offset >>> 24);
 slice[upto-2] = (byte) (offset >>> 16);
 slice[upto-1] = (byte) (offset >>> 8);
 slice[upto] = (byte) offset;
   
 // Write new level:
 buffer[byteUpto-1] = (byte) (16|newLevel);
 return newUpto+3;
}

/**
 * Appends the bytes in the provided {@link BytesRef} at
 * the current position.
 */
public void append(final BytesRef bytes) {
 int bytesLeft = bytes.length;
 int offset = bytes.offset;
 while (bytesLeft > 0) {
  int bufferLeft = BYTE_BLOCK_SIZE - byteUpto;
  if (bytesLeft < bufferLeft) {
   // fits within current buffer
   System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesLeft);
   byteUpto += bytesLeft;
   break;
  } else {
   // fill up this buffer and move to next one
   if (bufferLeft > 0) {
    System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bufferLeft);
   }
   nextBuffer();
   bytesLeft -= bufferLeft;
   offset += bufferLeft;
  }
 }
}

/**
 * Creates a new {@link BytesRefArray} with a counter to track allocated bytes
 */
public BytesRefArray(Counter bytesUsed) {
 this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(
   bytesUsed));
 pool.nextBuffer();
 bytesUsed.addAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER * Integer.BYTES);
 this.bytesUsed = bytesUsed;
}

   + (BYTE_BLOCK_SIZE - 2) + " in length; got " + bytes.length);
pool.nextBuffer();

public void add(int textStart) throws IOException {
 int termID = bytesHash.addByPoolOffset(textStart);
 if (termID >= 0) {      // New posting
  // First time we are seeing this token since we last
  // flushed the hash.
  // Init stream slices
  if (numPostingInt + intPool.intUpto > IntBlockPool.INT_BLOCK_SIZE) {
   intPool.nextBuffer();
  }
  if (ByteBlockPool.BYTE_BLOCK_SIZE - bytePool.byteUpto < numPostingInt*ByteBlockPool.FIRST_LEVEL_SIZE) {
   bytePool.nextBuffer();
  }
  intUptos = intPool.buffer;
  intUptoStart = intPool.intUpto;
  intPool.intUpto += streamCount;
  postingsArray.intStarts[termID] = intUptoStart + intPool.intOffset;
  for(int i=0;i<streamCount;i++) {
   final int upto = bytePool.newSlice(ByteBlockPool.FIRST_LEVEL_SIZE);
   intUptos[intUptoStart+i] = upto + bytePool.byteOffset;
  }
  postingsArray.byteStarts[termID] = intUptos[intUptoStart];
  newTerm(termID);
 } else {
  termID = (-termID)-1;
  int intStart = postingsArray.intStarts[termID];
  intUptos = intPool.buffers[intStart >> IntBlockPool.INT_BLOCK_SHIFT];
  intUptoStart = intStart & IntBlockPool.INT_BLOCK_MASK;
  addTerm(termID);
 }
}

bytePool.nextBuffer();

/**
 * Allocates a new slice with the given size. 
 * @see ByteBlockPool#FIRST_LEVEL_SIZE
 */
public int newSlice(final int size) {
 if (byteUpto > BYTE_BLOCK_SIZE-size)
  nextBuffer();
 final int upto = byteUpto;
 byteUpto += size;
 buffer[byteUpto-1] = 16;
 return upto;
}

/**
 * Allocates a new slice with the given size. 
 * @see ByteBlockPool#FIRST_LEVEL_SIZE
 */
public int newSlice(final int size) {
 if (byteUpto > BYTE_BLOCK_SIZE-size)
  nextBuffer();
 final int upto = byteUpto;
 byteUpto += size;
 buffer[byteUpto-1] = 16;
 return upto;
}

/**
 * Allocates a new slice with the given size. 
 * @see ByteBlockPool#FIRST_LEVEL_SIZE
 */
public int newSlice(final int size) {
 if (byteUpto > BYTE_BLOCK_SIZE-size)
  nextBuffer();
 final int upto = byteUpto;
 byteUpto += size;
 buffer[byteUpto-1] = 16;
 return upto;
}

/**
 * Creates a new byte slice with the given starting size and 
 * returns the slices offset in the pool.
 */
public int allocSlice(final byte[] slice, final int upto) {
 final int level = slice[upto] & 15;
 final int newLevel = NEXT_LEVEL_ARRAY[level];
 final int newSize = LEVEL_SIZE_ARRAY[newLevel];
 // Maybe allocate another block
 if (byteUpto > BYTE_BLOCK_SIZE-newSize) {
  nextBuffer();
 }
 final int newUpto = byteUpto;
 final int offset = newUpto + byteOffset;
 byteUpto += newSize;
 // Copy forward the past 3 bytes (which we are about
 // to overwrite with the forwarding address):
 buffer[newUpto] = slice[upto-3];
 buffer[newUpto+1] = slice[upto-2];
 buffer[newUpto+2] = slice[upto-1];
 // Write forwarding address at end of last slice:
 slice[upto-3] = (byte) (offset >>> 24);
 slice[upto-2] = (byte) (offset >>> 16);
 slice[upto-1] = (byte) (offset >>> 8);
 slice[upto] = (byte) offset;
   
 // Write new level:
 buffer[byteUpto-1] = (byte) (16|newLevel);
 return newUpto+3;
}

/**
 * Creates a new byte slice with the given starting size and 
 * returns the slices offset in the pool.
 */
public int allocSlice(final byte[] slice, final int upto) {
 final int level = slice[upto] & 15;
 final int newLevel = NEXT_LEVEL_ARRAY[level];
 final int newSize = LEVEL_SIZE_ARRAY[newLevel];
 // Maybe allocate another block
 if (byteUpto > BYTE_BLOCK_SIZE-newSize) {
  nextBuffer();
 }
 final int newUpto = byteUpto;
 final int offset = newUpto + byteOffset;
 byteUpto += newSize;
 // Copy forward the past 3 bytes (which we are about
 // to overwrite with the forwarding address):
 buffer[newUpto] = slice[upto-3];
 buffer[newUpto+1] = slice[upto-2];
 buffer[newUpto+2] = slice[upto-1];
 // Write forwarding address at end of last slice:
 slice[upto-3] = (byte) (offset >>> 24);
 slice[upto-2] = (byte) (offset >>> 16);
 slice[upto-1] = (byte) (offset >>> 8);
 slice[upto] = (byte) offset;
   
 // Write new level:
 buffer[byteUpto-1] = (byte) (16|newLevel);
 return newUpto+3;
}

/**
 * Appends the bytes in the provided {@link BytesRef} at
 * the current position.
 */
public void append(final BytesRef bytes) {
 int bytesLeft = bytes.length;
 int offset = bytes.offset;
 while (bytesLeft > 0) {
  int bufferLeft = BYTE_BLOCK_SIZE - byteUpto;
  if (bytesLeft < bufferLeft) {
   // fits within current buffer
   System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesLeft);
   byteUpto += bytesLeft;
   break;
  } else {
   // fill up this buffer and move to next one
   if (bufferLeft > 0) {
    System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bufferLeft);
   }
   nextBuffer();
   bytesLeft -= bufferLeft;
   offset += bufferLeft;
  }
 }
}

/**
 * Appends the bytes in the provided {@link BytesRef} at
 * the current position.
 */
public void append(final BytesRef bytes) {
 int length = bytes.length;
 if (length == 0) {
  return;
 }
 int offset = bytes.offset;
 int overflow = (length + byteUpto) - BYTE_BLOCK_SIZE;
 do {
  if (overflow <= 0) { 
   System.arraycopy(bytes.bytes, offset, buffer, byteUpto, length);
   byteUpto += length;
   break;
  } else {
   final int bytesToCopy = length-overflow;
   if (bytesToCopy > 0) {
    System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesToCopy);
    offset += bytesToCopy;
    length -= bytesToCopy;
   }
   nextBuffer();
   overflow = overflow - BYTE_BLOCK_SIZE;
  }
 }  while(true);
}

/**
 * Appends the bytes in the provided {@link BytesRef} at
 * the current position.
 */
public void append(final BytesRef bytes) {
 int length = bytes.length;
 if (length == 0) {
  return;
 }
 int offset = bytes.offset;
 int overflow = (length + byteUpto) - BYTE_BLOCK_SIZE;
 do {
  if (overflow <= 0) { 
   System.arraycopy(bytes.bytes, offset, buffer, byteUpto, length);
   byteUpto += length;
   break;
  } else {
   final int bytesToCopy = length-overflow;
   if (bytesToCopy > 0) {
    System.arraycopy(bytes.bytes, offset, buffer, byteUpto, bytesToCopy);
    offset += bytesToCopy;
    length -= bytesToCopy;
   }
   nextBuffer();
   overflow = overflow - BYTE_BLOCK_SIZE;
  }
 }  while(true);
}

/**
 * Creates a new {@link BytesRefList}
 */
public BytesRefList() {
 this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(
   bytesUsed));
 pool.nextBuffer();
 bytesUsed.addAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER
   + RamUsageEstimator.NUM_BYTES_INT);
}

/**
 * Creates a new {@link BytesRefArray} with a counter to track allocated bytes
 */
public BytesRefArray(Counter bytesUsed) {
 this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(
   bytesUsed));
 pool.nextBuffer();
 bytesUsed.addAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER
   + RamUsageEstimator.NUM_BYTES_INT);
 this.bytesUsed = bytesUsed;
}

/**
 * Creates a new {@link BytesRefArray} with a counter to track allocated bytes
 */
public BytesRefArray(Counter bytesUsed) {
 this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(
   bytesUsed));
 pool.nextBuffer();
 bytesUsed.addAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER
   + RamUsageEstimator.NUM_BYTES_INT);
 this.bytesUsed = bytesUsed;
}

/**
 * Creates a new {@link BytesRefArray} with a counter to track allocated bytes
 */
public BytesRefArray(Counter bytesUsed) {
 this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(
   bytesUsed));
 pool.nextBuffer();
 bytesUsed.addAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER * Integer.BYTES);
 this.bytesUsed = bytesUsed;
}

public void add(int textStart) throws IOException {
 int termID = bytesHash.addByPoolOffset(textStart);
 if (termID >= 0) {      // New posting
  // First time we are seeing this token since we last
  // flushed the hash.
  // Init stream slices
  if (numPostingInt + intPool.intUpto > IntBlockPool.INT_BLOCK_SIZE) {
   intPool.nextBuffer();
  }
  if (ByteBlockPool.BYTE_BLOCK_SIZE - bytePool.byteUpto < numPostingInt*ByteBlockPool.FIRST_LEVEL_SIZE) {
   bytePool.nextBuffer();
  }
  intUptos = intPool.buffer;
  intUptoStart = intPool.intUpto;
  intPool.intUpto += streamCount;
  postingsArray.intStarts[termID] = intUptoStart + intPool.intOffset;
  for(int i=0;i<streamCount;i++) {
   final int upto = bytePool.newSlice(ByteBlockPool.FIRST_LEVEL_SIZE);
   intUptos[intUptoStart+i] = upto + bytePool.byteOffset;
  }
  postingsArray.byteStarts[termID] = intUptos[intUptoStart];
  newTerm(termID);
 } else {
  termID = (-termID)-1;
  int intStart = postingsArray.intStarts[termID];
  intUptos = intPool.buffers[intStart >> IntBlockPool.INT_BLOCK_SHIFT];
  intUptoStart = intStart & IntBlockPool.INT_BLOCK_MASK;
  addTerm(termID);
 }
}

Javadoc

Advances the pool to its next buffer. This method should be called once after the constructor to initialize the pool. In contrast to the constructor a ByteBlockPool#reset() call will advance the pool to its first buffer immediately.

Popular methods of ByteBlockPool

<init>
reset
Expert: Resets the pool to its initial state reusing the first buffer. Calling ByteBlockPool#nextBuf
allocSlice
Creates a new byte slice with the given starting size and returns the slices offset in the pool.
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

Reactive rest calls using spring rest template
onRequestPermissionsResult (Fragment)
getSharedPreferences (Context)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
FileReader (java.io)
A specialized Reader that reads from a file in the file system. All read requests made by calling me
HttpURLConnection (java.net)
An URLConnection for HTTP (RFC 2616 [http://tools.ietf.org/html/rfc2616]) used to send and receive d
Permission (java.security)
Legacy security code; do not use.
JButton (javax.swing)
14 Best Plugins for Eclipse

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

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

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