io.pkts.buffer

Class BaseBuffer

java.lang.Object

io.pkts.buffer.BaseBuffer

All Implemented Interfaces:

Buffer, Cloneable

Direct Known Subclasses:

AbstractBuffer, BoundedInputStreamBuffer

public abstract class BaseBuffer
extends Object
implements Buffer

Abstract abstract buffer :-)

Author:

jonas@jonasborjesson.com

Field Summary

Fields

Modifier and Type	Field and Description
protected static byte	CR
protected static byte	LF

Constructor Summary

Constructors

Constructor and Description
BaseBuffer()

Method Summary

Modifier and Type	Method and Description
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.
abstract Buffer	clone() Performs a deep clone of this object.
boolean	hasWritableBytes() Checks whether this Buffer has any space left for writing.
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.
protected static boolean	isByteInArray(byte b, byte[] bytes)
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.
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 Buffer.readUntil(int, byte...) but will return null instead of throwing a ByteNotFoundException
Buffer	readUntilSingleCRLF() Read until we find a single CRLF.

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.pkts.buffer.Buffer

capacity, dumpAsHex, equals, equalsIgnoreCase, getArray, getBit, getBit0, getBit1, getBit2, getBit3, getBit4, getBit5, getBit6, getBit7, getByes, getByte, getBytes, getBytes, getBytes, getInt, getLowerBoundary, getRawArray, getReadableBytes, getReaderIndex, getShort, getUnsignedByte, getUnsignedInt, getUnsignedShort, getUpperBoundary, getWritableBytes, getWriterIndex, hashCode, hasReadableBytes, hasWriteSupport, isEmpty, markReaderIndex, peekByte, readByte, readBytes, readInt, readShort, readUnsignedByte, readUnsignedInt, readUnsignedShort, resetReaderIndex, setByte, setInt, setReaderIndex, setUnsignedByte, setUnsignedInt, setUnsignedShort, setWriterIndex, slice, slice, slice, toString, unsignedInt, write, write, write, write, write, write, writeAsString, writeAsString

Field Detail

LF

protected static final byte LF

See Also:

Constant Field Values

CR

protected static final byte CR

See Also:

Constant Field Values

Constructor Detail

BaseBuffer

public BaseBuffer()

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 Object

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:

checkWritableBytesSafe

protected boolean checkWritableBytesSafe(int length)

Check whether we have enough space for writing the desired length.

Parameters:

length -

Returns:

checkReadableBytes

protected void checkReadableBytes(int length)
                           throws IndexOutOfBoundsException

Convenience method for checking if we have enough readable bytes

Parameters:

length - the length the user wishes to read

Throws:

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

readUntil

public final 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 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.

IOException

readUntil

public final 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 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:

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

public final Buffer readUntilSafe(int maxBytes,
                                  byte... bytes)
                           throws IOException,
                                  IllegalArgumentException

Same as Buffer.readUntil(int, byte...) but will return null instead of throwing a ByteNotFoundException

Specified by:

readUntilSafe in interface Buffer

Returns:

Throws:

IOException

IllegalArgumentException

indexOf

public final int indexOf(int maxBytes,
                         byte... bytes)
                  throws IOException,
                         ByteNotFoundException,
                         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:

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

public final int indexOf(byte b)
                  throws IOException,
                         ByteNotFoundException,
                         IllegalArgumentException

Specified by:

indexOf in interface Buffer

Returns:

Throws:

IOException

ByteNotFoundException

IllegalArgumentException

readLine

public final 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.

Specified by:

readLine in interface Buffer

Returns:

a buffer containing the line but without the line terminating characters

Throws:

IOException

readUntilSingleCRLF

public final 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 Buffer.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

Specified by:

readUntilSingleCRLF in interface Buffer

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

public final Buffer readUntilDoubleCRLF()
                                 throws 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:

IOException

parseToInt

public final int parseToInt()
                     throws NumberFormatException,
                            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:

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

public final int parseToInt(int radix)
                     throws NumberFormatException,
                            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:

radix - the radix to be used while parsing s.

Returns:

the integer represented by the string argument in the specified radix.

Throws:

NumberFormatException - if the String does not contain a parsable int.

IOException

isByteInArray

protected static boolean isByteInArray(byte b,
                                       byte[] bytes)