BoundedInputStreamBuffer (Pkts Buffer Lib 3.0.10 API)

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

All Implemented Interfaces:

Buffer, Cloneable
```
public class BoundedInputStreamBuffer
extends BaseBuffer
```
Author:

jonas@jonasborjesson.com

Field Summary

Fields
Modifier and Type Field and Description

static int DEFAULT_CAPACITY
The default capacity for each individual byte array, default to tcpdumps default snaplength.
- Fields inherited from class io.pkts.buffer.BaseBuffer
  CR, LF

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_CAPACITY` The default capacity for each individual byte array, default to tcpdumps default snaplength.

Constructor Summary

Constructors
Constructor and Description

BoundedInputStreamBuffer(InputStream is)

BoundedInputStreamBuffer(int bufferCapacity, InputStream is)

Constructors
Constructor and Description
`BoundedInputStreamBuffer(InputStream is)`
`BoundedInputStreamBuffer(int bufferCapacity, InputStream is)`

Method Summary

All Methods Instance Methods Concrete 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 other)` Check whether to buffers are considered to be equal.
`boolean`	`equalsIgnoreCase(Object other)`
`byte[]`	`getArray()` Get the backing array.
`byte`	`getByte(int index)` Get the byte at the index.
`byte`	`getByte(long index)`
`void`	`getBytes(Buffer dst)` Same as calling `Buffer.getBytes(int, Buffer)` where the index is `Buffer.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 `Buffer.getRawArray()` you will get just that.
`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 `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.
`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.
`boolean`	`isEmpty()` Check whether this buffer is empty or not.
`void`	`markReaderIndex()` Mark the current position of the reader index.
`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
`short`	`readShort()`
`short`	`readUnsignedByte()`
`long`	`readUnsignedInt()` Read an unsigned int and will increase the reader index of this buffer by 4
`int`	`readUnsignedShort()`
`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()`
`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 `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.
`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 io.pkts.buffer.BaseBuffer
checkReadableBytes, checkReadableBytesSafe, checkWritableBytesSafe, indexOf, indexOf, isByteInArray, parseToInt, parseToInt, readLine, readUntil, readUntil, readUntilDoubleCRLF, readUntilSafe, readUntilSingleCRLF

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

Methods inherited from interface io.pkts.buffer.Buffer
getBit, getBit0, getBit1, getBit2, getBit3, getBit4, getBit5, getBit6, getBit7, getByes, getRawArray, unsignedInt

- Field Detail
  - DEFAULT_CAPACITY
```
public static final int DEFAULT_CAPACITY
```
    The default capacity for each individual byte array, default to tcpdumps default snaplength.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - BoundedInputStreamBuffer
```
public BoundedInputStreamBuffer(InputStream is)
```
  - BoundedInputStreamBuffer
```
public BoundedInputStreamBuffer(int bufferCapacity,
                                InputStream is)
```
    Parameters:
    
    bufferCapacity - To be sure that the PCAP framer works, this needs to be same or larger than SNAPLENGTH used to get PCAP. Default SNAPLENGTH of tcpdump is 262144. If using '-s NNN' parameter of tcpdump, you should also be able to reduce this to a lower value for less memory usage.
    
    is -
- Method Detail
  - 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
    
    Returns:
  - readByte
```
public byte readByte()
              throws IndexOutOfBoundsException,
                     IOException
```
    Read the next byte, which will also increase the readerIndex by one.
    
    Returns:
    
    the next byte
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException - in case there is nothing left to read
  - peekByte
```
public 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
  - readBytes
```
public 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.
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - 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:
  - hasReadableBytes
```
public boolean hasReadableBytes()
```
    Checks whether this buffer has any bytes available for reading without blocking. This is the same as Buffer.getReadableBytes() > 0
    
    Returns:
    
    Throws:
    
    IOException
    
    IndexOutOfBoundsException
  - isEmpty
```
public boolean isEmpty()
```
    Check whether this buffer is empty or not. This is the same as !Buffer.hasReadableBytes()
    
    Returns:
  - getArray
```
public byte[] getArray()
```
    Get the backing array.
    
    Returns:
  - getByte
```
public 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.
    
    Returns:
    
    the byte at the specified index
    
    Throws:
    
    IndexOutOfBoundsException - in case the index is greater than the capacity of this buffer
    
    IOException
  - getByte
```
public byte getByte(long index)
             throws IndexOutOfBoundsException,
                    IOException
```
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - readUnsignedInt
```
public 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
```
public 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
```
public 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.
    
    Returns:
    
    Throws:
    
    IndexOutOfBoundsException - in case there is not 4 bytes left to read
  - getShort
```
public short getShort(int index)
               throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - readUnsignedShort
```
public int readUnsignedShort()
                      throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getUnsignedShort
```
public int getUnsignedShort(int index)
                     throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - readShort
```
public short readShort()
                throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getUnsignedInt
```
public long getUnsignedInt(int index)
                    throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getUnsignedByte
```
public short getUnsignedByte(int index)
                      throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - dumpAsHex
```
public String dumpAsHex()
```
    Dump the content of this buffer as a hex dump ala Wireshark. Mainly for debugging purposes
    
    Returns:
  - setByte
```
public 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
  - setUnsignedByte
```
public void setUnsignedByte(int index,
                            short value)
                     throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - setUnsignedShort
```
public void setUnsignedShort(int index,
                             int value)
                      throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - clone
```
public 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:
  - equals
```
public boolean equals(Object other)
```
    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
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(Object other)
```
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Buffer
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface Buffer
    
    Overrides:
    
    toString in class Object
  - getWritableBytes
```
public int getWritableBytes()
```
    Description copied from interface: Buffer
    
    Get the number of writable bytes.
    
    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
    
    Overrides:
    
    hasWritableBytes in class BaseBuffer
    
    Returns:
  - write
```
public void write(byte[] bytes)
           throws IndexOutOfBoundsException,
                  WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - getBytes
```
public void getBytes(Buffer dst)
```
    Description copied from interface: Buffer
    
    Same as calling Buffer.getBytes(int, Buffer) where the index is Buffer.getReaderIndex().
  - getBytes
```
public void getBytes(byte[] dst)
              throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - getBytes
```
public void getBytes(int index,
                     Buffer dst)
              throws 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.
    
    Throws:
    
    IndexOutOfBoundsException - in case index < 0
  - setInt
```
public void setInt(int index,
                   int value)
            throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - write
```
public void write(int value)
           throws IndexOutOfBoundsException,
                  WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - write
```
public void write(long value)
           throws IndexOutOfBoundsException,
                  WriteNotSupportedException
```
    Throws:
    
    IndexOutOfBoundsException
    
    WriteNotSupportedException
  - writeAsString
```
public void writeAsString(int value)
                   throws IndexOutOfBoundsException,
                          WriteNotSupportedException
```
    Description copied from interface: Buffer
    
    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
```
public void writeAsString(long value)
                   throws IndexOutOfBoundsException,
                          WriteNotSupportedException
```
    Description copied from interface: Buffer
    
    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
  - setUnsignedInt
```
public void setUnsignedInt(int index,
                           long value)
                    throws IndexOutOfBoundsException
```
    Throws:
    
    IndexOutOfBoundsException
  - 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
  - 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.
    
    Returns:
  - setWriterIndex
```
public void setWriterIndex(int index)
```
  - setReaderIndex
```
public void setReaderIndex(int index)
```
  - getReaderIndex
```
public int getReaderIndex()
```
    Description copied from interface: Buffer
    
    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:
  - readUnsignedByte
```
public final short readUnsignedByte()
                             throws IndexOutOfBoundsException,
                                    IOException
```
    Throws:
    
    IndexOutOfBoundsException
    
    IOException
  - capacity
```
public int capacity()
```
    Description copied from interface: Buffer
    
    The capacity of this buffer. The capacity is not affected by where the reader index is etc
    
    Returns:
    
    the capacity
  - resetReaderIndex
```
public void resetReaderIndex()
```
    Description copied from interface: Buffer
    
    Reset the reader index to the marked position or to the beginning of the buffer if mark hasn't explicitly been called.
  - markReaderIndex
```
public void markReaderIndex()
```
    Description copied from interface: Buffer
    
    Mark the current position of the reader index.
    
    See Also:
    
    #reset()
  - 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:
  - slice
```
public Buffer slice(int stop)
```
    Description copied from interface: Buffer
    
    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:

Class BoundedInputStreamBuffer

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

DEFAULT_CAPACITY

Constructor Detail

BoundedInputStreamBuffer

BoundedInputStreamBuffer

Method Detail

slice

readByte

peekByte

readBytes

getReadableBytes

hasReadableBytes

isEmpty

getArray

getByte

getByte

readUnsignedInt

readInt

getInt

getShort

readUnsignedShort

getUnsignedShort

readShort

getUnsignedInt

getUnsignedByte

dumpAsHex

setByte

setUnsignedByte

setUnsignedShort

clone

equals

equalsIgnoreCase

hashCode

toString

getWritableBytes

hasWritableBytes

write

getBytes

getBytes

getBytes

setInt

write

write

writeAsString

writeAsString

setUnsignedInt

write

write

write

hasWriteSupport

setWriterIndex

setReaderIndex

getReaderIndex

getWriterIndex

readUnsignedByte

capacity

resetReaderIndex

markReaderIndex

getLowerBoundary

getUpperBoundary

slice

slice