JCSharedBuffer

java.lang.Object
- org.mases.jcobridge.JCSharedBuffer

All Implemented Interfaces:

Closeable, AutoCloseable
```
public final class JCSharedBuffer
extends Object
implements Closeable
```
The JCSharedBuffer class shares a byte buffer between CLR and JVM.

Since:

2.5.12.0

Author:

MASES S.R.L.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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).
`CharBuffer`	`asCharBuffer()` Creates a view of this byte buffer as a char buffer.
`DoubleBuffer`	`asDoubleBuffer()` Creates a view of this byte buffer as a double buffer.
`FloatBuffer`	`asFloatBuffer()` Creates a view of this byte buffer as a float buffer.
`IntBuffer`	`asIntBuffer()` Creates a view of this byte buffer as an int buffer.
`LongBuffer`	`asLongBuffer()` Creates a view of this byte buffer as a long buffer.
`JCSharedBuffer`	`asReadOnlyBuffer()` Creates a new, read-only byte buffer that shares this buffer's content.
`ShortBuffer`	`asShortBuffer()` Creates a view of this byte buffer as a short buffer.
`int`	`capacity()` Returns this buffer's capacity.
`JCSharedBuffer`	`clear()` Clears this buffer.
`void`	`close()`
`JCSharedBuffer`	`compact()` Compacts this buffer (optional operation).
`int`	`compareTo(JCSharedBuffer that)` Compares this buffer to another.
`static ByteBuffer`	`Create(byte[] array)` Creates a new `ByteBuffer` from an array of bytes
`static JCSharedBuffer`	`Create(ByteBuffer buf)` Creates a new `JCSharedBuffer` from a `ByteBuffer`
`static CharBuffer`	`Create(char[] array)` Creates a new `CharBuffer` from an array of char
`static DoubleBuffer`	`Create(double[] array)` Creates a new `DoubleBuffer` from an array of double
`static FloatBuffer`	`Create(float[] array)` Creates a new `FloatBuffer` from an array of float
`static ByteBuffer`	`Create(int length)` Creates a new `ByteBuffer` with a specified length
`static IntBuffer`	`Create(int[] array)` Creates a new `IntBuffer` from an array of int
`static LongBuffer`	`Create(long[] array)` Creates a new `LongBuffer` from an array of long
`static ShortBuffer`	`Create(short[] array)` Creates a new `ShortBuffer` from an array of short
`JCSharedBuffer`	`duplicate()` Creates a new byte buffer that shares this buffer's content.
`boolean`	`equals(Object ob)` Tells whether or not this buffer is equal to another object.
`JCSharedBuffer`	`flip()` Flips this buffer.
`byte`	`get()` Relative get method.
`JCSharedBuffer`	`get(byte[] dst)` Relative bulk get method.
`JCSharedBuffer`	`get(byte[] dst, int offset, int length)` Relative bulk get method.
`byte`	`get(int index)` Absolute get method.
`ByteBuffer`	`getBuffer()` Returns the underlying `ByteBuffer` instance
`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.
`static boolean`	`getReuseByteBuffer()` Report if reuse of `ByteBuffer` is enabled/disabled
`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`	`isDirect()` Tells whether or not this byte buffer is direct.
`boolean`	`isReadOnly()` Tells whether or not this buffer is read-only.
`int`	`limit()` Returns this buffer's limit.
`JCSharedBuffer`	`limit(int newLimit)` Sets this buffer's limit.
`JCSharedBuffer`	`mark()` Sets this buffer's mark at its position.
`ByteOrder`	`order()` Retrieves this buffer's byte order.
`JCSharedBuffer`	`order(ByteOrder bo)` Modifies this buffer's byte order.
`int`	`position()` Returns this buffer's position.
`JCSharedBuffer`	`position(int newPosition)` Sets this buffer's position.
`JCSharedBuffer`	`put(byte b)` Relative put method (optional operation).
`JCSharedBuffer`	`put(byte[] src)` Relative bulk put method (optional operation).
`JCSharedBuffer`	`put(byte[] src, int offset, int length)` Relative bulk put method (optional operation).
`JCSharedBuffer`	`put(ByteBuffer src)` Relative bulk put method (optional operation).
`JCSharedBuffer`	`put(int index, byte b)` Absolute put method (optional operation).
`JCSharedBuffer`	`putChar(char value)` Relative put method for writing a char value (optional operation).
`JCSharedBuffer`	`putChar(int index, char value)` Absolute put method for writing a char value (optional operation).
`JCSharedBuffer`	`putDouble(double value)` Relative put method for writing a double value (optional operation).
`JCSharedBuffer`	`putDouble(int index, double value)` Absolute put method for writing a double value (optional operation).
`JCSharedBuffer`	`putFloat(float value)` Relative put method for writing a float value (optional operation).
`JCSharedBuffer`	`putFloat(int index, float value)` Absolute put method for writing a float value (optional operation).
`JCSharedBuffer`	`putInt(int value)` Relative put method for writing an int value (optional operation).
`JCSharedBuffer`	`putInt(int index, int value)` Absolute put method for writing an int value (optional operation).
`JCSharedBuffer`	`putLong(int index, long value)` Absolute put method for writing a long value (optional operation).
`JCSharedBuffer`	`putLong(long value)` Relative put method for writing a long value (optional operation).
`JCSharedBuffer`	`putShort(int index, short value)` Absolute put method for writing a short value (optional operation).
`JCSharedBuffer`	`putShort(short value)` Relative put method for writing a short value (optional operation).
`int`	`remaining()` Returns the number of elements between the current position and the limit.
`JCSharedBuffer`	`reset()` Resets this buffer's position to the previously-marked position.
`JCSharedBuffer`	`rewind()` Rewinds this buffer.
`static void`	`setReuseByteBuffer(boolean val)` Change this value to enable/disable reuse of `ByteBuffer`
`ByteBuffer`	`slice()` Creates a new byte buffer whose content is a shared subsequence of this buffer's content.
`String`	`toString()` Returns a string summarizing the state of this buffer.

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - Create
```
public static JCSharedBuffer Create(ByteBuffer buf)
                             throws IOException
```
    Creates a new JCSharedBuffer from a ByteBuffer
    
    Parameters:
    
    buf - The ByteBuffer used to initialize the JCSharedBuffer
    
    Returns:
    
    A JCSharedBuffer can be managed with the same API of a ByteBuffer
    
    Throws:
    
    IOException - Thrown if something goes wrong managing memory of buf, see getCause for deep information
  - Create
```
public static ByteBuffer Create(int length)
                         throws IOException
```
    Creates a new ByteBuffer with a specified length
    
    Parameters:
    
    length - The length to be used to initialize the ByteBuffer
    
    Returns:
    
    A ByteBuffer will have the ByteOrder of the platform, capacity and limit equals to the length
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for ByteBuffer, see getCause for deep information
  - Create
```
public static ByteBuffer Create(byte[] array)
                         throws IOException
```
    Creates a new ByteBuffer from an array of bytes
    
    Parameters:
    
    array - The array of bytes to be used to initialize the ByteBuffer
    
    Returns:
    
    A ByteBuffer containing, within the unmanaged memory, the copy of array, the returned ByteBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for ByteBuffer, see getCause for deep information
  - Create
```
public static CharBuffer Create(char[] array)
                         throws IOException
```
    Creates a new CharBuffer from an array of char
    
    Parameters:
    
    array - The array of char to be used to initialize the CharBuffer
    
    Returns:
    
    A CharBuffer containing, within the unmanaged memory, the copy of array, the returned CharBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for CharBuffer, see getCause for deep information
  - Create
```
public static DoubleBuffer Create(double[] array)
                           throws IOException
```
    Creates a new DoubleBuffer from an array of double
    
    Parameters:
    
    array - The array of double to be used to initialize the DoubleBuffer
    
    Returns:
    
    A DoubleBuffer containing, within the unmanaged memory, the copy of array, the returned DoubleBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for DoubleBuffer, see getCause for deep information
  - Create
```
public static FloatBuffer Create(float[] array)
                          throws IOException
```
    Creates a new FloatBuffer from an array of float
    
    Parameters:
    
    array - The array of float to be used to initialize the FloatBuffer
    
    Returns:
    
    A FloatBuffer containing, within the unmanaged memory, the copy of array, the returned FloatBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for FloatBuffer, see getCause for deep information
  - Create
```
public static IntBuffer Create(int[] array)
                        throws IOException
```
    Creates a new IntBuffer from an array of int
    
    Parameters:
    
    array - The array of int to be used to initialize the IntBuffer
    
    Returns:
    
    A IntBuffer containing, within the unmanaged memory, the copy of array, the returned IntBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for IntBuffer, see getCause for deep information
  - Create
```
public static LongBuffer Create(long[] array)
                         throws IOException
```
    Creates a new LongBuffer from an array of long
    
    Parameters:
    
    array - The array of long to be used to initialize the LongBuffer
    
    Returns:
    
    A LongBuffer containing, within the unmanaged memory, the copy of array, the returned LongBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for LongBuffer, see getCause for deep information
  - Create
```
public static ShortBuffer Create(short[] array)
                          throws IOException
```
    Creates a new ShortBuffer from an array of short
    
    Parameters:
    
    array - The array of short to be used to initialize the ShortBuffer
    
    Returns:
    
    A ShortBuffer containing, within the unmanaged memory, the copy of array, the returned ShortBuffer will have the ByteOrder of the platform
    
    Throws:
    
    IOException - Thrown if something goes wrong allocating memory for ShortBuffer, see getCause for deep information
  - getReuseByteBuffer
```
public static boolean getReuseByteBuffer()
```
    Report if reuse of ByteBuffer is enabled/disabled
    
    Returns:
    
    True if reuse of ByteBuffer is enabled, otherwise false
  - setReuseByteBuffer
```
public static void setReuseByteBuffer(boolean val)
```
    Change this value to enable/disable reuse of ByteBuffer
    
    Parameters:
    
    val - Set to false if the ByteBuffer generated using Create(byte[]) shall be discarded
  - close
```
public void close()
           throws IOException
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException
  - getBuffer
```
public ByteBuffer getBuffer()
```
    Returns the underlying ByteBuffer instance
    
    Returns:
    
    The underlying ByteBuffer
  - capacity
```
public final int capacity()
```
    Returns this buffer's capacity.
    
    Returns:
    
    The capacity of this buffer
  - position
```
public final int position()
```
    Returns this buffer's position.
    
    Returns:
    
    The position of this buffer
  - position
```
public final JCSharedBuffer position(int newPosition)
```
    Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded.
    
    Parameters:
    
    newPosition - The new position value; must be non-negative and no larger than the current limit
    
    Returns:
    
    This buffer
    
    Throws:
    
    IllegalArgumentException - If the preconditions on newPosition do not hold
  - limit
```
public final int limit()
```
    Returns this buffer's limit.
    
    Returns:
    
    The limit of this buffer
  - limit
```
public final JCSharedBuffer limit(int newLimit)
```
    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.
    
    Parameters:
    
    newLimit - The new limit value; must be non-negative and no larger than this buffer's capacity
    
    Returns:
    
    This buffer
    
    Throws:
    
    IllegalArgumentException - If the preconditions on newLimit do not hold
  - mark
```
public final JCSharedBuffer mark()
```
    Sets this buffer's mark at its position.
    
    Returns:
    
    This buffer
  - reset
```
public final JCSharedBuffer reset()
```
    Resets this buffer's position to the previously-marked position.
    Invoking this method neither changes nor discards the mark's value.
    
    Returns:
    
    This buffer
    
    Throws:
    
    InvalidMarkException - If the mark has not been set
  - clear
```
public final JCSharedBuffer clear()
```
    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.
    Returns:
    
    This buffer
  - flip
```
public final JCSharedBuffer flip()
```
    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 compact method when transferring data from one place to another.
    Returns:
    
    This buffer
  - rewind
```
public final JCSharedBuffer rewind()
```
    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
    Returns:
    
    This buffer
  - remaining
```
public final int remaining()
```
    Returns the number of elements between the current position and the limit.
    
    Returns:
    
    The number of elements remaining in this buffer
  - hasRemaining
```
public final boolean hasRemaining()
```
    Tells whether there are any elements between the current position and the limit.
    
    Returns:
    
    true if, and only if, there is at least one element remaining in this buffer
  - isReadOnly
```
public final boolean isReadOnly()
```
    Tells whether or not this buffer is read-only.
    
    Returns:
    
    true if, and only if, this buffer is read-only
  - hasArray
```
public final boolean hasArray()
```
    Tells whether or not this buffer is backed by an accessible byte array.
    If this method returns true then the array and arrayOffset methods may safely be invoked.
    
    Returns:
    
    true if, and only if, this buffer is backed by an array and is not read-only
  - arrayOffset
```
public final int arrayOffset()
```
    Returns the offset within this buffer's backing array of the first element of the buffer (optional operation).
    If this buffer is backed by an array then buffer position p corresponds to array index p + arrayOffset().
    Invoke the hasArray method before invoking this method in order to ensure that this buffer has an accessible backing array.
    
    Returns:
    
    The offset within this buffer's array of the first element of the buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is backed by an array but is read-only
    
    UnsupportedOperationException - If this buffer is not backed by an accessible array
  - isDirect
```
public final boolean isDirect()
```
    Tells whether or not this byte buffer is direct.
    
    Returns:
    
    true if, and only if, this buffer is direct
  - slice
```
public ByteBuffer slice()
```
    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.
    
    Returns:
    
    The new byte buffer
  - duplicate
```
public final JCSharedBuffer duplicate()
                               throws IOException
```
    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.
    
    Returns:
    
    The new byte buffer
    
    Throws:
    
    IOException - Thrown if something goes wrong managing memory of original JCSharedBuffer, see getCause for deep information
  - asReadOnlyBuffer
```
public final JCSharedBuffer asReadOnlyBuffer()
                                      throws IOException
```
    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 duplicate method.
    
    Returns:
    
    The new, read-only byte buffer
    
    Throws:
    
    IOException - Thrown if something goes wrong managing memory of original JCSharedBuffer, see getCause for deep information
  - get
```
public final byte get()
```
    Relative get method. Reads the byte at this buffer's current position, and then increments the position.
    
    Returns:
    
    The byte at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If the buffer's current position is not smaller than its limit
  - put
```
public final JCSharedBuffer put(byte b)
```
    Relative put method (optional operation).
    Writes the given byte into this buffer at the current position, and then increments the position.
    
    Parameters:
    
    b - The byte to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If this buffer's current position is not smaller than its limit
    
    ReadOnlyBufferException - If this buffer is read-only
  - get
```
public final byte get(int index)
```
    Absolute get method. Reads the byte at the given index.
    
    Parameters:
    
    index - The index from which the byte will be read
    
    Returns:
    
    The byte at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
  - put
```
public final JCSharedBuffer put(int index,
                                byte b)
```
    Absolute put method (optional operation).
    Writes the given byte into this buffer at the given index.
    
    Parameters:
    
    index - The index at which the byte will be written
    
    b - The byte value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit
    
    ReadOnlyBufferException - If this buffer is read-only
  - get
```
public JCSharedBuffer get(byte[] dst,
                          int offset,
                          int length)
```
    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 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.
    Parameters:
    
    dst - The array into which bytes are to be written
    
    offset - The offset within the array of the first byte to be written; must be non-negative and no larger than dst.length
    
    length - The maximum number of bytes to be written to the given array; must be non-negative and no larger than dst.length - offset
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferUnderflowException - If there are fewer than length bytes remaining in this buffer
    
    IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
  - get
```
public JCSharedBuffer get(byte[] dst)
```
    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)
 
```
    Parameters:
    
    dst - The destination array
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferUnderflowException - If there are fewer than length bytes remaining in this buffer
  - put
```
public JCSharedBuffer put(ByteBuffer src)
```
    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 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.
    Parameters:
    
    src - The source buffer from which bytes are to be read; must not be this buffer
    
    Returns:
    
    This buffer
    
    Throws:
    
    UnsupportedOperationException - The method is not implemented
  - put
```
public JCSharedBuffer put(byte[] src,
                          int offset,
                          int length)
```
    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 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.
    Parameters:
    
    src - The array from which bytes are to be read
    
    offset - The offset within the array of the first byte to be read; must be non-negative and no larger than array.length
    
    length - The number of bytes to be read from the given array; must be non-negative and no larger than array.length - offset
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in this buffer
    
    IndexOutOfBoundsException - If the preconditions on the offset and length parameters do not hold
    
    ReadOnlyBufferException - If this buffer is read-only
  - put
```
public final JCSharedBuffer put(byte[] src)
```
    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)
 
```
    Parameters:
    
    src - The source array
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - array
```
public final byte[] array()
```
    Returns the byte array that backs this buffer (optional operation).
    Modifications to this buffer's content will cause the returned array's content to be modified, and vice versa.
    Invoke the hasArray method before invoking this method in order to ensure that this buffer has an accessible backing array.
    
    Returns:
    
    The array that backs this buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is backed by an array but is read-only
    
    UnsupportedOperationException - If this buffer is not backed by an accessible array
  - compact
```
public final JCSharedBuffer compact()
```
    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 while (in.read(buf) >= 0 || buf.position != 0) { buf.flip(); out.write(buf); buf.compact(); // In case of partial write }
    Returns:
    
    This buffer
    
    Throws:
    
    ReadOnlyBufferException - If this buffer is read-only
  - toString
```
public String toString()
```
    Returns a string summarizing the state of this buffer.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A summary string
  - hashCode
```
public int hashCode()
```
    Returns the current hash code of this buffer.
    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.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    The current hash code of this buffer
  - equals
```
public boolean equals(Object ob)
```
    Tells whether or not this buffer is equal to another object.
    Two byte buffers are equal if, and only if,
    1. They have the same element type,
    2. They have the same number of remaining elements, and
    3. The two sequences of remaining elements, considered independently of their starting positions, are pointwise equal.
    A byte buffer is not equal to any other type of object.
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    ob - The object to which this buffer is to be compared
    
    Returns:
    
    true if, and only if, this buffer is equal to the given object
  - compareTo
```
public int compareTo(JCSharedBuffer that)
```
    Compares this buffer to another.
    Two byte buffers are compared by comparing their sequences of remaining elements lexicographically, without regard to the starting position of each sequence within its corresponding buffer. Pairs of byte elements are compared as if by invoking Byte.compare(byte,byte).
    A byte buffer is not comparable to any other type of object.
    
    Parameters:
    
    that - The object to which this buffer is to be compared
    
    Returns:
    
    A negative integer, zero, or a positive integer as this buffer is less than, equal to, or greater than the given buffer
  - order
```
public final ByteOrder order()
```
    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 BIG_ENDIAN.
    
    Returns:
    
    This buffer's byte order
  - order
```
public final JCSharedBuffer order(ByteOrder bo)
```
    Modifies this buffer's byte order.
    
    Parameters:
    
    bo - The new byte order, either BIG_ENDIAN or LITTLE_ENDIAN
    
    Returns:
    
    This buffer
  - getChar
```
public final char getChar()
```
    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.
    
    Returns:
    
    The char value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than two bytes remaining in this buffer
  - putChar
```
public final JCSharedBuffer putChar(char value)
```
    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.
    
    Parameters:
    
    value - The char value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than two bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getChar
```
public final char getChar(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The char value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
  - putChar
```
public final JCSharedBuffer putChar(int index,
                                    char value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The char value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
    
    ReadOnlyBufferException - If this buffer is read-only
  - asCharBuffer
```
public final CharBuffer asCharBuffer()
```
    Creates a view of this byte buffer as a char buffer.
    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 divided by two, 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.
    
    Returns:
    
    A new char buffer
  - getShort
```
public final short getShort()
```
    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.
    
    Returns:
    
    The short value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than two bytes remaining in this buffer
  - putShort
```
public final JCSharedBuffer putShort(short value)
```
    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.
    
    Parameters:
    
    value - The short value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than two bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getShort
```
public final short getShort(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The short value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
  - putShort
```
public final JCSharedBuffer putShort(int index,
                                     short value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The short value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus one
    
    ReadOnlyBufferException - If this buffer is read-only
  - asShortBuffer
```
public final ShortBuffer asShortBuffer()
```
    Creates a view of this byte buffer as a short buffer.
    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 divided by two, 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.
    
    Returns:
    
    A new short buffer
  - getInt
```
public final int getInt()
```
    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.
    
    Returns:
    
    The int value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than four bytes remaining in this buffer
  - putInt
```
public final JCSharedBuffer putInt(int value)
```
    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.
    
    Parameters:
    
    value - The int value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than four bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getInt
```
public final int getInt(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The int value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
  - putInt
```
public final JCSharedBuffer putInt(int index,
                                   int value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The int value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
    
    ReadOnlyBufferException - If this buffer is read-only
  - asIntBuffer
```
public final IntBuffer asIntBuffer()
```
    Creates a view of this byte buffer as an int buffer.
    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 divided by four, 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.
    
    Returns:
    
    A new int buffer
  - getLong
```
public final long getLong()
```
    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.
    
    Returns:
    
    The long value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than eight bytes remaining in this buffer
  - putLong
```
public final JCSharedBuffer putLong(long value)
```
    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.
    
    Parameters:
    
    value - The long value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than eight bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getLong
```
public final long getLong(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The long value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
  - putLong
```
public final JCSharedBuffer putLong(int index,
                                    long value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The long value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
    
    ReadOnlyBufferException - If this buffer is read-only
  - asLongBuffer
```
public final LongBuffer asLongBuffer()
```
    Creates a view of this byte buffer as a long buffer.
    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 divided by eight, 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.
    
    Returns:
    
    A new long buffer
  - getFloat
```
public final float getFloat()
```
    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.
    
    Returns:
    
    The float value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than four bytes remaining in this buffer
  - putFloat
```
public final JCSharedBuffer putFloat(float value)
```
    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.
    
    Parameters:
    
    value - The float value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than four bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getFloat
```
public final float getFloat(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The float value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
  - putFloat
```
public final JCSharedBuffer putFloat(int index,
                                     float value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The float value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus three
    
    ReadOnlyBufferException - If this buffer is read-only
  - asFloatBuffer
```
public final FloatBuffer asFloatBuffer()
```
    Creates a view of this byte buffer as a float buffer.
    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 divided by four, 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.
    
    Returns:
    
    A new float buffer
  - getDouble
```
public final double getDouble()
```
    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.
    
    Returns:
    
    The double value at the buffer's current position
    
    Throws:
    
    BufferUnderflowException - If there are fewer than eight bytes remaining in this buffer
  - putDouble
```
public final JCSharedBuffer putDouble(double value)
```
    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.
    
    Parameters:
    
    value - The double value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    BufferOverflowException - If there are fewer than eight bytes remaining in this buffer
    
    ReadOnlyBufferException - If this buffer is read-only
  - getDouble
```
public final double getDouble(int index)
```
    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.
    
    Parameters:
    
    index - The index from which the bytes will be read
    
    Returns:
    
    The double value at the given index
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
  - putDouble
```
public final JCSharedBuffer putDouble(int index,
                                      double value)
```
    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.
    
    Parameters:
    
    index - The index at which the bytes will be written
    
    value - The double value to be written
    
    Returns:
    
    This buffer
    
    Throws:
    
    IndexOutOfBoundsException - If index is negative or not smaller than the buffer's limit, minus seven
    
    ReadOnlyBufferException - If this buffer is read-only
  - asDoubleBuffer
```
public final DoubleBuffer asDoubleBuffer()
```
    Creates a view of this byte buffer as a double buffer.
    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 divided by eight, 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.
    
    Returns:
    
    A new double buffer

Class JCSharedBuffer

Method Summary

Methods inherited from class java.lang.Object

Method Detail

Create

Create

Create

Create

Create

Create

Create

Create

Create

getReuseByteBuffer

setReuseByteBuffer

close

getBuffer

capacity

position

position

limit

limit

mark

reset

clear

flip

rewind

remaining

hasRemaining

isReadOnly

hasArray

arrayOffset

isDirect

slice

duplicate

asReadOnlyBuffer

get

put

get

put

get

get

put

put

put

array

compact

toString

hashCode

equals

compareTo

order

order

getChar

putChar

getChar

putChar

asCharBuffer

getShort

putShort

getShort

putShort

asShortBuffer

getInt

putInt

getInt

putInt

asIntBuffer

getLong

putLong

getLong

putLong

asLongBuffer

getFloat

putFloat

getFloat

putFloat

asFloatBuffer

getDouble

putDouble