Buffer(int mark,
    int pos,
    int lim,
    int cap) 
{
       // package-private
        if (cap <  0)
            throw new IllegalArgumentException("Negative capacity: " + cap);
        this.capacity = cap;
        limit(lim);
        position(pos);
        if (mark  >= 0) {
            if (mark  > pos)
                throw new IllegalArgumentException("mark  > position: ("
                                                   + mark + "  > " + pos + ")");
            this.mark = mark;
        }
}

 abstract public Object array()
Returns the array that backs this
buffer  (optional operation).

 This method is intended to allow array-backed buffers to be
passed to native code more efficiently. Concrete subclasses
provide more strongly-typed return values for this method.

 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.  

 abstract public 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.  

 public final int capacity() 
{
        return capacity;
}

Returns this buffer's capacity.

 static  void checkBounds(int off,
    int len,
    int size) 
{
 // package-private
        if ((off | len | (off + len) | (size - (off + len))) <  0)
            throw new IndexOutOfBoundsException();
}

 final int checkIndex(int i) 
{
                       // package-private
        if ((i <  0) || (i  >= limit))
            throw new IndexOutOfBoundsException();
        return i;
}

Checks the given index against the limit, throwing an IndexOutOfBoundsException if it is not smaller than the limit or is smaller than zero.

 final int checkIndex(int i,
    int nb) 
{
               // package-private
        if ((i <  0) || (nb  > limit - i))
            throw new IndexOutOfBoundsException();
        return i;
}

 public final Buffer clear() 
{
        position = 0;
        limit = capacity;
        mark = -1;
        return this;
}

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.

 final  void discardMark() 
{
                          // package-private
        mark = -1;
}

 public final Buffer flip() 
{
        limit = position;
        position = 0;
        mark = -1;
        return this;
}

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.

 abstract public boolean hasArray()
Tells whether or not this buffer is backed by an accessible
array.

 If this method returns true then the array 
and arrayOffset  methods may safely be invoked.

 public final boolean hasRemaining() 
{
        return position <  limit;
}

Tells whether there are any elements between the current position and the limit.

 abstract public boolean isDirect()
Tells whether or not this buffer is
direct. 

 abstract public boolean isReadOnly()
Tells whether or not this buffer is read-only. 

 public final int limit() 
{
        return limit;
}

Returns this buffer's limit.

 public final Buffer limit(int newLimit) 
{
        if ((newLimit  > capacity) || (newLimit <  0))
            throw new IllegalArgumentException();
        limit = newLimit;
        if (position  > limit) position = limit;
        if (mark  > limit) mark = -1;
        return this;
}

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.

 public final Buffer mark() 
{
        mark = position;
        return this;
}

Sets this buffer's mark at its position.

 final int markValue() 
{
                             // package-private
        return mark;
}

 final int nextGetIndex() 
{
                          // package-private
        if (position  >= limit)
            throw new BufferUnderflowException();
        return position++;
}

Checks the current position against the limit, throwing a BufferUnderflowException if it is not smaller than the limit, and then increments the position.

 final int nextGetIndex(int nb) 
{
                    // package-private
        if (limit - position <  nb)
            throw new BufferUnderflowException();
        int p = position;
        position += nb;
        return p;
}

 final int nextPutIndex() 
{
                          // package-private
        if (position  >= limit)
            throw new BufferOverflowException();
        return position++;
}

Checks the current position against the limit, throwing a BufferOverflowException if it is not smaller than the limit, and then increments the position.

 final int nextPutIndex(int nb) 
{
                    // package-private
        if (limit - position <  nb)
            throw new BufferOverflowException();
        int p = position;
        position += nb;
        return p;
}

 public final int position() 
{
        return position;
}

Returns this buffer's position.

 public final Buffer position(int newPosition) 
{
        if ((newPosition  > limit) || (newPosition <  0))
            throw new IllegalArgumentException();
        position = newPosition;
        if (mark  > position) mark = -1;
        return this;
}

Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded.

 public final int remaining() 
{
        return limit - position;
}

Returns the number of elements between the current position and the limit.

 public final Buffer reset() 
{
        int m = mark;
        if (m <  0)
            throw new InvalidMarkException();
        position = m;
        return this;
}

Resets this buffer's position to the previously-marked position.

Invoking this method neither changes nor discards the mark's value.

 public final Buffer rewind() 
{
        position = 0;
        mark = -1;
        return this;
}

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