AbstractBuffer (Pkts Buffer Lib 1.0.2 API)

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

All Implemented Interfaces:

Buffer, java.lang.Cloneable

Direct Known Subclasses:

ByteBuffer, InputStreamBuffer
```
public abstract class AbstractBuffer
extends java.lang.Object
implements Buffer
```
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.

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`	`checkReadableBytes(int length)` Convenience method for checking if we have enough readable bytes
`protected boolean`	`checkReadableBytesSafe(int length)` Convenience method for checking if we have enough readable bytes
`protected boolean`	`checkWritableBytesSafe(int length)` Check whether we have enough space for writing the desired length.
`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(java.lang.Object other)` Check whether to buffers are considered to be equal.
`int`	`getReadableBytes()` Returns the number of available bytes for reading without blocking.
`int`	`getReaderIndex()` The reader index
`int`	`getWritableBytes()` Get the number of writable bytes.
`int`	`getWriterIndex()` The writer index.
`abstract int`	`hashCode()`
`boolean`	`hasWritableBytes()` Checks whether this `Buffer` has any space left for writing.
`boolean`	`hasWriteSupport()` The underlying subclass should override this if it has write support.
`int`	`indexOf(byte b)`
`int`	`indexOf(int maxBytes, byte... bytes)` Same as `Buffer.readUntil(int, byte...)` but instead of returning the buffer with everything up until the specified byte it returns the index instead.
`void`	`markReaderIndex()` Mark the current position of the reader index.
`int`	`parseToInt()` Parse all the readable bytes in this buffer as a unsigned integer value.
`int`	`parseToInt(int radix)` (Copied from the Integer class and slightly altered to read from this buffer instead of a String) Parses the string argument as a signed integer in the radix specified by the second argument.
`Buffer`	`readLine()` Reads a line, i.e., it reads until we hit a line feed ('\n') or a carriage return ('\r'), or a carriage return followed immediately by a line feed.
`short`	`readUnsignedByte()`
`Buffer`	`readUntil(byte b)` Same as `#readUntil(4096, b)` Read until the specified byte is encountered and return a buffer representing that section of the buffer.
`Buffer`	`readUntil(int maxBytes, byte... bytes)` Read until any of the specified bytes have been encountered or until we have read a maximum amount of bytes.
`Buffer`	`readUntilDoubleCRLF()` Read until we find a double CRLF.
`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)`
`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(java.lang.String s)` Same as `Buffer.write(String, String)` where the charset is set to "UTF-8"
`void`	`write(java.lang.String s, java.lang.String charset)` Write a string to this buffer using the specified charset to convert the String into bytes.

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, getByte, getBytes, getBytes, getInt, getShort, getUnsignedByte, getUnsignedShort, hasReadableBytes, isEmpty, peekByte, readByte, readBytes, readInt, readShort, readUnsignedInt, readUnsignedShort, setByte, setInt, setUnsignedByte, setUnsignedInt, setUnsignedShort, slice, toString, 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
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
  - getReaderIndex
```
public int getReaderIndex()
```
    The reader index
    
    Specified by:
    
    getReaderIndex in interface Buffer
    
    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.
    
    Specified by:
    
    getWriterIndex in interface Buffer
    
    Returns:
  - setReaderIndex
```
public void setReaderIndex(int index)
```
    Specified by:
    
    setReaderIndex in interface Buffer
  - capacity
```
public int capacity()
```
    The capacity of this buffer. The capacity is not affected by where the reader index is etc
    
    Specified by:
    
    capacity in interface Buffer
    
    Returns:
    
    the capacity
  - getWritableBytes
```
public int getWritableBytes()
```
    Description copied from interface: Buffer
    
    Get the number of writable bytes.
    
    Specified by:
    
    getWritableBytes in interface Buffer
    
    Returns:
  - hasWritableBytes
```
public boolean hasWritableBytes()
```
    Description copied from interface: Buffer
    
    Checks whether this Buffer has any space left for writing. Same as Buffer.getWritableBytes() > 0
    
    Specified by:
    
    hasWritableBytes in interface Buffer
    
    Returns:
  - markReaderIndex
```
public void markReaderIndex()
```
    Mark the current position of the reader index.
    
    Specified by:
    
    markReaderIndex in interface Buffer
    
    See Also:
    
    #reset()
  - slice
```
public Buffer slice(int stop)
```
    Same as #slice(Buffer.getReaderIndex(), int)
    
    Specified by:
    
    slice in interface Buffer
    
    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.
    
    Specified by:
    
    slice in interface Buffer
    
    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.
    
    Specified by:
    
    getReadableBytes in interface Buffer
    
    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.
    
    Specified by:
    
    resetReaderIndex in interface Buffer
  - readUntil
```
public Buffer readUntil(byte b)
                 throws java.io.IOException,
                        ByteNotFoundException
```
    Same as #readUntil(4096, b) Read until the specified byte is encountered and return a buffer representing that section of the buffer. If the byte isn't found, then a ByteNotFoundException is thrown and the Buffer.getReaderIndex() is left where we bailed out. Note, the byte we are looking for will have been consumed so whatever that is left in the Buffer will not contain that byte. Example: Buffer buffer = Buffers.wrap("hello world"); Buffer hello = buffer.readUntil((byte)' '); System.out.println(hello); // will contain "hello" System.out.println(buffer); // will contain "world" As the example above illustrates, we are looking for a space, which is found between "hello" and "world". Since the space will be consumed, the original buffer will now only contain "world" and not " world".
    
    Specified by:
    
    readUntil in interface Buffer
    
    Parameters:
    
    b - the byte to look for
    
    Returns:
    
    a buffer containing the content from the initial reader index to the the position where the byte was found (exclusive the byte we are looking for)
    
    Throws:
    
    ByteNotFoundException - in case the byte we were looking for is not found.
    
    java.io.IOException
  - readUntil
```
public Buffer readUntil(int maxBytes,
                        byte... bytes)
                 throws java.io.IOException,
                        ByteNotFoundException,
                        java.lang.IllegalArgumentException
```
    Read until any of the specified bytes have been encountered or until we have read a maximum amount of bytes. This one works exactly the same as Buffer.readUntil(byte) except it allows you to look for multiple bytes and to specify for how many bytes we should be looking before we give up. Example, we want to read until we either find
    
    Specified by:
    
    readUntil in interface Buffer
    
    Parameters:
    
    maxBytes - the maximum number of bytes we would like to read before giving up.
    
    bytes - the bytes we are looking for (either one of them)
    
    Returns:
    
    a buffer containing the content from the initial reader index to the the position where the byte was found (exclusive the byte we are looking for)
    
    Throws:
    
    java.io.IOException
    
    ByteNotFoundException - in case none of the bytes we were looking for are found within the specified maximum number of bytes.
    
    java.lang.IllegalArgumentException - in no bytes to look for is specified.
  - indexOf
```
public int indexOf(byte b)
            throws java.io.IOException,
                   ByteNotFoundException,
                   java.lang.IllegalArgumentException
```
    Specified by:
    
    indexOf in interface Buffer
    
    Returns:
    
    Throws:
    
    java.io.IOException
    
    ByteNotFoundException
    
    java.lang.IllegalArgumentException
  - indexOf
```
public int indexOf(int maxBytes,
                   byte... bytes)
            throws java.io.IOException,
                   ByteNotFoundException,
                   java.lang.IllegalArgumentException
```
    Same as Buffer.readUntil(int, byte...) but instead of returning the buffer with everything up until the specified byte it returns the index instead. NOTE. The index is representing where in the Buffer you can find the byte and the index is in relation to the entire Buffer and its capacity so even if you have already read x bytes, it would not change the index of what you search for. Example:
    
    Specified by:
    
    indexOf in interface Buffer
    
    Parameters:
    
    maxBytes - the maximum number of bytes we would like to read before giving up.
    
    bytes - the bytes we are looking for (either one of them)
    
    Returns:
    
    the index of the found byte or -1 (negative one) if we couldn't find it.
    
    Throws:
    
    java.io.IOException
    
    ByteNotFoundException - will ONLY be thrown if we haven't found the byte within the maxBytes limit. If the buffer we are searching in is less than maxBytes and we can't find what we are looking for then negative one will be returned instead.
    
    java.lang.IllegalArgumentException
  - readLine
```
public Buffer readLine()
                throws java.io.IOException
```
    Reads a line, i.e., it reads until we hit a line feed ('\n') or a carriage return ('\r'), or a carriage return followed immediately by a line feed.
    
    Specified by:
    
    readLine in interface Buffer
    
    Returns:
    
    a buffer containing the line but without the line terminating characters
    
    Throws:
    
    java.io.IOException
  - readUntilDoubleCRLF
```
public Buffer readUntilDoubleCRLF()
                           throws java.io.IOException
```
    Description copied from interface: Buffer
    
    Read until we find a double CRLF. The double CRLF will NOT be part of the returned buffer but they will be consumed. If we cannot find a double CRLF then null will be returned and the passed in buffer will be reset to the same reader index as when it was passed in.
    
    Specified by:
    
    readUntilDoubleCRLF in interface Buffer
    
    Returns:
    
    the resulting buffer containing everything up until (but not inclusive) the double-crlf or null if no double-crlf was not found.
    
    Throws:
    
    java.io.IOException
  - checkReadableBytes
```
protected void checkReadableBytes(int length)
                           throws java.lang.IndexOutOfBoundsException
```
    Convenience method for checking if we have enough readable bytes
    
    Parameters:
    
    length - the length the user wishes to read
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case we don't have the bytes available
  - checkReadableBytesSafe
```
protected boolean checkReadableBytesSafe(int length)
```
    Convenience method for checking if we have enough readable bytes
    
    Parameters:
    
    length - the length the user wishes to read
    
    Returns:
    
    true if we have enough bytes available for read
  - checkIndex
```
protected void checkIndex(int index)
                   throws java.lang.IndexOutOfBoundsException
```
    Convenience method for checking if we can read at the index
    
    Parameters:
    
    index -
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - checkWritableBytesSafe
```
protected boolean checkWritableBytesSafe(int length)
```
    Check whether we have enough space for writing the desired length.
    
    Parameters:
    
    length -
    
    Returns:
  - checkWriterIndex
```
protected void checkWriterIndex(int index)
                         throws java.lang.IndexOutOfBoundsException
```
    Convenience method for checking whether we can write at the specified index.
    
    Parameters:
    
    index -
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - readUnsignedByte
```
public final short readUnsignedByte()
                             throws java.lang.IndexOutOfBoundsException,
                                    java.io.IOException
```
    Specified by:
    
    readUnsignedByte in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    java.io.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.
    
    Specified by:
    
    hasWriteSupport in interface Buffer
    
    Returns:
  - write
```
public void write(byte b)
           throws java.lang.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
    
    Specified by:
    
    write in interface Buffer
    
    Throws:
    
    java.lang.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(java.lang.String s)
           throws java.lang.IndexOutOfBoundsException,
                  WriteNotSupportedException,
                  java.io.UnsupportedEncodingException
```
    Description copied from interface: Buffer
    
    Same as Buffer.write(String, String) where the charset is set to "UTF-8"
    
    Specified by:
    
    write in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case we cannot write entire String to this Buffer.
    
    WriteNotSupportedException - in case the underlying implementation does not support writes.
    
    java.io.UnsupportedEncodingException - in case the charset "UTF-8" is not supported by the platform.
  - write
```
public void write(java.lang.String s,
                  java.lang.String charset)
           throws java.lang.IndexOutOfBoundsException,
                  WriteNotSupportedException,
                  java.io.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.
    
    Specified by:
    
    write in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case we cannot write entire String to this Buffer.
    
    WriteNotSupportedException
    
    java.io.UnsupportedEncodingException - in case the specified charset is not supported
  - equals
```
public abstract boolean equals(java.lang.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 java.lang.Object
  - hashCode
```
public abstract int hashCode()
```
    Specified by:
    
    hashCode in interface Buffer
    
    Overrides:
    
    hashCode in class java.lang.Object
  - parseToInt
```
public int parseToInt()
               throws java.lang.NumberFormatException,
                      java.io.IOException
```
    Description copied from interface: Buffer
    
    Parse all the readable bytes in this buffer as a unsigned integer value. The reader index will not be modified.
    
    Specified by:
    
    parseToInt in interface Buffer
    
    Returns:
    
    Throws:
    
    java.lang.NumberFormatException - in case the bytes in the buffer cannot be converted into an integer value.
    
    java.io.IOException - in case anything goes wrong when reading from the underlying
  - parseToInt
```
public int parseToInt(int radix)
               throws java.lang.NumberFormatException,
                      java.io.IOException
```
    (Copied from the Integer class and slightly altered to read from this buffer instead of a String) Parses the string argument as a signed integer in the radix specified by the second argument. The characters in the string must all be digits of the specified radix (as determined by whether Character.digit(char, int) returns a nonnegative value), except that the first character may be an ASCII minus sign '-' ('\u002D') to indicate a negative value. The resulting integer value is returned.
    An exception of type NumberFormatException is thrown if any of the following situations occurs:
    - The first argument is null or is a string of length zero.
    - The radix is either smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX.
    - Any character of the string is not a digit of the specified radix, except that the first character may be a minus sign '-' ( '\u002D') provided that the string is longer than length 1.
    - The value represented by the string is not a value of type int.
    Examples:
    parseInt("0", 10) returns 0 parseInt("473", 10) returns 473 parseInt("-0", 10) returns 0 parseInt("-FF", 16) returns -255 parseInt("1100110", 2) returns 102 parseInt("2147483647", 10) returns 2147483647 parseInt("-2147483648", 10) returns -2147483648 parseInt("2147483648", 10) throws a NumberFormatException parseInt("99", 8) throws a NumberFormatException parseInt("Kona", 10) throws a NumberFormatException parseInt("Kona", 27) returns 411787
    Specified by:
    
    parseToInt in interface Buffer
    
    Parameters:
    
    s - the String containing the integer representation to be parsed
    
    radix - the radix to be used while parsing s.
    
    Returns:
    
    the integer represented by the string argument in the specified radix.
    
    Throws:
    
    java.lang.NumberFormatException - if the String does not contain a parsable int.
    
    java.io.IOException

Class AbstractBuffer

Field Summary

Constructor Summary

Method Summary

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

getReaderIndex

getWriterIndex

setReaderIndex

capacity

getWritableBytes

hasWritableBytes

markReaderIndex

slice

slice

getReadableBytes

resetReaderIndex

readUntil

readUntil

indexOf

indexOf

readLine

readUntilDoubleCRLF

checkReadableBytes

checkReadableBytesSafe

checkIndex

checkWritableBytesSafe

checkWriterIndex

readUnsignedByte

hasWriteSupport

write

write

write

equals

hashCode

parseToInt

parseToInt