Creates a default empty composite buffer
Adds the given array into the composite buffer at the end. <p> The appended array is not copied so changes to the source array are visible in this buffer and vice versa. If this composite was empty than it would return true for the {@link #hasArray()} method until another array is appended. <p> Calling this method resets the limit to the new _capacity.
Adds the given composite buffer contents (from current position, up to the limit) into this composite buffer at the end. The source buffer position will be set to its limit. <p> The appended buffer contents are not copied wherever possible, so changes to the source arrays are typically visible in this buffer and vice versa. Exceptions include where the source buffer position is not located at the start of its current backing array, or where the given buffer has a limit that doesn't encompass all of the last array used, and so the remainder of that arrays contents must be copied first to append here. <p> Calling this method resets the limit to the new _capacity.
Adds the given readable buffer contents (from current position, up to the limit) into this composite buffer at the end. The source buffer position will be set to its limit. <p> The appended buffer contents are not copied wherever possible, so changes to the source arrays are typically visible in this buffer and vice versa. Exceptions are where the source buffer is not backed by an array, or where the source buffer position is not located at the start of its backing array, and so the remainder of the contents must be copied first to append here. <p> Calling this method resets the limit to the new _capacity.
Gets the current position index in the current backing array, which represents the current buffer position.
Compact the buffer dropping arrays that have been consumed by previous reads from this Composite buffer. The limit is reset to the new _capacity
Returns the capacity of the backing buffer of this ReadableBuffer @return the capacity of the backing buffer of this ReadableBuffer
Returns true if this ReadableBuffer is backed by an array which can be accessed by the {@link #array()} and {@link #arrayOffset()} methods.
Returns the primitive array that backs this buffer if one exists and the buffer is not read-only. The caller should have checked the {@link #hasArray()} method before calling this method.
Returns the offset into the backing array of the first element in the buffer. The caller should have checked the {@link #hasArray()} method before calling this method.
Compact the backing storage of this ReadableBuffer, possibly freeing previously-read portions of pooled data or reducing the number of backing arrays if present. <p> This is an optional operation and care should be taken in its implementation.
Reads the byte at the current position and advances the position by 1.
Reads the byte at the given index, the buffer position is not affected.
Reads four bytes from the buffer and returns them as an integer value. The buffer position is advanced by four byes.
Reads eight bytes from the buffer and returns them as an long value. The buffer position is advanced by eight byes.
Reads two bytes from the buffer and returns them as an short value. The buffer position is advanced by two byes.
Reads four bytes from the buffer and returns them as an float value. The buffer position is advanced by four byes.
Reads eight bytes from the buffer and returns them as an double value. The buffer position is advanced by eight byes.
A bulk read method that copies bytes from this buffer into the target byte array.
A bulk read method that copies bytes from this buffer into the target byte array.
Copy data from this buffer to the target buffer starting from the current position and continuing until either this buffer's remaining bytes are consumed or the target is full.
Creates a new ReadableBuffer instance that is a view of the readable portion of this buffer. The position will be set to zero and the limit and the reported capacity will match the value returned by this buffer's {@link #remaining()} method, the mark will be undefined.
Sets the buffer limit to the current position and the position is set to zero, the mark value reset to undefined.
Sets the current read limit of this buffer to the given value. If the buffer mark value is defined and is larger than the limit the mark will be discarded. If the position is larger than the new limit it will be reset to the new limit.
@return the current value of this buffer's limit.
Sets the current position of this buffer to the given value. If the buffer mark value is defined and is larger than the newly set position is must be discarded.
@return the current position from which the next read operation will start.
Mark the current position of this buffer which can be returned to after a read operation by calling {@link #reset()}.
Reset the buffer's position to a previously marked value, the mark should remain set after calling this method.
Resets the buffer position to zero and clears and previously set mark.
Resets the buffer position to zero and sets the limit to the buffer capacity, the mark value is discarded if set.
@return the remaining number of readable bytes in this buffer.
@return true if there are readable bytes still remaining in this buffer.
Creates a duplicate {@link ReadableBuffer} to this instance. <p> The duplicated buffer will have the same position, limit and mark as this buffer. The two buffers share the same backing data.
@return a ByteBuffer view of the current readable portion of this buffer.
Reads a UTF-8 encoded String from the buffer starting the decode at the current position and reading until the limit is reached. The position is advanced to the limit once this method returns. If there is no bytes remaining in the buffer when this method is called a null is returned.
Decodes a String from the buffer using the provided {@link CharsetDecoder} starting the decode at the current position and reading until the limit is reached. The position is advanced to the limit once this method returns. If there is no bytes remaining in the buffer when this method is called a null is returned.
ReadableBuffer implementation whose content is made up of one or more byte arrays.