AbstractBuffer (Pkts Buffer Lib 3.0.10 API)

java.lang.Object
- io.pkts.buffer.BaseBuffer
- - io.pkts.buffer.AbstractBuffer

All Implemented Interfaces:

Buffer, Cloneable

Direct Known Subclasses:

ByteBuffer, InputStreamBuffer
```
public abstract class AbstractBuffer
extends BaseBuffer
```
Author:

jonas@jonasborjesson.com

Field Summary

Fields
Modifier and Type	Field and Description
`protected int`	`lowerBoundary` We will pretend that any bytes below this boundary doesn't exist.
`protected int`	`markedReaderIndex` The position of the reader index that has been marked.
`protected int`	`readerIndex` From where we will continue reading
`protected int`	`upperBoundary` Any bytes above this boundary is not accessible to us
`protected int`	`writerIndex` This is where we will write the next byte.

Fields inherited from class io.pkts.buffer.BaseBuffer
CR, LF

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractBuffer(int readerIndex, int lowerBoundary, int upperBoundary, int writerIndex)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`capacity()` The capacity of this buffer.
`protected void`	`checkIndex(int index)` Convenience method for checking if we can read at the index
`protected void`	`checkWriterIndex(int index)` Convenience method for checking whether we can write at the specified index.
`abstract Buffer`	`clone()` Performs a deep clone of this object.
`abstract boolean`	`equals(Object other)` Check whether to buffers are considered to be equal.
`int`	`getLowerBoundary()` If you access the `Buffer.getRawArray()` you will get just that.
`int`	`getReadableBytes()` Returns the number of available bytes for reading without blocking.
`int`	`getReaderIndex()` The reader index
`int`	`getUpperBoundary()` See explanation in `Buffer.getLowerBoundary()` since this is the same, just the upper limit of that raw array.
`int`	`getWritableBytes()` Get the number of writable bytes.
`int`	`getWriterIndex()` The writer index.
`abstract int`	`hashCode()`
`boolean`	`hasWriteSupport()` The underlying subclass should override this if it has write support.
`void`	`markReaderIndex()` Mark the current position of the reader index.
`short`	`readUnsignedByte()`
`void`	`resetReaderIndex()` Reset the reader index to the marked position or to the beginning of the buffer if mark hasn't explicitly been called.
`void`	`setReaderIndex(int index)`
`void`	`setWriterIndex(int index)`
`Buffer`	`slice()` Slice off the rest of the buffer.
`Buffer`	`slice(int stop)` Same as `#slice(Buffer.getReaderIndex(), int)`
`void`	`write(byte b)` Write a byte to where the current writer index is pointing.
`void`	`write(String s)` Same as `Buffer.write(String, String)` where the charset is set to "UTF-8"
`void`	`write(String s, String charset)` Write a string to this buffer using the specified charset to convert the String into bytes.

Methods inherited from class io.pkts.buffer.BaseBuffer
checkReadableBytes, checkReadableBytesSafe, checkWritableBytesSafe, hasWritableBytes, indexOf, indexOf, isByteInArray, parseToInt, parseToInt, readLine, readUntil, readUntil, readUntilDoubleCRLF, readUntilSafe, readUntilSingleCRLF

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

Methods inherited from interface io.pkts.buffer.Buffer
dumpAsHex, equalsIgnoreCase, getArray, getBit, getBit0, getBit1, getBit2, getBit3, getBit4, getBit5, getBit6, getBit7, getByes, getByte, getBytes, getBytes, getBytes, getInt, getRawArray, getShort, getUnsignedByte, getUnsignedInt, getUnsignedShort, hasReadableBytes, isEmpty, peekByte, readByte, readBytes, readInt, readShort, readUnsignedInt, readUnsignedShort, setByte, setInt, setUnsignedByte, setUnsignedInt, setUnsignedShort, slice, toString, unsignedInt, write, write, write, writeAsString, writeAsString

- Field Detail
  - readerIndex
```
protected int readerIndex
```
    From where we will continue reading
  - writerIndex
```
protected int writerIndex
```
    This is where we will write the next byte.
  - markedReaderIndex
```
protected int markedReaderIndex
```
    The position of the reader index that has been marked. I.e., this is the position we will move the reader index back to if someone is asking us to resetReaderIndex()
  - lowerBoundary
```
protected int lowerBoundary
```
    We will pretend that any bytes below this boundary doesn't exist.
  - upperBoundary
```
protected int upperBoundary
```
    Any bytes above this boundary is not accessible to us
- Constructor Detail
  - AbstractBuffer
```
protected AbstractBuffer(int readerIndex,
                         int lowerBoundary,
                         int upperBoundary,
                         int writerIndex)
```
- Method Detail
  - clone
```
public abstract Buffer clone()
```
    Description copied from interface: Buffer
    
    Performs a deep clone of this object. I.e., the array that is backed by this buffer will be copied and a new buffer will be returned. Hence, any changes to the backing of this buffer will not affect the cloned buffer.
    
    Specified by:
    
    clone in interface Buffer
    
    Specified by:
    
    clone in class BaseBuffer
    
    Returns:
  - getLowerBoundary
```
public int getLowerBoundary()
```
    Description copied from interface: Buffer
    
    If you access the Buffer.getRawArray() you will get just that. The raw un-guarded array, which may be useful but should be used with care since you now can do whatever you want with the data. However, if you do so and also want to know which 'slice' of that array this buffer is seeing, then you need to know the lower boundary as well since the array can e.g be 1k long but the data seen by this buffer starts at index 200.
    
    Returns:
  - getUpperBoundary
```
public int getUpperBoundary()
```
    Description copied from interface: Buffer
    
    See explanation in Buffer.getLowerBoundary() since this is the same, just the upper limit of that raw array.
    
    Returns:
  - getReaderIndex
```
public int getReaderIndex()
```
    The reader index
    
    Returns:
  - getWriterIndex
```
public int getWriterIndex()
```
    Description copied from interface: Buffer
    
    The writer index. This is where we will be writing our next byte if asked to do so.
    
    Returns:
  - setWriterIndex
```
public void setWriterIndex(int index)
```
  - setReaderIndex
```
public void setReaderIndex(int index)
```
  - capacity
```
public int capacity()
```
    The capacity of this buffer. The capacity is not affected by where the reader index is etc
    
    Returns:
    
    the capacity
  - getWritableBytes
```
public int getWritableBytes()
```
    Description copied from interface: Buffer
    
    Get the number of writable bytes.
    
    Returns:
  - markReaderIndex
```
public void markReaderIndex()
```
    Mark the current position of the reader index.
    
    See Also:
    
    #reset()
  - slice
```
public Buffer slice(int stop)
```
    Same as #slice(Buffer.getReaderIndex(), int)
    
    Returns:
  - slice
```
public Buffer slice()
```
    Description copied from interface: Buffer
    
    Slice off the rest of the buffer. Same as #slice(Buffer.getReaderIndex(), buffer.getCapacity()) Note, if you slice an empty buffer you will get back another empty buffer. Same goes for when you slice a buffer whose bytes already have been consumed.
    
    Returns:
  - getReadableBytes
```
public int getReadableBytes()
```
    Returns the number of available bytes for reading without blocking. If this returns less than what you want, there may still be more bytes available depending on the underlying implementation. E.g., a Buffer backed by an InputStream may be able to read more off the stream, however, it may not be able to do so without blocking.
    
    Returns:
  - resetReaderIndex
```
public void resetReaderIndex()
```
    Reset the reader index to the marked position or to the beginning of the buffer if mark hasn't explicitly been called.
  - checkIndex
```
protected void checkIndex(int index)
                   throws IndexOutOfBoundsException
```
    Convenience method for checking if we can read at the index
    
    Parameters:
    
    index -
    
    Throws:
    
    IndexOutOfBoundsException
  - checkWriterIndex
```
protected void checkWriterIndex(int index)
                         throws IndexOutOfBoundsException
```
    Convenience method for checking whether we can write at the specified index.
    
    Parameters:
    
    index -
    
    Throws:
    
    IndexOutOfBoundsException
  - readUnsignedByte
```
public final short readUnsignedByte()
                             throws IndexOutOfBoundsException,
                                    IOException
```
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - hasWriteSupport
```
public boolean hasWriteSupport()
```
    The underlying subclass should override this if it has write support. Check whether this Buffer has write support or not. There are buffers that do not allow you to write to them (such as the EmptyBuffer) so if you try and write to such a buffer it will throw a WriteNotSupportedException.
    
    Returns:
  - write
```
public void write(byte b)
           throws IndexOutOfBoundsException
```
    Description copied from interface: Buffer
    
    Write a byte to where the current writer index is pointing. Note, many implementations may not support writing and if they don't, they will throw a WriteNotSupportedException
    
    Throws:
    
    IndexOutOfBoundsException - in case there is no more space to write to (which includes those cases where the underlying implementation does not support writing)
  - write
```
public void write(String s)
           throws IndexOutOfBoundsException,
                  WriteNotSupportedException,
                  UnsupportedEncodingException
```
    Description copied from interface: Buffer
    
    Same as Buffer.write(String, String) where the charset is set to "UTF-8"
    
    Throws:
    
    IndexOutOfBoundsException - in case we cannot write entire String to this Buffer.
    
    WriteNotSupportedException - in case the underlying implementation does not support writes.
    
    UnsupportedEncodingException - in case the charset "UTF-8" is not supported by the platform.
  - write
```
public void write(String s,
                  String charset)
           throws IndexOutOfBoundsException,
                  WriteNotSupportedException,
                  UnsupportedEncodingException
```
    Description copied from interface: Buffer
    
    Write a string to this buffer using the specified charset to convert the String into bytes. The writerInxex of this buffer will be increased with the corresponding number of bytes. Note, either the entire string is written to this buffer or if it doesn't fit then nothing is written to this buffer.
    
    Throws:
    
    IndexOutOfBoundsException - in case we cannot write entire String to this Buffer.
    
    WriteNotSupportedException
    
    UnsupportedEncodingException - in case the specified charset is not supported
  - equals
```
public abstract boolean equals(Object other)
```
    Description copied from interface: Buffer
    
    Check whether to buffers are considered to be equal. To buffers are equal if the underlying visible area of the byte array are equal.
    
    Specified by:
    
    equals in interface Buffer
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public abstract int hashCode()
```
    Specified by:
    
    hashCode in interface Buffer
    
    Overrides:
    
    hashCode in class Object

Class AbstractBuffer

Field Summary

Fields inherited from class io.pkts.buffer.BaseBuffer

Constructor Summary

Method Summary

Methods inherited from class io.pkts.buffer.BaseBuffer

Methods inherited from class java.lang.Object

Methods inherited from interface io.pkts.buffer.Buffer

Field Detail

readerIndex

writerIndex

markedReaderIndex

lowerBoundary

upperBoundary

Constructor Detail

AbstractBuffer

Method Detail

clone

getLowerBoundary

getUpperBoundary

getReaderIndex

getWriterIndex

setWriterIndex

setReaderIndex

capacity

getWritableBytes

markReaderIndex

slice

slice

getReadableBytes

resetReaderIndex

checkIndex

checkWriterIndex

readUnsignedByte

hasWriteSupport

write

write

write

equals

hashCode