EmptyBuffer (Pkts Buffer Lib 1.0.2 API)

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

All Implemented Interfaces:

Buffer, java.lang.Cloneable
```
public class EmptyBuffer
extends java.lang.Object
implements Buffer
```
Represents an empty buffer.

Author:

jonas@jonasborjesson.com

Constructor Summary

Constructors
Modifier Constructor and Description

protected EmptyBuffer()

Constructors
Modifier	Constructor and Description
`protected`	`EmptyBuffer()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`capacity()` The capacity of this buffer.
`Buffer`	`clone()` Really nothing to clone so just return this since this `EmptyBuffer` is by definition immutable.
`java.lang.String`	`dumpAsHex()` Dump the content of this buffer as a hex dump ala Wireshark.
`boolean`	`equalsIgnoreCase(java.lang.Object other)`
`byte[]`	`getArray()` Get the backing array.
`byte`	`getByte(int index)` Get the byte at the index.
`void`	`getBytes(Buffer dst)` Same as calling `Buffer.getBytes(int, Buffer)` where the index is `Buffer.getReaderIndex()`.
`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`	`getReadableBytes()` Returns the number of available bytes for reading without blocking.
`int`	`getReaderIndex()` The reader index
`short`	`getShort(int index)`
`short`	`getUnsignedByte(int index)`
`int`	`getUnsignedShort(int index)`
`int`	`getWritableBytes()` Get the number of writable bytes.
`int`	`getWriterIndex()` The writer index.
`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 `Buffer.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.
`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)`
`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).
`java.lang.String`	`toString()`
`void`	`write(byte b)` Write a byte to where the current writer index is pointing.
`void`	`write(int value)`
`void`	`write(long value)`
`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.
`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.

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

Methods inherited from interface io.pkts.buffer.Buffer
equals, hashCode

- Constructor Detail
  - EmptyBuffer
```
protected EmptyBuffer()
```
- Method Detail
  - readBytes
```
public Buffer readBytes(int length)
                 throws java.lang.IndexOutOfBoundsException,
                        java.io.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.
    
    Specified by:
    
    readBytes in interface Buffer
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    java.io.IOException
  - 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
  - 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:
  - hasReadableBytes
```
public boolean hasReadableBytes()
```
    Checks whether this buffer has any bytes available for reading without blocking. This is the same as #readableBytes > 0
    
    Specified by:
    
    hasReadableBytes in interface Buffer
    
    Returns:
  - isEmpty
```
public boolean isEmpty()
```
    Check whether this buffer is empty or not. This is the same as !Buffer.hasReadableBytes()
    
    Specified by:
    
    isEmpty in interface Buffer
    
    Returns:
  - getArray
```
public byte[] getArray()
```
    Get the backing array.
    
    Specified by:
    
    getArray in interface Buffer
    
    Returns:
  - 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
  - slice
```
public 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
    
    Specified by:
    
    slice in interface Buffer
    
    Returns:
  - slice
```
public Buffer slice(int stop)
```
    Same as #slice(Buffer.getReaderIndex(), int)
    
    Specified by:
    
    slice in interface Buffer
    
    Returns:
  - slice
```
public 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.
    
    Specified by:
    
    slice in interface Buffer
    
    Returns:
  - getReaderIndex
```
public int getReaderIndex()
```
    The reader index
    
    Specified by:
    
    getReaderIndex 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()
  - 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
  - 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
  - getByte
```
public byte getByte(int index)
             throws java.lang.IndexOutOfBoundsException,
                    java.io.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.
    
    Specified by:
    
    getByte in interface Buffer
    
    Returns:
    
    the byte at the specified index
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case the index is greater than the capacity of this buffer
    
    java.io.IOException
  - readByte
```
public byte readByte()
              throws java.lang.IndexOutOfBoundsException,
                     java.io.IOException
```
    Read the next byte, which will also increase the readerIndex by one.
    
    Specified by:
    
    readByte in interface Buffer
    
    Returns:
    
    the next byte
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case there is nothing left to read
    
    java.io.IOException
  - readUnsignedInt
```
public long readUnsignedInt()
                     throws java.lang.IndexOutOfBoundsException
```
    Read an unsigned int and will increase the reader index of this buffer by 4
    
    Specified by:
    
    readUnsignedInt in interface Buffer
    
    Returns:
    
    a long representing the unsigned int
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - readInt
```
public int readInt()
            throws java.lang.IndexOutOfBoundsException
```
    Read an int and will increase the reader index of this buffer by 4
    
    Specified by:
    
    readInt in interface Buffer
    
    Returns:
    
    the int value
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - getInt
```
public int getInt(int index)
           throws java.lang.IndexOutOfBoundsException
```
    Get a 32-bit integer at the specified absolute index. This method will not modify the readerIndex of this buffer.
    
    Specified by:
    
    getInt in interface Buffer
    
    Returns:
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - getShort
```
public short getShort(int index)
               throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    getShort in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - readUnsignedShort
```
public int readUnsignedShort()
                      throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    readUnsignedShort in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - getUnsignedShort
```
public int getUnsignedShort(int index)
                     throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    getUnsignedShort in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - readShort
```
public short readShort()
                throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    readShort in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - readUnsignedByte
```
public short readUnsignedByte()
                       throws java.lang.IndexOutOfBoundsException,
                              java.io.IOException
```
    Specified by:
    
    readUnsignedByte in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    java.io.IOException
  - getUnsignedByte
```
public short getUnsignedByte(int index)
                      throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    getUnsignedByte in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - dumpAsHex
```
public java.lang.String dumpAsHex()
```
    Dump the content of this buffer as a hex dump ala Wireshark. Mainly for debugging purposes
    
    Specified by:
    
    dumpAsHex in interface Buffer
    
    Returns:
  - setByte
```
public void setByte(int index,
                    byte value)
             throws java.lang.IndexOutOfBoundsException
```
    Set the byte at given index to a new value
    
    Specified by:
    
    setByte in interface Buffer
    
    Parameters:
    
    index - the index
    
    value - the value
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - setUnsignedByte
```
public void setUnsignedByte(int index,
                            short value)
                     throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    setUnsignedByte in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - setUnsignedShort
```
public void setUnsignedShort(int index,
                             int value)
                      throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    setUnsignedShort in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - clone
```
public Buffer clone()
```
    Really nothing to clone so just return this since this EmptyBuffer is by definition immutable. 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:
  - toString
```
public java.lang.String toString()
```
    Specified by:
    
    toString in interface Buffer
    
    Overrides:
    
    toString in class java.lang.Object
  - peekByte
```
public byte peekByte()
              throws java.lang.IndexOutOfBoundsException,
                     java.io.IOException
```
    Description copied from interface: Buffer
    
    Peak a head to see what the next byte is. This method will not change the readerIndex
    
    Specified by:
    
    peekByte in interface Buffer
    
    Returns:
    
    the next byte
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case there is nothing left to read
    
    java.io.IOException
  - readUntil
```
public Buffer readUntil(int maxBytes,
                        byte... bytes)
                 throws java.io.IOException,
                        ByteNotFoundException
```
    Description copied from interface: Buffer
    
    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.
  - indexOf
```
public int indexOf(int maxBytes,
                   byte... bytes)
            throws java.io.IOException,
                   ByteNotFoundException,
                   java.lang.IllegalArgumentException
```
    Description copied from interface: Buffer
    
    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
  - 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
  - setReaderIndex
```
public void setReaderIndex(int index)
```
    Specified by:
    
    setReaderIndex in interface Buffer
  - 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
```
    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.
  - 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
  - write
```
public void write(int value)
           throws java.lang.IndexOutOfBoundsException,
                  WriteNotSupportedException
```
    Specified by:
    
    write in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
public void write(long value)
           throws java.lang.IndexOutOfBoundsException,
                  WriteNotSupportedException
```
    Specified by:
    
    write in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    WriteNotSupportedException
  - writeAsString
```
public void writeAsString(int value)
                   throws java.lang.IndexOutOfBoundsException,
                          WriteNotSupportedException
```
    Description copied from interface: Buffer
    
    Write the integer value to this Buffer as a String.
    
    Specified by:
    
    writeAsString in interface Buffer
    
    Parameters:
    
    value - the value that will be converted to a String before being written to this Buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    WriteNotSupportedException
  - writeAsString
```
public void writeAsString(long value)
                   throws java.lang.IndexOutOfBoundsException,
                          WriteNotSupportedException
```
    Description copied from interface: Buffer
    
    Write the long value to this Buffer as a String.
    
    Specified by:
    
    writeAsString in interface Buffer
    
    Parameters:
    
    value - the value that will be converted to a String before being written to this Buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
    
    WriteNotSupportedException
  - 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:
  - 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:
  - getBytes
```
public void getBytes(Buffer dst)
```
    Description copied from interface: Buffer
    
    Same as calling Buffer.getBytes(int, Buffer) where the index is Buffer.getReaderIndex().
    
    Specified by:
    
    getBytes in interface Buffer
  - getBytes
```
public void getBytes(int index,
                     Buffer dst)
              throws java.lang.IndexOutOfBoundsException
```
    Description copied from interface: Buffer
    
    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.
    
    Specified by:
    
    getBytes in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - in case index < 0
  - hasWriteSupport
```
public boolean hasWriteSupport()
```
    Description copied from interface: Buffer
    
    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:
  - setInt
```
public void setInt(int index,
                   int value)
            throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    setInt in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - parseToInt
```
public int parseToInt()
               throws java.lang.NumberFormatException
```
    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.
  - parseToInt
```
public int parseToInt(int radix)
```
    Description copied from interface: Buffer
    
    Convert the entire buffer to a signed integer value
    
    Specified by:
    
    parseToInt in interface Buffer
    
    Returns:
  - setUnsignedInt
```
public void setUnsignedInt(int index,
                           long value)
                    throws java.lang.IndexOutOfBoundsException
```
    Specified by:
    
    setUnsignedInt in interface Buffer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(java.lang.Object other)
```
    Specified by:
    
    equalsIgnoreCase in interface Buffer

Class EmptyBuffer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.pkts.buffer.Buffer

Constructor Detail

EmptyBuffer

Method Detail

readBytes

readLine

readUntilDoubleCRLF

getReadableBytes

hasReadableBytes

isEmpty

getArray

readUntil

slice

slice

slice

getReaderIndex

markReaderIndex

resetReaderIndex

capacity

getByte

readByte

readUnsignedInt

readInt

getInt

getShort

readUnsignedShort

getUnsignedShort

readShort

readUnsignedByte

getUnsignedByte

dumpAsHex

setByte

setUnsignedByte

setUnsignedShort

clone

toString

peekByte

readUntil

indexOf

indexOf

setReaderIndex

write

write

write

write

write

writeAsString

writeAsString

getWriterIndex

getWritableBytes

hasWritableBytes

getBytes

getBytes

hasWriteSupport

setInt

parseToInt

parseToInt

setUnsignedInt

equalsIgnoreCase