java.lang.Object
- org.lwjgl.system.CustomBuffer<SELF>

All Implemented Interfaces:

Pointer

Direct Known Subclasses:

PointerBuffer, StructBuffer
```
public abstract class CustomBuffer<SELF extends CustomBuffer<SELF>>
extends java.lang.Object
implements Pointer
```
Base class of custom buffers with an API that mirrors java.nio for convenience.

Nested Class Summary
- Nested classes/interfaces inherited from interface org.lwjgl.system.Pointer
  Pointer.Default

Field Summary
- Fields inherited from interface org.lwjgl.system.Pointer
  POINTER_SHIFT, POINTER_SIZE

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`address()` Returns the memory address at the current buffer position.
`long`	`address(int position)` Returns the memory address at the specified buffer position.
`long`	`address0()` Returns the buffer's base address.
`int`	`capacity()` Returns this buffer's capacity.
`SELF`	`clear()` Clears this buffer.
`SELF`	`compact()` Compacts this buffer (optional operation).
`SELF`	`duplicate()` Creates a new buffer that shares this buffer's content.
`SELF`	`flip()` Flips this buffer.
`void`	`free()` Frees the buffer allocation.
`boolean`	`hasRemaining()` Tells whether there are any elements between the current position and the limit.
`int`	`limit()` Returns this buffer's limit.
`SELF`	`limit(int newLimit)` Sets this buffer's limit.
`SELF`	`mark()` Sets this buffer's mark at its position.
`int`	`position()` Returns this buffer's position.
`SELF`	`position(int newPosition)` Sets this buffer's position.
`SELF`	`put(SELF src)` Relative bulk put method (optional operation).
`int`	`remaining()` Returns the number of elements between the current position and the limit.
`SELF`	`reset()` Resets this buffer's position to the previously-marked position.
`SELF`	`rewind()` Rewinds this buffer.
`abstract int`	`sizeof()` Returns the `sizeof` a single element in the buffer.
`SELF`	`slice()` Creates a new buffer whose content is a shared subsequence of this buffer's content.
`SELF`	`slice(int offset, int capacity)` Returns a slice of this buffer between `(buffer.position() + offset)` and `(buffer.position() + offset + capacity)`.
`java.lang.String`	`toString()` Returns a string summarizing the state of this buffer.

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

- Method Detail
  - sizeof
```
public abstract int sizeof()
```
    Returns the sizeof a single element in the buffer.
  - address0
```
public long address0()
```
    Returns the buffer's base address. [INTERNAL USE ONLY]
  - address
```
public long address()
```
    Returns the memory address at the current buffer position.
    
    Specified by:
    
    address in interface Pointer
    
    Returns:
    
    the pointer address
  - address
```
public long address(int position)
```
    Returns the memory address at the specified buffer position.
  - free
```
public void free()
```
    Frees the buffer allocation.
    This method should not be used if the memory backing this buffer is not owned by the buffer.
  - capacity
```
public int capacity()
```
    Returns this buffer's capacity.
    
    Returns:
    
    the capacity of this buffer
  - position
```
public int position()
```
    Returns this buffer's position.
    
    Returns:
    
    the position of this buffer
  - position
```
public SELF 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:
    
    java.lang.IllegalArgumentException - If the preconditions on newPosition do not hold
  - limit
```
public int limit()
```
    Returns this buffer's limit.
    
    Returns:
    
    the limit of this buffer
  - limit
```
public SELF 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:
    
    java.lang.IllegalArgumentException - If the preconditions on newLimit do not hold
  - mark
```
public SELF mark()
```
    Sets this buffer's mark at its position.
    
    Returns:
    
    This buffer
  - reset
```
public SELF 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:
    
    java.nio.InvalidMarkException - If the mark has not been set
  - clear
```
public SELF 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 SELF 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 CustomBuffer.compact() method when transferring data from one place to another.
    Returns:
    
    This buffer
  - rewind
```
public SELF 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 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 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
  - slice
```
public SELF slice()
```
    Creates a new 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 elements remaining in this buffer, and its mark will be undefined. The new buffer will be read-only if, and only if, this buffer is read-only.
    
    Returns:
    
    the new buffer
  - slice
```
public SELF slice(int offset,
                  int capacity)
```
    Returns a slice of this buffer between (buffer.position() + offset) and (buffer.position() + offset + capacity).
    The position and limit of this buffer are preserved after a call to this method.
    
    Parameters:
    
    offset - the slice offset, it must be ≤ this.remaining()
    
    capacity - the slice length, it must be ≤ this.capacity() - (this.position() + offset)
    
    Returns:
    
    the sliced buffer
  - duplicate
```
public SELF duplicate()
```
    Creates a new 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 and position will be identical to those of this buffer.
    
    Returns:
    
    the new buffer
  - put
```
public SELF put(SELF src)
```
    Relative bulk put method (optional operation).
    This method transfers the elements remaining in the specified source buffer into this buffer. If there are more elements remaining in the source buffer than in this buffer, that is, if src.remaining() > remaining(), then no elements are transferred and a BufferOverflowException is thrown.
    Otherwise, this method copies n = src.remaining() elements from the specified 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 elements are to be read; must not be this buffer
    
    Returns:
    
    This buffer
    
    Throws:
    
    java.nio.BufferOverflowException - If there is insufficient space in this buffer for the remaining elements in the source buffer
    
    java.lang.IllegalArgumentException - If the source buffer is this buffer
    
    java.nio.ReadOnlyBufferException - If this buffer is read-only
  - compact
```
public SELF compact()
```
    Compacts this buffer (optional operation).
    The elements between the buffer's current position and its limit, if any, are copied to the beginning of the buffer. That is, the element at index p = position() is copied to index zero, the element at index p + 1 is copied to index one, and so forth until the element 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 elements copied, rather than to zero, so that an invocation of this method can be followed immediately by an invocation of another relative put method.
    
    Returns:
    
    This buffer
    
    Throws:
    
    java.nio.ReadOnlyBufferException - If this buffer is read-only
  - toString
```
public java.lang.String toString()
```
    Returns a string summarizing the state of this buffer.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    A summary string

Class CustomBuffer<SELF extends CustomBuffer<SELF>>

Nested Class Summary

Nested classes/interfaces inherited from interface org.lwjgl.system.Pointer

Field Summary

Fields inherited from interface org.lwjgl.system.Pointer

Method Summary

Methods inherited from class java.lang.Object

Method Detail

sizeof

address0

address

address

free

capacity

position

position

limit

limit

mark

reset

clear

flip

rewind

remaining

hasRemaining

slice

slice

duplicate

put

compact

toString