com.sun.grizzly.Buffer Maven / Gradle / Ivy
/*
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2007-2008 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*
*/
package com.sun.grizzly;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
/**
* JDK {@link java.nio.ByteBuffer} was taken as base for Grizzly
* Buffer interface, but Buffer has several extensions:
* it's possible to prepend some data to a Buffer and release Buffer, when
* it's not required any more.
*
* @author Alexey Stashok
*/
public interface Buffer extends Comparable> {
/**
* Prepend data from header.position() to header.limit() to the
* current buffer. This will change the value returned by buffer()!
* @throws IllegalArgumentException if header.limit() - header.position()
* is greater than headerSize.
*/
public K prepend(final K header);
/**
* Trim the buffer by reducing capacity to position, if possible.
* May return without changing capacity. Also resets the position to 0,
* like reset().
*/
public void trim();
/**
* Notify the allocator that the space for this Buffer is no
* longer needed. All calls to methods on a Buffer
* will fail after a call to dispose().
*/
public void dispose();
/**
* Return the JDK underlying buffer
*
* @return the JDK underlying buffer
*/
public K underlying();
/**
* Returns this buffer's capacity.
*
* @return The capacity of this buffer
*/
public int capacity();
/**
* Returns this buffer's position.
*
* @return The position of this buffer
*/
public int position();
/**
* Sets this buffer's position. If the mark is defined and larger than the
* new position then it is discarded.
*
* @param newPosition
* The new position value; must be non-negative
* and no larger than the current limit
*
* @return This buffer
*
* @throws IllegalArgumentException
* If the preconditions on newPosition do not hold
*/
public Buffer position(int newPosition);
/**
* Returns this buffer's limit.
*
* @return The limit of this buffer
*/
public int limit();
/**
* Sets this buffer's limit. If the position is larger than the new limit
* then it is set to the new limit. If the mark is defined and larger than
* the new limit then it is discarded.
*
* @param newLimit
* The new limit value; must be non-negative
* and no larger than this buffer's capacity
*
* @return This buffer
*
* @throws IllegalArgumentException
* If the preconditions on newLimit do not hold
*/
public Buffer limit(int newLimit);
/**
* Sets this buffer's mark at its position.
*
* @return This buffer
*/
public Buffer mark();
/**
* Resets this buffer's position to the previously-marked position.
*
* Invoking this method neither changes nor discards the mark's
* value.
*
* @return This buffer
*
* @throws InvalidMarkException
* If the mark has not been set
*/
public Buffer reset();
/**
* Clears this buffer. The position is set to zero, the limit is set to
* the capacity, and the mark is discarded.
*
* 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.
*
* @return This buffer
*/
public Buffer clear();
/**
* Flips this buffer. The limit is set to the current position and then
* the position is set to zero. If the mark is defined then it is
* discarded.
*
* 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
* {@link Buffer#compact compact} method when transferring data from
* one place to another.
*
* @return This buffer
*/
public Buffer flip();
/**
* Rewinds this buffer. The position is set to zero and the mark is
* discarded.
*
* 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
*
* @return This buffer
*/
public Buffer rewind();
/**
* Returns the number of elements between the current position and the
* limit.
*
* @return The number of elements remaining in this buffer
*/
public int remaining();
/**
* Tells whether there are any elements between the current position and
* the limit.
*
* @return true if, and only if, there is at least one element
* remaining in this buffer
*/
public boolean hasRemaining();
/**
* Tells whether or not this buffer is read-only.
*
* @return true if, and only if, this buffer is read-only
*/
public boolean isReadOnly();
/**
* Creates a new byte 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.
*
* @return The new byte buffer
*/
public Buffer slice();
/**
* Creates a new byte 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 buffers' 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.
*
* @return The new byte buffer
*/
public Buffer duplicate();
/**
* Creates a new, read-only byte 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 buffers' 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 {@link #duplicate duplicate} method.
*
* @return The new, read-only byte buffer
*/
public Buffer asReadOnlyBuffer();
// -- Singleton get/put methods --
/**
* Relative get method. Reads the byte at this buffer's
* current position, and then increments the position.
*
* @return The byte at the buffer's current position
*
* @throws BufferUnderflowException
* If the buffer's current position is not smaller than its limit
*/
public byte get();
/**
* Relative put method (optional operation).
*
* Writes the given byte into this buffer at the current
* position, and then increments the position.
*
* @param b
* The byte to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If this buffer's current position is not smaller than its limit
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer put(byte b);
/**
* Absolute get method. Reads the byte at the given
* index.
*
* @param index
* The index from which the byte will be read
*
* @return The byte at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit
*/
public byte get(int index);
/**
* Absolute put method (optional operation).
*
* Writes the given byte into this buffer at the given
* index.
*
* @param index
* The index at which the byte will be written
*
* @param b
* The byte value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer put(int index, byte b);
// -- Bulk get operations --
/**
* Relative bulk get method.
*
* 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 {@link 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.
*
* @param dst
* The array into which bytes are to be written
*
* @param offset
* The offset within the array of the first byte to be
* written; must be non-negative and no larger than
* dst.length
*
* @param length
* The maximum number of bytes to be written to the given
* array; must be non-negative and no larger than
* dst.length - offset
*
* @return This buffer
*
* @throws BufferUnderflowException
* If there are fewer than length bytes
* remaining in this buffer
*
* @throws IndexOutOfBoundsException
* If the preconditions on the offset and length
* parameters do not hold
*/
public Buffer get(byte[] dst, int offset, int length);
/**
* Relative bulk get method.
*
* 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)
*
* @return This buffer
*
* @throws BufferUnderflowException
* If there are fewer than length bytes
* remaining in this buffer
*/
public Buffer get(byte[] dst);
// -- Bulk put operations --
/**
* Relative bulk put method (optional operation).
*
* 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 {@link
* 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.
*
* @param src
* The source buffer from which bytes are to be read;
* must not be this buffer
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
* for the remaining bytes in the source buffer
*
* @throws IllegalArgumentException
* If the source buffer is this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer put(Buffer src);
/**
* Relative bulk put method (optional operation).
*
* 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 {@link 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.
*
* @param src
* The array from which bytes are to be read
*
* @param offset
* The offset within the array of the first byte to be read;
* must be non-negative and no larger than array.length
*
* @param length
* The number of bytes to be read from the given array;
* must be non-negative and no larger than
* array.length - offset
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
*
* @throws IndexOutOfBoundsException
* If the preconditions on the offset and length
* parameters do not hold
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer put(byte[] src, int offset, int length);
/**
* Relative bulk put method (optional operation).
*
* 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)
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer put(byte[] src);
/**
* Compacts this buffer (optional operation).
*
* 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
* }
*
*
* @return This buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer compact();
/**
* Retrieves this buffer's byte order.
*
* The byte order is used when reading or writing multibyte values, and
* when creating buffers that are views of this byte buffer. The order of
* a newly-created byte buffer is always {@link ByteOrder#BIG_ENDIAN
* BIG_ENDIAN}.
*
* @return This buffer's byte order
*/
public ByteOrder order();
/**
* Modifies this buffer's byte order.
*
* @param bo
* The new byte order,
* either {@link ByteOrder#BIG_ENDIAN BIG_ENDIAN}
* or {@link ByteOrder#LITTLE_ENDIAN LITTLE_ENDIAN}
*
* @return This buffer
*/
public Buffer order(ByteOrder bo);
/**
* Relative get method for reading a char value.
*
* 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.
*
* @return The char value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than two bytes
* remaining in this buffer
*/
public char getChar();
/**
* Relative put method for writing a char
* value (optional operation).
*
* 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.
*
* @param value
* The char value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than two bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putChar(char value);
/**
* Absolute get method for reading a char value.
*
* Reads two bytes at the given index, composing them into a
* char value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The char value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus one
*/
public char getChar(int index);
/**
* Absolute put method for writing a char
* value (optional operation).
*
* Writes two bytes containing the given char value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The char value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus one
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putChar(int index, char value);
/**
* Relative get method for reading a short value.
*
* 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.
*
* @return The short value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than two bytes
* remaining in this buffer
*/
public short getShort();
/**
* Relative put method for writing a short
* value (optional operation).
*
* 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.
*
* @param value
* The short value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than two bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putShort(short value);
/**
* Absolute get method for reading a short value.
*
* Reads two bytes at the given index, composing them into a
* short value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The short value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus one
*/
public short getShort(int index);
/**
* Absolute put method for writing a short
* value (optional operation).
*
* Writes two bytes containing the given short value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The short value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus one
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putShort(int index, short value);
/**
* Relative get method for reading an int value.
*
* 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.
*
* @return The int value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than four bytes
* remaining in this buffer
*/
public int getInt();
/**
* Relative put method for writing an int
* value (optional operation).
*
* 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.
*
* @param value
* The int value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than four bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putInt(int value);
/**
* Absolute get method for reading an int value.
*
* Reads four bytes at the given index, composing them into a
* int value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The int value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus three
*/
public int getInt(int index);
/**
* Absolute put method for writing an int
* value (optional operation).
*
* Writes four bytes containing the given int value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The int value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus three
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putInt(int index, int value);
/**
* Relative get method for reading a long value.
*
* 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.
*
* @return The long value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than eight bytes
* remaining in this buffer
*/
public long getLong();
/**
* Relative put method for writing a long
* value (optional operation).
*
* 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.
*
* @param value
* The long value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than eight bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putLong(long value);
/**
* Absolute get method for reading a long value.
*
* Reads eight bytes at the given index, composing them into a
* long value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The long value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus seven
*/
public long getLong(int index);
/**
* Absolute put method for writing a long
* value (optional operation).
*
* Writes eight bytes containing the given long value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The long value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus seven
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putLong(int index, long value);
/**
* Relative get method for reading a float value.
*
* 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.
*
* @return The float value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than four bytes
* remaining in this buffer
*/
public float getFloat();
/**
* Relative put method for writing a float
* value (optional operation).
*
* 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.
*
* @param value
* The float value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than four bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putFloat(float value);
/**
* Absolute get method for reading a float value.
*
* Reads four bytes at the given index, composing them into a
* float value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The float value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus three
*/
public float getFloat(int index);
/**
* Absolute put method for writing a float
* value (optional operation).
*
* Writes four bytes containing the given float value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The float value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus three
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putFloat(int index, float value);
/**
* Relative get method for reading a double value.
*
* 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.
*
* @return The double value at the buffer's current position
*
* @throws BufferUnderflowException
* If there are fewer than eight bytes
* remaining in this buffer
*/
public double getDouble();
/**
* Relative put method for writing a double
* value (optional operation).
*
* 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.
*
* @param value
* The double value to be written
*
* @return This buffer
*
* @throws BufferOverflowException
* If there are fewer than eight bytes
* remaining in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putDouble(double value);
/**
* Absolute get method for reading a double value.
*
* Reads eight bytes at the given index, composing them into a
* double value according to the current byte order.
*
* @param index
* The index from which the bytes will be read
*
* @return The double value at the given index
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus seven
*/
public double getDouble(int index);
/**
* Absolute put method for writing a double
* value (optional operation).
*
* Writes eight bytes containing the given double value, in the
* current byte order, into this buffer at the given index.
*
* @param index
* The index at which the bytes will be written
*
* @param value
* The double value to be written
*
* @return This buffer
*
* @throws IndexOutOfBoundsException
* If index is negative
* or not smaller than the buffer's limit,
* minus seven
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public Buffer putDouble(int index, double value);
/**
* Returns {@link Buffer} content as {@link String}
* @param charset the {@link Charset}, which will be use
* for byte[] -> {@link String} transformation.
*
* @return {@link String} representation of this {@link Buffer} content.
*/
public String contentAsString(Charset charset);
}