public final class BuffersBuffer extends CompositeBuffer
CompositeBuffer.BulkOperation, CompositeBuffer.DisposeOrder, CompositeBuffer.Setter
disposeOrder
Modifier | Constructor and Description |
---|---|
protected |
BuffersBuffer(MemoryManager memoryManager,
Buffer[] buffers,
int buffersSize,
boolean isReadOnly) |
Modifier and Type | Method and Description |
---|---|
boolean |
allowBufferDispose() |
void |
allowBufferDispose(boolean allow) |
boolean |
allowInternalBuffersDispose() |
void |
allowInternalBuffersDispose(boolean allowInternalBuffersDispose) |
BuffersBuffer |
append(Buffer buffer) |
byte[] |
array()
Returns the byte array that backs this buffer (optional operation).
|
int |
arrayOffset()
Returns the offset within this buffer's backing array of the first
element of the buffer (optional operation).
|
BuffersBuffer |
asReadOnlyBuffer()
Creates a new, read-only
Buffer that shares this buffer's
content. |
int |
bulk(CompositeBuffer.BulkOperation operation)
Iterates over
Buffer bytes from Buffer.position() to Buffer.limit()
and lets CompositeBuffer.BulkOperation examine/change the buffer content; |
int |
bulk(CompositeBuffer.BulkOperation operation,
int position,
int limit)
Iterates over
Buffer bytes from position to limit
and lets CompositeBuffer.BulkOperation examine/change the buffer content; |
int |
capacity()
Returns this buffer's capacity.
|
BuffersBuffer |
clear()
Clears this buffer.
|
BuffersBuffer |
compact()
Compacts this buffer (optional operation).
|
int |
compareTo(Buffer that) |
static BuffersBuffer |
create()
Construct BuffersBuffer.
|
static BuffersBuffer |
create(MemoryManager memoryManager) |
static BuffersBuffer |
create(MemoryManager memoryManager,
Buffer... buffers) |
static BuffersBuffer |
create(MemoryManager memoryManager,
Buffer[] buffers,
boolean isReadOnly) |
void |
dispose()
Notify the allocator that the space for this Buffer is no
longer needed.
|
BuffersBuffer |
duplicate()
Creates a new
Buffer that shares this buffer's content. |
boolean |
equals(Object obj) |
BuffersBuffer |
flip()
Flips this buffer.
|
byte |
get()
Relative get method.
|
BuffersBuffer |
get(byte[] dst)
Relative bulk get method.
|
BuffersBuffer |
get(byte[] dst,
int offset,
int length)
Relative bulk get method.
|
BuffersBuffer |
get(ByteBuffer dst)
Relative bulk get method.
|
BuffersBuffer |
get(ByteBuffer dst,
int offset,
int length)
Relative bulk get method.
|
byte |
get(int index)
Absolute get method.
|
char |
getChar()
Relative get method for reading a char value.
|
char |
getChar(int index)
Absolute get method for reading a char value.
|
double |
getDouble()
Relative get method for reading a double value.
|
double |
getDouble(int index)
Absolute get method for reading a double value.
|
float |
getFloat()
Relative get method for reading a float value.
|
float |
getFloat(int index)
Absolute get method for reading a float value.
|
int |
getInt()
Relative get method for reading an int value.
|
int |
getInt(int index)
Absolute get method for reading an int value.
|
long |
getLong()
Relative get method for reading a long value.
|
long |
getLong(int index)
Absolute get method for reading a long value.
|
short |
getShort()
Relative get method for reading a short value.
|
short |
getShort(int index)
Absolute get method for reading a short value.
|
boolean |
hasArray()
Tells whether or not this buffer is backed by an accessible byte array.
|
int |
hashCode()
Returns the current hash code of this buffer.
|
boolean |
hasRemaining()
Tells whether there are any elements between the current position and
the limit.
|
boolean |
isComposite() |
boolean |
isDirect()
Tells whether or not this buffer is
direct.
|
boolean |
isExternal()
Returns true if the message represents an external resource
(for example
FileTransfer ),
which is not loaded in memory. |
boolean |
isReadOnly()
Tells whether or not this buffer is read-only.
|
int |
limit()
Returns this buffer's limit.
|
BuffersBuffer |
limit(int newLimit)
Sets this buffer's limit.
|
BuffersBuffer |
mark()
Sets this buffer's mark at its position.
|
ByteOrder |
order()
Retrieves this buffer's byte order.
|
BuffersBuffer |
order(ByteOrder bo)
Modifies this buffer's byte order.
|
int |
position()
Returns this buffer's position.
|
BuffersBuffer |
position(int newPosition)
Sets this buffer's position.
|
BuffersBuffer |
prepend(Buffer buffer)
Prepend data from header.position() to header.limit() to the
current buffer.
|
BuffersBuffer |
put(Buffer src)
Relative bulk put method (optional operation).
|
Buffer |
put(Buffer src,
int position,
int length)
Relative bulk put method (optional operation).
|
BuffersBuffer |
put(byte b)
Relative put method (optional operation).
|
BuffersBuffer |
put(byte[] src)
Relative bulk put method (optional operation).
|
BuffersBuffer |
put(byte[] src,
int offset,
int length)
Relative bulk put method (optional operation).
|
BuffersBuffer |
put(ByteBuffer src)
Relative bulk put method (optional operation).
|
BuffersBuffer |
put(ByteBuffer src,
int offset,
int length)
Relative bulk put method (optional operation).
|
BuffersBuffer |
put(int index,
byte b)
Absolute put method (optional operation).
|
BuffersBuffer |
put8BitString(String s)
Relative bulk put method (optional operation).
|
BuffersBuffer |
putChar(char value)
Relative put method for writing a char
value (optional operation).
|
BuffersBuffer |
putChar(int index,
char value)
Absolute put method for writing a char
value (optional operation).
|
BuffersBuffer |
putDouble(double value)
Relative put method for writing a double
value (optional operation).
|
BuffersBuffer |
putDouble(int index,
double value)
Absolute put method for writing a double
value (optional operation).
|
BuffersBuffer |
putFloat(float value)
Relative put method for writing a float
value (optional operation).
|
BuffersBuffer |
putFloat(int index,
float value)
Absolute put method for writing a float
value (optional operation).
|
BuffersBuffer |
putInt(int value)
Relative put method for writing an int
value (optional operation).
|
BuffersBuffer |
putInt(int index,
int value)
Absolute put method for writing an int
value (optional operation).
|
BuffersBuffer |
putLong(int index,
long value)
Absolute put method for writing a long
value (optional operation).
|
BuffersBuffer |
putLong(long value)
Relative put method for writing a long
value (optional operation).
|
BuffersBuffer |
putShort(int index,
short value)
Absolute put method for writing a short
value (optional operation).
|
BuffersBuffer |
putShort(short value)
Relative put method for writing a short
value (optional operation).
|
boolean |
release()
Perform message specific actions to release resources held by the
entity backing this
WritableMessage . |
int |
remaining()
Returns the number of elements between the current position and the
limit.
|
void |
removeAll()
Removes underlying
Buffer s, without disposing |
protected int |
removeRightBuffers(int startIndex) |
boolean |
replace(Buffer oldBuffer,
Buffer newBuffer)
Replace one internal
Buffer with another one. |
BuffersBuffer |
reset()
Resets this buffer's position to the previously-marked position.
|
BuffersBuffer |
rewind()
Rewinds this buffer.
|
void |
shrink()
Disposes the buffer part, outside [position, limit] interval if possible.
|
Buffer |
slice()
Creates a new
Buffer whose content is a shared subsequence
of this buffer's content. |
Buffer |
slice(int position,
int limit)
Creates a new
Buffer whose content is a shared subsequence of
this buffer's content. |
Buffer |
split(int splitPosition)
Split up the buffer into two parts: [0..splitPosition) and [splitPosition, capacity).
|
BufferArray |
toBufferArray()
|
BufferArray |
toBufferArray(BufferArray array)
Returns the specified
BufferArray after adding this Buffer . |
BufferArray |
toBufferArray(BufferArray array,
int position,
int limit)
|
BufferArray |
toBufferArray(int position,
int limit)
|
ByteBuffer |
toByteBuffer()
Converts this
Buffer to a ByteBuffer . |
ByteBuffer |
toByteBuffer(int position,
int limit)
Converts this
Buffer to a ByteBuffer . |
ByteBufferArray |
toByteBufferArray()
Converts this
Buffer to a ByteBuffer per Buffer.toByteBuffer()
and returns a ByteBufferArray containing the converted ByteBuffer . |
ByteBufferArray |
toByteBufferArray(ByteBufferArray array)
Converts this
Buffer to a ByteBuffer per Buffer.toByteBuffer()
and adds the result to the provided ByteBufferArray . |
ByteBufferArray |
toByteBufferArray(ByteBufferArray array,
int position,
int limit)
Converts this
Buffer to a ByteBuffer per Buffer.toByteBuffer(int, int)
and adds the result to the provided ByteBufferArray . |
ByteBufferArray |
toByteBufferArray(int position,
int limit)
Converts this
Buffer to a ByteBuffer per Buffer.toByteBuffer(int, int)
and returns a ByteBufferArray containing the converted ByteBuffer . |
String |
toString() |
String |
toStringContent()
|
String |
toStringContent(Charset charset)
|
String |
toStringContent(Charset charset,
int position,
int limit)
|
void |
trim()
Trim the buffer by reducing capacity to position, if possible.
|
boolean |
tryDispose()
Try to dispose Buffer if it's allowed.
|
Buffer[] |
underlying()
Return the underlying buffer
|
disposeOrder, disposeOrder, newBuffer, newBuffer, newBuffer, newBuffer
protected BuffersBuffer(MemoryManager memoryManager, Buffer[] buffers, int buffersSize, boolean isReadOnly)
public static BuffersBuffer create()
public static BuffersBuffer create(MemoryManager memoryManager)
public static BuffersBuffer create(MemoryManager memoryManager, Buffer... buffers)
public static BuffersBuffer create(MemoryManager memoryManager, Buffer[] buffers, boolean isReadOnly)
public final boolean tryDispose()
Buffer
public void dispose()
Buffer
public final boolean isComposite()
public BuffersBuffer append(Buffer buffer)
public BuffersBuffer prepend(Buffer buffer)
Buffer
prepend
in interface Buffer
prepend
in class CompositeBuffer
public boolean replace(Buffer oldBuffer, Buffer newBuffer)
CompositeBuffer
Buffer
with another one.replace
in class CompositeBuffer
oldBuffer
- the Buffer
to replace.newBuffer
- the new Buffer
.public Buffer[] underlying()
Buffer
underlying
in interface Buffer
underlying
in class CompositeBuffer
public int position()
Buffer
public BuffersBuffer position(int newPosition)
Buffer
newPosition
- The new position value; must be non-negative
and no larger than the current limitpublic int limit()
Buffer
public BuffersBuffer limit(int newLimit)
Buffer
newLimit
- The new limit value; must be non-negative
and no larger than this buffer's capacitypublic int capacity()
Buffer
public BuffersBuffer mark()
Buffer
public BuffersBuffer reset()
Buffer
Invoking this method neither changes nor discards the mark's value.
public boolean isDirect()
Buffer
public BuffersBuffer clear()
Buffer
Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example:
buf.clear(); // Prepare buffer for reading in.read(buf); // Read data
This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case.
public BuffersBuffer flip()
Buffer
After a sequence of channel-read or put operations, invoke this method to prepare for a sequence of channel-write or relative get operations. For example:
buf.put(magic); // Prepend header in.read(buf); // Read data into rest of buffer buf.flip(); // Flip buffer out.write(buf); // Write header + data to channel
This method is often used in conjunction with the
compact
method when transferring data from
one place to another.
public BuffersBuffer rewind()
Buffer
Invoke this method before a sequence of channel-write or get operations, assuming that the limit has already been set appropriately. For example:
out.write(buf); // Write remaining data buf.rewind(); // Rewind buffer buf.get(array); // Copy data into array
public int remaining()
Buffer
public boolean hasRemaining()
Buffer
public boolean isReadOnly()
Buffer
public BuffersBuffer asReadOnlyBuffer()
Buffer
Buffer
that shares this buffer's
content.
The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer; the new buffer itself, however, will be read-only and will not allow the shared content to be modified. The two buffer's position, limit, and mark values will be independent.
The new buffer's capacity, limit, position, and mark values will be identical to those of this buffer.
If this buffer is itself read-only then this method behaves in
exactly the same way as the duplicate
method.
Buffer
public Buffer split(int splitPosition)
Buffer
splitPosition
- position of split.public void shrink()
Buffer
public void trim()
Buffer
protected int removeRightBuffers(int startIndex)
public Buffer slice()
Buffer
Buffer
whose content is a shared subsequence
of this buffer's content.
The content of the new buffer will start at this buffer's current position. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffers' position, limit, and mark values will be independent.
The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
Buffer
public Buffer slice(int position, int limit)
Buffer
Buffer
whose content is a shared subsequence of
this buffer's content.
The content of the new buffer will start at passed position and end at passed limit. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffer's position, limit, and mark values will be independent.
The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer, and its mark will be undefined. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
Buffer
public BuffersBuffer duplicate()
Buffer
Buffer
that shares this buffer's content.
The content of the new buffer will be that of this buffer. Changes to this buffer's content will be visible in the new buffer, and vice versa; the two buffer's position, limit, and mark values will be independent.
The new buffer's capacity, limit, position, and mark values will be identical to those of this buffer. The new buffer will be direct if, and only if, this buffer is direct, and it will be read-only if, and only if, this buffer is read-only.
Buffer
public BuffersBuffer compact()
Buffer
The bytes between the buffer's current position and its limit, if any, are copied to the beginning of the buffer. That is, the byte at index p = position() is copied to index zero, the byte at index p + 1 is copied to index one, and so forth until the byte at index limit() - 1 is copied to index n = limit() - 1 - p. The buffer's position is then set to n+1 and its limit is set to its capacity. The mark, if defined, is discarded.
The buffer's position is set to the number of bytes copied, rather than to zero, so that an invocation of this method can be followed immediately by an invocation of another relative put method.
Invoke this method after writing data from a buffer in case the write was incomplete. The following loop, for example, copies bytes from one channel to another via the buffer buf:
buf.clear(); // Prepare buffer for use for (;;) { if (in.read(buf) < 0 && !buf.hasRemaining()) break; // No more bytes to transfer buf.flip(); out.write(buf); buf.compact(); // In case of partial write }
public ByteOrder order()
Buffer
The byte order is used when reading or writing multibyte values, and
when creating buffers that are views of this Buffer
. The order of
a newly-created Buffer
is always BIG_ENDIAN
.
public BuffersBuffer order(ByteOrder bo)
Buffer
bo
- The new byte order,
either BIG_ENDIAN
or LITTLE_ENDIAN
public boolean allowBufferDispose()
public void allowBufferDispose(boolean allow)
public boolean allowInternalBuffersDispose()
allowInternalBuffersDispose
in class CompositeBuffer
public void allowInternalBuffersDispose(boolean allowInternalBuffersDispose)
allowInternalBuffersDispose
in class CompositeBuffer
public byte get()
Buffer
public BuffersBuffer put(byte b)
Buffer
Writes the given byte into this buffer at the current position, and then increments the position.
b
- The byte to be writtenpublic byte get(int index)
Buffer
index
- The index from which the byte will be readpublic BuffersBuffer put(int index, byte b)
Buffer
Writes the given byte into this buffer at the given index.
index
- The index at which the byte will be writtenb
- The byte value to be writtenpublic BuffersBuffer get(byte[] dst)
Buffer
This method transfers bytes from this buffer into the given destination array. An invocation of this method of the form src.get(a) behaves in exactly the same way as the invocation
src.get(a, 0, a.length)
public BuffersBuffer get(byte[] dst, int offset, int length)
Buffer
This method transfers bytes from this buffer into the given
destination array. If there are fewer bytes remaining in the
buffer than are required to satisfy the request, that is, if
length > remaining(), then no
bytes are transferred and a BufferUnderflowException
is
thrown.
Otherwise, this method copies length bytes from this buffer into the given array, starting at the current position of this buffer and at the given offset in the array. The position of this buffer is then incremented by length.
In other words, an invocation of this method of the form src.get(dst, off, len) has exactly the same effect as the loop
for (int i = off; i < off + len; i++) dst[i] = src.get();except that it first checks that there are sufficient bytes in this buffer and it is potentially much more efficient.
dst
- The array into which bytes are to be writtenoffset
- The offset within the array of the first byte to be
written; must be non-negative and no larger than
dst.lengthlength
- The maximum number of bytes to be written to the given
array; must be non-negative and no larger than
dst.length - offsetpublic BuffersBuffer put(byte[] src)
Buffer
This method transfers the entire content of the given source byte array into this buffer. An invocation of this method of the form dst.put(a) behaves in exactly the same way as the invocation
dst.put(a, 0, a.length)
public BuffersBuffer put(byte[] src, int offset, int length)
Buffer
This method transfers bytes into this buffer from the given
source array. If there are more bytes to be copied from the array
than remain in this buffer, that is, if
length > remaining(), then no
bytes are transferred and a BufferOverflowException
is
thrown.
Otherwise, this method copies length bytes from the given array into this buffer, starting at the given offset in the array and at the current position of this buffer. The position of this buffer is then incremented by length.
In other words, an invocation of this method of the form dst.put(src, off, len) has exactly the same effect as the loop
for (int i = off; i < off + len; i++) dst.put(a[i]);except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The array from which bytes are to be readoffset
- The offset within the array of the first byte to be read;
must be non-negative and no larger than array.lengthlength
- The number of bytes to be read from the given array;
must be non-negative and no larger than
array.length - offsetpublic BuffersBuffer put8BitString(String s)
Buffer
This method transfers bytes into this buffer from the given
8-bit source String
. If the source String.length()
is
bigger than this buffer's remaining, that is, if
length() > remaining(), then no
bytes are transferred and a BufferOverflowException
is
thrown.
Otherwise, this method copies length bytes from the
given String
into this buffer.
In other words, an invocation of this method of the form dst.put(src) has exactly the same effect as the loop
for (int i = 0; i < s.length(); i++) dst.put((byte) s.charAt(i));except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
s
- The String
from which bytes are to be readpublic BuffersBuffer get(ByteBuffer dst)
Buffer
This method transfers bytes from this buffer into the given
destination ByteBuffer
. An invocation of this method of the form
src.get(a) behaves in exactly the same way as the invocation
src.get(a, 0, a.remaining())
public BuffersBuffer get(ByteBuffer dst, int offset, int length)
Buffer
This method transfers bytes from this buffer into the given
destination ByteBuffer
. If there are fewer bytes remaining in the
buffer than are required to satisfy the request, that is, if
length > remaining(), then no
bytes are transferred and a BufferUnderflowException
is
thrown.
Otherwise, this method copies length bytes from this
buffer into the given ByteBuffer
, starting at the current position of this
buffer and at the given offset in the ByteBuffer
. The position of this
buffer is then incremented by length.
In other words, an invocation of this method of the form src.get(dst, off, len) has exactly the same effect as the loop
for (int i = off; i < off + len; i++) dst.put(i) = src.get();except that it first checks that there are sufficient bytes in this buffer and it is potentially much more efficient.
dst
- The ByteBuffer
into which bytes are to be writtenoffset
- The offset within the ByteBuffer
of the first byte to be
written; must be non-negative and no larger than
dst.remaining()length
- The maximum number of bytes to be written to the given
array; must be non-negative and no larger than
dst.remaining() - offsetpublic BuffersBuffer put(ByteBuffer src)
Buffer
This method transfers the bytes remaining in the given source
buffer into this buffer. If there are more bytes remaining in the
source buffer than in this buffer, that is, if
src.remaining() > remaining(),
then no bytes are transferred and a BufferOverflowException
is thrown.
Otherwise, this method copies n = src.remaining() bytes from the given buffer into this buffer, starting at each buffer's current position. The positions of both buffers are then incremented by n.
In other words, an invocation of this method of the form dst.put(src) has exactly the same effect as the loop
while (src.hasRemaining()) dst.put(src.get());except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The source buffer from which bytes are to be read;
must not be this bufferpublic BuffersBuffer put(ByteBuffer src, int offset, int length)
Buffer
This method transfers the "length" bytes from the given source
buffer into this buffer. If this buffer has less bytes remaining than
length, that is, if
length > remaining(),
then no bytes are transferred and a BufferOverflowException
is thrown.
Otherwise, this method copies n = length bytes from the given postion in the source buffer into this buffer, starting from the current buffer position. The positions of this buffer is then incremented by length.
In other words, an invocation of this method of the form dst.put(src, position, length) has exactly the same effect as the loop
for (int i = 0; i < length; i++) dst.put(src.get(i + position));except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The source buffer from which bytes are to be read;
must not be this bufferoffset
- starting position in the source bufferlength
- number of bytes to be copiedpublic BuffersBuffer put(Buffer src)
Buffer
This method transfers the bytes remaining in the given source
buffer into this buffer. If there are more bytes remaining in the
source buffer than in this buffer, that is, if
src.remaining() > remaining(),
then no bytes are transferred and a BufferOverflowException
is thrown.
Otherwise, this method copies n = src.remaining() bytes from the given buffer into this buffer, starting at each buffer's current position. The positions of both buffers are then incremented by n.
In other words, an invocation of this method of the form dst.put(src) has exactly the same effect as the loop
while (src.hasRemaining()) dst.put(src.get());except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The source buffer from which bytes are to be read;
must not be this bufferpublic Buffer put(Buffer src, int position, int length)
Buffer
This method transfers the "length" bytes from the given source
buffer into this buffer. If this buffer has less bytes remaining than
length, that is, if
length > remaining(),
then no bytes are transferred and a BufferOverflowException
is thrown.
Otherwise, this method copies n = length bytes from the given postion in the source buffer into this buffer, starting from the current buffer position. The positions of this buffer is then incremented by length.
In other words, an invocation of this method of the form dst.put(src, position, length) has exactly the same effect as the loop
for (int i = 0; i < length; i++) dst.put(src.get(i + position));except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
src
- The source buffer from which bytes are to be read;
must not be this bufferposition
- starting position in the source bufferlength
- number of bytes to be copiedpublic char getChar()
Buffer
Reads the next two bytes at this buffer's current position, composing them into a char value according to the current byte order, and then increments the position by two.
public BuffersBuffer putChar(char value)
Buffer
Writes two bytes containing the given char value, in the current byte order, into this buffer at the current position, and then increments the position by two.
value
- The char value to be writtenpublic char getChar(int index)
Buffer
Reads two bytes at the given index, composing them into a char value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putChar(int index, char value)
Buffer
Writes two bytes containing the given char value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The char value to be writtenpublic short getShort()
Buffer
Reads the next two bytes at this buffer's current position, composing them into a short value according to the current byte order, and then increments the position by two.
public BuffersBuffer putShort(short value)
Buffer
Writes two bytes containing the given short value, in the current byte order, into this buffer at the current position, and then increments the position by two.
value
- The short value to be writtenpublic short getShort(int index)
Buffer
Reads two bytes at the given index, composing them into a short value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putShort(int index, short value)
Buffer
Writes two bytes containing the given short value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The short value to be writtenpublic int getInt()
Buffer
Reads the next four bytes at this buffer's current position, composing them into an int value according to the current byte order, and then increments the position by four.
public BuffersBuffer putInt(int value)
Buffer
Writes four bytes containing the given int value, in the current byte order, into this buffer at the current position, and then increments the position by four.
value
- The int value to be writtenpublic int getInt(int index)
Buffer
Reads four bytes at the given index, composing them into a int value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putInt(int index, int value)
Buffer
Writes four bytes containing the given int value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The int value to be writtenpublic long getLong()
Buffer
Reads the next eight bytes at this buffer's current position, composing them into a long value according to the current byte order, and then increments the position by eight.
public BuffersBuffer putLong(long value)
Buffer
Writes eight bytes containing the given long value, in the current byte order, into this buffer at the current position, and then increments the position by eight.
value
- The long value to be writtenpublic long getLong(int index)
Buffer
Reads eight bytes at the given index, composing them into a long value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putLong(int index, long value)
Buffer
Writes eight bytes containing the given long value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The long value to be writtenpublic float getFloat()
Buffer
Reads the next four bytes at this buffer's current position, composing them into a float value according to the current byte order, and then increments the position by four.
public BuffersBuffer putFloat(float value)
Buffer
Writes four bytes containing the given float value, in the current byte order, into this buffer at the current position, and then increments the position by four.
value
- The float value to be writtenpublic float getFloat(int index)
Buffer
Reads four bytes at the given index, composing them into a float value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putFloat(int index, float value)
Buffer
Writes four bytes containing the given float value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The float value to be writtenpublic double getDouble()
Buffer
Reads the next eight bytes at this buffer's current position, composing them into a double value according to the current byte order, and then increments the position by eight.
public BuffersBuffer putDouble(double value)
Buffer
Writes eight bytes containing the given double value, in the current byte order, into this buffer at the current position, and then increments the position by eight.
value
- The double value to be writtenpublic double getDouble(int index)
Buffer
Reads eight bytes at the given index, composing them into a double value according to the current byte order.
index
- The index from which the bytes will be readpublic BuffersBuffer putDouble(int index, double value)
Buffer
Writes eight bytes containing the given double value, in the current byte order, into this buffer at the given index.
index
- The index at which the bytes will be writtenvalue
- The double value to be writtenpublic int bulk(CompositeBuffer.BulkOperation operation)
Buffer
bytes from Buffer.position()
to Buffer.limit()
and lets CompositeBuffer.BulkOperation
examine/change the buffer content;bulk
in class CompositeBuffer
operation
- CompositeBuffer.BulkOperation
public int bulk(CompositeBuffer.BulkOperation operation, int position, int limit)
Buffer
bytes from position to limit
and lets CompositeBuffer.BulkOperation
examine/change the buffer content;bulk
in class CompositeBuffer
operation
- CompositeBuffer.BulkOperation
public int compareTo(Buffer that)
public String toStringContent(Charset charset)
Buffer
public String toStringContent(Charset charset, int position, int limit)
Buffer
public ByteBuffer toByteBuffer()
Buffer
Converts this Buffer
to a ByteBuffer
.
If this Buffer
is not composite - then returned
ByteBuffer
's content is a shared subsequence of this buffer's
content, with CompositeBuffer
this is not guaranteed.
The position of the returned ByteBuffer
is not guaranteed to be 0,
the capacity of the returned ByteBuffer
is not guaranteed to be
equal to the capacity of this Buffer
.
It is guaranteed that the result of the returned ByteBuffer's
Buffer.remaining()
call will be equal to this Buffer's
Buffer.remaining()
call.
The Buffer's and ByteBuffer's position, limit, and mark values are not
guaranteed to be independent, so it's recommended to save and restore
position, limit values if it is planned to change them or
ByteBuffer.slice()
the returned ByteBuffer
.
Buffer
as a ByteBuffer
.public ByteBuffer toByteBuffer(int position, int limit)
Buffer
Converts this Buffer
to a ByteBuffer
.
If this Buffer
is not composite - then returned
ByteBuffer
's content is a shared subsequence of this buffer's
content, with CompositeBuffer
this is not guaranteed.
The position of the returned ByteBuffer
is not guaranteed to be 0,
the capacity of the returned ByteBuffer
is not guaranteed to be
equal to the capacity of this Buffer
.
It is guaranteed that the result of the returned ByteBuffer's
Buffer.remaining()
call will be equal (limit - position).
The Buffer's and ByteBuffer's position, limit, and mark values are not
guaranteed to be independent, so it's recommended to save and restore
position, limit values if it is planned to change them or
ByteBuffer.slice()
the returned ByteBuffer
.
position
- the position for the starting subsequence for the
returned ByteBuffer
.limit
- the limit for the ending of the subsequence of the
returned ByteBuffer
.Buffer
as a ByteBuffer
.public final ByteBufferArray toByteBufferArray()
Buffer
Converts this Buffer
to a ByteBuffer
per Buffer.toByteBuffer()
and returns a ByteBufferArray
containing the converted ByteBuffer
.
It is guaranteed that returned array's ByteBuffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
Buffer
to a ByteBuffer
per Buffer.toByteBuffer()
and returns a ByteBufferArray
containing the converted ByteBuffer
.#toByteBuffer()}
public final ByteBufferArray toByteBufferArray(ByteBufferArray array)
Buffer
Converts this Buffer
to a ByteBuffer
per Buffer.toByteBuffer()
and adds the result to the provided ByteBufferArray
.
It is guaranteed that returned array's ByteBuffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
ByteBufferArray
with the converted
ByteBuffer
added to provided array
.#toByteBuffer()}
public final ByteBufferArray toByteBufferArray(int position, int limit)
Buffer
Converts this Buffer
to a ByteBuffer
per Buffer.toByteBuffer(int, int)
and returns a ByteBufferArray
containing the converted ByteBuffer
.
It is guaranteed that returned array's ByteBuffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
position
- the start position within the source buffer
limit
- the limit, or number, of bytes to include in the resulting
ByteBuffer
Buffer
to a ByteBuffer
per Buffer.toByteBuffer(int, int)
and returns a ByteBufferArray
containing the converted ByteBuffer
.#toByteBuffer(int, int)}
public final ByteBufferArray toByteBufferArray(ByteBufferArray array, int position, int limit)
Buffer
Converts this Buffer
to a ByteBuffer
per Buffer.toByteBuffer(int, int)
and adds the result to the provided ByteBufferArray
.
It is guaranteed that returned array's ByteBuffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
ByteBufferArray
with the converted
ByteBuffer
added to provided array
.#toByteBuffer(int, int)}
public final BufferArray toBufferArray()
Buffer
Returns a new BufferArray
instance with this Buffer
added as an element to the BufferArray
.
It is guaranteed that returned array's Buffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
BufferArray
instance with this Buffer
added as an element to the BufferArray
.public final BufferArray toBufferArray(BufferArray array)
Buffer
Returns the specified BufferArray
after adding this Buffer
.
It is guaranteed that returned array's Buffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
BufferArray
after adding this Buffer
.public final BufferArray toBufferArray(int position, int limit)
Buffer
Updates this Buffer
's position
and limit
and adds it to a new BufferArray
instance.
It is guaranteed that returned array's Buffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
position
- the new position for this Buffer
limit
- the new limit for this Buffer
Buffer
and returns the specified
BufferArray
.public final BufferArray toBufferArray(BufferArray array, int position, int limit)
Buffer
Updates this Buffer
's position
and limit
and adds it to the specified BufferArray
.
It is guaranteed that returned array's Buffer elements' content is
a shared subsequence of this buffer's content no matter if it's a
CompositeBuffer
or not.
position
- the new position for this Buffer
limit
- the new limit for this Buffer
Buffer
and returns the specified
BufferArray
.public void removeAll()
CompositeBuffer
Buffer
s, without disposingremoveAll
in class CompositeBuffer
public boolean hasArray()
Buffer
public byte[] array()
Buffer
public int arrayOffset()
Buffer
public int hashCode()
The hash code of a byte buffer depends only upon its remaining elements; that is, upon the elements from position() up to, and including, the element at limit() - 1.
Because buffer hash codes are content-dependent, it is inadvisable to use buffers as keys in hash maps or similar data structures unless it is known that their contents will not change.
public boolean release()
WritableMessage
WritableMessage
.public boolean isExternal()
FileTransfer
),
which is not loaded in memory.
False, if the message is
located in memory (like Buffer
).Copyright © 2014 Oracle Corporation. All rights reserved.