Buffer (Pkts Buffer Lib 3.0.10 API)

All Superinterfaces:

Cloneable

All Known Implementing Classes:

AbstractBuffer, BaseBuffer, BoundedInputStreamBuffer, ByteBuffer, EmptyBuffer, InputStreamBuffer
```
public interface Buffer
extends Cloneable
```
Yet another buffer class! Kind of the same as the awesome classes in netty.io but currently the buffer classes in netty are a little too tied into the rest of the netty stack. Therefore, copy-pasting the necessary pieces needed for this project. Also, since this entire project (i.e. yajpcap) is only for one particular use case, we don't need all the flexibility of netty's buffers, even though somewhat silly to re-invent the wheel.

Author:

jonas@jonasborjesson.com

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`capacity()` The capacity of this buffer.
`Buffer`	`clone()` Performs a deep clone of this object.
`String`	`dumpAsHex()` Dump the content of this buffer as a hex dump ala Wireshark.
`boolean`	`equals(Object b)` Check whether to buffers are considered to be equal.
`boolean`	`equalsIgnoreCase(Object b)`
`byte[]`	`getArray()` Get the backing array.
`default boolean`	`getBit(int byteIndex, int bitNo)` Check whether a particular bit within a byte is on or off.
`default boolean`	`getBit0(int index)`
`default boolean`	`getBit1(int index)`
`default boolean`	`getBit2(int index)`
`default boolean`	`getBit3(int index)`
`default boolean`	`getBit4(int index)`
`default boolean`	`getBit5(int index)`
`default boolean`	`getBit6(int index)`
`default boolean`	`getBit7(int index)`
`default void`	`getByes(byte[] dst)` Deprecated. Please use `getBytes(byte[])` instead
`byte`	`getByte(int index)` Get the byte at the index.
`void`	`getBytes(Buffer dst)` Same as calling `getBytes(int, Buffer)` where the index is `getReaderIndex()`.
`void`	`getBytes(byte[] dst)`
`void`	`getBytes(int index, Buffer dst)` Transfer this buffer's data to the destination buffer.
`int`	`getInt(int index)` Get a 32-bit integer at the specified absolute index.
`int`	`getLowerBoundary()` If you access the `getRawArray()` you will get just that.
`default byte[]`	`getRawArray()`
`int`	`getReadableBytes()` Returns the number of available bytes for reading without blocking.
`int`	`getReaderIndex()` The reader index
`short`	`getShort(int index)`
`short`	`getUnsignedByte(int index)`
`long`	`getUnsignedInt(int index)`
`int`	`getUnsignedShort(int index)`
`int`	`getUpperBoundary()` See explanation in `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.
`int`	`hashCode()`
`boolean`	`hasReadableBytes()` Checks whether this buffer has any bytes available for reading without blocking.
`boolean`	`hasWritableBytes()` Checks whether this `Buffer` has any space left for writing.
`boolean`	`hasWriteSupport()` Check whether this `Buffer` has write support or not.
`int`	`indexOf(byte b)`
`int`	`indexOf(int maxBytes, byte... bytes)` Same as `readUntil(int, byte...)` but instead of returning the buffer with everything up until the specified byte it returns the index instead.
`boolean`	`isEmpty()` Check whether this buffer is empty or not.
`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)` Convert the entire buffer to a signed integer value
`byte`	`peekByte()` Peak a head to see what the next byte is.
`byte`	`readByte()` Read the next byte, which will also increase the readerIndex by one.
`Buffer`	`readBytes(int length)` Read the requested number of bytes and increase the readerIndex with the corresponding number of bytes.
`int`	`readInt()` Read an int and will increase the reader index of this buffer by 4
`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`	`readShort()`
`short`	`readUnsignedByte()`
`long`	`readUnsignedInt()` Read an unsigned int and will increase the reader index of this buffer by 4
`int`	`readUnsignedShort()`
`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.
`Buffer`	`readUntilSafe(int maxBytes, byte... bytes)` Same as `readUntil(int, byte...)` but will return null instead of throwing a `ByteNotFoundException`
`Buffer`	`readUntilSingleCRLF()` Read until we find a single 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`	`setByte(int index, byte value)` Set the byte at given index to a new value
`void`	`setInt(int index, int value)`
`void`	`setReaderIndex(int index)`
`void`	`setUnsignedByte(int index, short value)`
`void`	`setUnsignedInt(int index, long value)`
`void`	`setUnsignedShort(int index, int value)`
`void`	`setWriterIndex(int index)`
`Buffer`	`slice()` Slice off the rest of the buffer.
`Buffer`	`slice(int stop)` Same as `#slice(Buffer.getReaderIndex(), int)`
`Buffer`	`slice(int start, int stop)` Get a slice of the buffer starting at `start` (inclusive) ending at `stop` (exclusive).
`String`	`toString()`
`static long`	`unsignedInt(byte a, byte b, byte c, byte d)` Helper method to "parse" out a unsigned int from the given 4 bytes.
`void`	`write(byte b)` Write a byte to where the current writer index is pointing.
`void`	`write(byte[] bytes)`
`void`	`write(int value)`
`void`	`write(long value)`
`void`	`write(String s)` Same as `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.
`void`	`writeAsString(int value)` Write the integer value to this `Buffer` as a String.
`void`	`writeAsString(long value)` Write the long value to this `Buffer` as a String.

- Method Detail
  - unsignedInt
```
static long unsignedInt(byte a,
                        byte b,
                        byte c,
                        byte d)
```
    Helper method to "parse" out a unsigned int from the given 4 bytes.
    
    Parameters:
    
    a -
    
    b -
    
    c -
    
    d -
    
    Returns:
  - getBytes
```
void getBytes(Buffer dst)
```
    Same as calling getBytes(int, Buffer) where the index is getReaderIndex().
    
    Parameters:
    
    dst -
    
    Throws:
    
    IndexOutOfBoundsException
  - getBytes
```
void getBytes(int index,
              Buffer dst)
       throws IndexOutOfBoundsException
```
    Transfer this buffer's data to the destination buffer. This method does not change the readerIndex or the writerIndex of the src buffer (i.e. this) but will increase the writerIndex of the destination buffer.
    
    Parameters:
    
    index -
    
    dst -
    
    Throws:
    
    IndexOutOfBoundsException - in case index < 0
  - getBytes
```
void getBytes(byte[] dst)
       throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getByes
```
@Deprecated
default void getByes(byte[] dst)
                          throws IndexOutOfBoundsException
```
    Deprecated. Please use getBytes(byte[]) instead
    
    Throws:
    
    IndexOutOfBoundsException
    
    See Also:
    
    getBytes(byte[])
  - readBytes
```
Buffer readBytes(int length)
          throws IndexOutOfBoundsException,
                 IOException
```
    Read the requested number of bytes and increase the readerIndex with the corresponding number of bytes. The new buffer and this buffer both share the same backing array so changing either one of them will affect the other.
    
    Parameters:
    
    length -
    
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - readLine
```
Buffer readLine()
         throws 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.
    
    Returns:
    
    a buffer containing the line but without the line terminating characters
    
    Throws:
    
    IOException
  - readUntilSingleCRLF
```
Buffer readUntilSingleCRLF()
                    throws IOException
```
    Read until we find a single CRLF. The single CRLF will NOT be part of the returned buffer but will be consumed. If we cannot find a single 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. Note that this one is very similar to readLine() but the readLine doesn't enforce the CRLF being present, which is typical for e.g. SIP and is important when reading bytes being streamed over e.g. a network connection
    
    Returns:
    
    the resulting buffer containing everything up until (but not inclusive) the single-crlf or null if no single-crlf was not found.
    
    Throws:
    
    IOException
  - readUntilDoubleCRLF
```
Buffer readUntilDoubleCRLF()
                    throws IOException
```
    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.
    
    Returns:
    
    the resulting buffer containing everything up until (but not inclusive) the double-crlf or null if no double-crlf was not found.
    
    Throws:
    
    IOException
  - getReadableBytes
```
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:
  - hasReadableBytes
```
boolean hasReadableBytes()
```
    Checks whether this buffer has any bytes available for reading without blocking. This is the same as getReadableBytes() > 0
    
    Returns:
  - isEmpty
```
boolean isEmpty()
```
    Check whether this buffer is empty or not. This is the same as !hasReadableBytes()
    
    Returns:
  - getArray
```
byte[] getArray()
```
    Get the backing array.
    
    Returns:
  - getRawArray
```
default byte[] getRawArray()
```
  - getBit
```
default boolean getBit(int byteIndex,
                       int bitNo)
                throws IllegalArgumentException
```
    Check whether a particular bit within a byte is on or off.
    
    Parameters:
    
    byteIndex - the index of the byte we are going to check.
    
    bitNo - the bit no, which is zero indexed and of course needs to be within 0 to 7.
    
    Returns:
    
    Throws:
    
    IllegalArgumentException - in case the bit number is not between 0-7 (inclusive).
  - getBit0
```
default boolean getBit0(int index)
```
  - getBit1
```
default boolean getBit1(int index)
```
  - getBit2
```
default boolean getBit2(int index)
```
  - getBit3
```
default boolean getBit3(int index)
```
  - getBit4
```
default boolean getBit4(int index)
```
  - getBit5
```
default boolean getBit5(int index)
```
  - getBit6
```
default boolean getBit6(int index)
```
  - getBit7
```
default boolean getBit7(int index)
```
  - readUntil
```
Buffer readUntil(byte b)
          throws 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 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".
    
    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.
    
    IOException
  - readUntil
```
Buffer readUntil(int maxBytes,
                 byte... bytes)
          throws IOException,
                 ByteNotFoundException,
                 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 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
    
    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:
    
    IOException
    
    ByteNotFoundException - in case none of the bytes we were looking for are found within the specified maximum number of bytes.
    
    IllegalArgumentException - in no bytes to look for is specified.
  - readUntilSafe
```
Buffer readUntilSafe(int maxBytes,
                     byte... bytes)
              throws IOException,
                     IllegalArgumentException
```
    Same as readUntil(int, byte...) but will return null instead of throwing a ByteNotFoundException
    
    Parameters:
    
    maxBytes -
    
    bytes -
    
    Returns:
    
    Throws:
    
    IOException
    
    IllegalArgumentException
  - indexOf
```
int indexOf(int maxBytes,
            byte... bytes)
     throws IOException,
            ByteNotFoundException,
            IllegalArgumentException
```
    Same as 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:
    
    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:
    
    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.
    
    IllegalArgumentException
  - indexOf
```
int indexOf(byte b)
     throws IOException,
            ByteNotFoundException,
            IllegalArgumentException
```
    Parameters:
    
    b -
    
    Returns:
    
    Throws:
    
    IOException
    
    ByteNotFoundException
    
    IllegalArgumentException
  - slice
```
Buffer slice(int start,
             int stop)
```
    Get a slice of the buffer starting at start (inclusive) ending at stop (exclusive). Hence, the new capacity of the buffer is stop - start
    
    Returns:
  - slice
```
Buffer slice(int stop)
```
    Same as #slice(Buffer.getReaderIndex(), int)
    
    Parameters:
    
    stop -
    
    Returns:
  - slice
```
Buffer slice()
```
    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:
  - getLowerBoundary
```
int getLowerBoundary()
```
    If you access the 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
```
int getUpperBoundary()
```
    See explanation in getLowerBoundary() since this is the same, just the upper limit of that raw array.
    
    Returns:
  - getReaderIndex
```
int getReaderIndex()
```
    The reader index
    
    Returns:
  - setReaderIndex
```
void setReaderIndex(int index)
```
  - markReaderIndex
```
void markReaderIndex()
```
    Mark the current position of the reader index.
    
    See Also:
    
    #reset()
  - resetReaderIndex
```
void resetReaderIndex()
```
    Reset the reader index to the marked position or to the beginning of the buffer if mark hasn't explicitly been called.
  - capacity
```
int capacity()
```
    The capacity of this buffer. The capacity is not affected by where the reader index is etc
    
    Returns:
    
    the capacity
  - getByte
```
byte getByte(int index)
      throws IndexOutOfBoundsException,
             IOException
```
    Get the byte at the index. Note, depending on the underlying implementing buffer, this method may block and try and read the missing bytes off a stream. E.g., the InputStreamBuffer gets its bytes off of a InputStream so let's say you have read 10 bytes off of the stream already but ask to access the byte at index 20, we will try and ready an additional 10 bytes from the InputStream so we can return the byte at index 20.
    
    Parameters:
    
    index -
    
    Returns:
    
    the byte at the specified index
    
    Throws:
    
    IndexOutOfBoundsException - in case the index is greater than the capacity of this buffer
    
    IOException
  - readByte
```
byte readByte()
       throws IndexOutOfBoundsException,
              IOException
```
    Read the next byte, which will also increase the readerIndex by one.
    
    Returns:
    
    the next byte
    
    Throws:
    
    IndexOutOfBoundsException - in case there is nothing left to read
    
    IOException
  - peekByte
```
byte peekByte()
       throws IndexOutOfBoundsException,
              IOException
```
    Peak a head to see what the next byte is. This method will not change the readerIndex
    
    Returns:
    
    the next byte
    
    Throws:
    
    IndexOutOfBoundsException - in case there is nothing left to read
    
    IOException
  - readUnsignedInt
```
long readUnsignedInt()
              throws IndexOutOfBoundsException
```
    Read an unsigned int and will increase the reader index of this buffer by 4
    
    Returns:
    
    a long representing the unsigned int
    
    Throws:
    
    IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - readInt
```
int readInt()
     throws IndexOutOfBoundsException
```
    Read an int and will increase the reader index of this buffer by 4
    
    Returns:
    
    the int value
    
    Throws:
    
    IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - getInt
```
int getInt(int index)
    throws IndexOutOfBoundsException
```
    Get a 32-bit integer at the specified absolute index. This method will not modify the readerIndex of this buffer.
    
    Parameters:
    
    index -
    
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - setInt
```
void setInt(int index,
            int value)
     throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - setUnsignedInt
```
void setUnsignedInt(int index,
                    long value)
             throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getShort
```
short getShort(int index)
        throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - readUnsignedShort
```
int readUnsignedShort()
               throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getUnsignedShort
```
int getUnsignedShort(int index)
              throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - setUnsignedShort
```
void setUnsignedShort(int index,
                      int value)
               throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - readShort
```
short readShort()
         throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - readUnsignedByte
```
short readUnsignedByte()
                throws IndexOutOfBoundsException,
                       IOException
```
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - getUnsignedInt
```
long getUnsignedInt(int index)
             throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getUnsignedByte
```
short getUnsignedByte(int index)
               throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - setUnsignedByte
```
void setUnsignedByte(int index,
                     short value)
              throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - parseToInt
```
int parseToInt()
        throws NumberFormatException,
               IOException
```
    Parse all the readable bytes in this buffer as a unsigned integer value. The reader index will not be modified.
    
    Returns:
    
    Throws:
    
    NumberFormatException - in case the bytes in the buffer cannot be converted into an integer value.
    
    IOException - in case anything goes wrong when reading from the underlying
  - parseToInt
```
int parseToInt(int radix)
        throws NumberFormatException,
               IOException
```
    Convert the entire buffer to a signed integer value
    
    Parameters:
    
    radix -
    
    Returns:
    
    Throws:
    
    NumberFormatException
    
    IOException
  - dumpAsHex
```
String dumpAsHex()
```
    Dump the content of this buffer as a hex dump ala Wireshark. Mainly for debugging purposes
    
    Returns:
  - clone
```
Buffer clone()
```
    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.
    
    Returns:
  - setByte
```
void setByte(int index,
             byte value)
      throws IndexOutOfBoundsException
```
    Set the byte at given index to a new value
    
    Parameters:
    
    index - the index
    
    value - the value
    
    Throws:
    
    IndexOutOfBoundsException
  - getWriterIndex
```
int getWriterIndex()
```
    The writer index. This is where we will be writing our next byte if asked to do so.
    
    Returns:
  - setWriterIndex
```
void setWriterIndex(int index)
```
  - getWritableBytes
```
int getWritableBytes()
```
    Get the number of writable bytes.
    
    Returns:
  - hasWritableBytes
```
boolean hasWritableBytes()
```
    Checks whether this Buffer has any space left for writing. Same as getWritableBytes() > 0
    
    Returns:
  - hasWriteSupport
```
boolean hasWriteSupport()
```
    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
```
void write(byte b)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException
```
    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
    
    Parameters:
    
    b -
    
    Throws:
    
    IndexOutOfBoundsException - in case there is no more space to write to (which includes those cases where the underlying implementation does not support writing)
    
    WriteNotSupportedException - in case the underlying implementation does not support writes.
  - write
```
void write(byte[] bytes)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
void write(int value)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
void write(long value)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
void write(String s)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException,
           UnsupportedEncodingException
```
    Same as write(String, String) where the charset is set to "UTF-8"
    
    Parameters:
    
    s -
    
    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.
  - writeAsString
```
void writeAsString(int value)
            throws IndexOutOfBoundsException,
                   WriteNotSupportedException
```
    Write the integer value to this Buffer as a String.
    
    Parameters:
    
    value - the value that will be converted to a String before being written to this Buffer.
    
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - writeAsString
```
void writeAsString(long value)
            throws IndexOutOfBoundsException,
                   WriteNotSupportedException
```
    Write the long value to this Buffer as a String.
    
    Parameters:
    
    value - the value that will be converted to a String before being written to this Buffer.
    
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
void write(String s,
           String charset)
    throws IndexOutOfBoundsException,
           WriteNotSupportedException,
           UnsupportedEncodingException
```
    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.
    
    Parameters:
    
    s -
    
    charset -
    
    Throws:
    
    IndexOutOfBoundsException - in case we cannot write entire String to this Buffer.
    
    WriteNotSupportedException
    
    UnsupportedEncodingException - in case the specified charset is not supported
  - equals
```
boolean equals(Object b)
```
    Check whether to buffers are considered to be equal. To buffers are equal if the underlying visible area of the byte array are equal.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    b -
    
    Returns:
  - equalsIgnoreCase
```
boolean equalsIgnoreCase(Object b)
```
  - hashCode
```
int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
String toString()
```
    Overrides:
    
    toString in class Object

Interface Buffer

Method Summary

Method Detail

unsignedInt

getBytes

getBytes

getBytes

getByes

readBytes

readLine

readUntilSingleCRLF

readUntilDoubleCRLF

getReadableBytes

hasReadableBytes

isEmpty

getArray

getRawArray

getBit

getBit0

getBit1

getBit2

getBit3

getBit4

getBit5

getBit6

getBit7

readUntil

readUntil

readUntilSafe

indexOf

indexOf

slice

slice

slice

getLowerBoundary

getUpperBoundary

getReaderIndex

setReaderIndex

markReaderIndex

resetReaderIndex

capacity

getByte

readByte

peekByte

readUnsignedInt

readInt

getInt

setInt

setUnsignedInt

getShort

readUnsignedShort

getUnsignedShort

setUnsignedShort

readShort

readUnsignedByte

getUnsignedInt

getUnsignedByte

setUnsignedByte

parseToInt

parseToInt

dumpAsHex

clone

setByte

getWriterIndex

setWriterIndex

getWritableBytes

hasWritableBytes

hasWriteSupport

write

write

write

write

write

writeAsString

writeAsString

write

equals

equalsIgnoreCase

hashCode

toString