public final class BufferUtils extends Object
Modifier and Type | Field and Description |
---|---|
static IntUnaryOperator |
DEFAULT_BUFFER_GROWTH_FACTOR |
static char |
DEFAULT_HEX_SEPARATOR |
static Level |
DEFAULT_HEXDUMP_LEVEL |
static char |
EMPTY_HEX_SEPARATOR |
static String |
HEX_DIGITS |
static long |
MAX_UINT32_VALUE
Maximum value of a
uint32 field |
static int |
MAX_UINT8_VALUE
Maximum value of a
uint8 field |
Modifier and Type | Method and Description |
---|---|
static <A extends Appendable> |
appendHex(A sb,
byte[] array,
int offset,
int len,
char sep) |
static <A extends Appendable> |
appendHex(A sb,
char sep,
byte... array) |
static <B extends Buffer> |
clear(B buffer)
Invokes
Buffer.clear() |
static byte[] |
decodeHex(char separator,
CharSequence csq) |
static byte[] |
decodeHex(char separator,
CharSequence csq,
int start,
int end) |
static <S extends OutputStream> |
decodeHex(S stream,
char separator,
CharSequence csq) |
static <S extends OutputStream> |
decodeHex(S stream,
char separator,
CharSequence csq,
int start,
int end) |
static void |
dumpHex(SimplifiedLog logger,
Level level,
String prefix,
char sep,
int chunkSize,
byte... data) |
static void |
dumpHex(SimplifiedLog logger,
Level level,
String prefix,
char sep,
int chunkSize,
byte[] data,
int offset,
int len) |
static void |
dumpHex(SimplifiedLog logger,
Level level,
String prefix,
PropertyResolver resolver,
char sep,
byte... data) |
static void |
dumpHex(SimplifiedLog logger,
Level level,
String prefix,
PropertyResolver resolver,
char sep,
byte[] data,
int offset,
int len) |
static boolean |
equals(byte[] a1,
byte[] a2)
Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons
(e.g.
|
static boolean |
equals(byte[] a1,
int a1Offset,
byte[] a2,
int a2Offset,
int length)
Compares the contents of 2 arrays of bytes - Note: do not use it to execute security related comparisons
(e.g.
|
static byte |
fromHex(char hi,
char lo) |
static BigInteger |
fromMPIntBytes(byte[] mpInt) |
static long |
getLong(byte[] buf,
int off,
int len) |
static int |
getNextPowerOf2(int value) |
static long |
getUInt(byte... buf) |
static long |
getUInt(byte[] buf,
int off,
int len) |
static int |
indexOf(byte[] array,
byte valueToFind,
int startIndex,
int len)
Finds the index of the given value in the array starting at the given index and checking up to specified number
of elements.
|
static boolean |
isValidInt32Value(long value) |
static boolean |
isValidUint32Value(long value) |
static int |
putLong(long value,
byte[] buf,
int off,
int len) |
static int |
putUInt(long value,
byte[] buf)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
static int |
putUInt(long value,
byte[] buf,
int off,
int len)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
static int |
readInt(InputStream input,
byte[] buf)
Read a 32-bit value in network order
|
static int |
readInt(InputStream input,
byte[] buf,
int offset,
int len)
Read a 32-bit value in network order
|
static long |
readUInt(InputStream input,
byte[] buf)
Read a 32-bit value in network order
|
static long |
readUInt(InputStream input,
byte[] buf,
int offset,
int len)
Read a 32-bit value in network order
|
static String |
toHex(byte... array) |
static String |
toHex(byte[] array,
int offset,
int len) |
static String |
toHex(byte[] array,
int offset,
int len,
char sep) |
static String |
toHex(char sep,
byte... array) |
static int |
updateLengthPlaceholder(Buffer buffer,
int lenPos)
Used for encodings where we don't know the data length before adding it to the buffer.
|
static void |
updateLengthPlaceholder(Buffer buffer,
int lenPos,
long dataLength)
Updates a 32-bit "placeholder" location for data length - moves the write position to the specified
placeholder position, updates the length value and then moves the write position it back to its original value.
|
static long |
validateInt32Value(long value,
String message) |
static long |
validateInt32Value(long value,
String format,
Object... args) |
static long |
validateInt32Value(long value,
String format,
Object arg) |
static long |
validateUint32Value(long value,
String message) |
static long |
validateUint32Value(long value,
String format,
Object... args) |
static long |
validateUint32Value(long value,
String format,
Object arg) |
static void |
writeInt(OutputStream output,
int value,
byte[] buf)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
static void |
writeInt(OutputStream output,
int value,
byte[] buf,
int off,
int len)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
static void |
writeUInt(OutputStream output,
long value,
byte[] buf)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
static void |
writeUInt(OutputStream output,
long value,
byte[] buf,
int off,
int len)
Writes a 32-bit value in network order (i.e., MSB 1st)
|
public static final char DEFAULT_HEX_SEPARATOR
public static final char EMPTY_HEX_SEPARATOR
public static final String HEX_DIGITS
public static final Level DEFAULT_HEXDUMP_LEVEL
public static final IntUnaryOperator DEFAULT_BUFFER_GROWTH_FACTOR
public static final long MAX_UINT32_VALUE
uint32
fieldpublic static final int MAX_UINT8_VALUE
uint8
fieldpublic static int indexOf(byte[] array, byte valueToFind, int startIndex, int len)
Finds the index of the given value in the array starting at the given index and checking up to specified number of elements.
This method returns -1
) for a null
input array.
A negative startIndex is treated as zero. A startIndex larger than the array length will return -1
.
array
- the array to search through for the object, may be null
valueToFind
- the value to findstartIndex
- the index to start searching atlen
- the number of elements to search from the start index-1
if not found or null
array input
or non-positive number of elementspublic static void dumpHex(SimplifiedLog logger, Level level, String prefix, PropertyResolver resolver, char sep, byte... data)
public static void dumpHex(SimplifiedLog logger, Level level, String prefix, PropertyResolver resolver, char sep, byte[] data, int offset, int len)
public static void dumpHex(SimplifiedLog logger, Level level, String prefix, char sep, int chunkSize, byte... data)
public static void dumpHex(SimplifiedLog logger, Level level, String prefix, char sep, int chunkSize, byte[] data, int offset, int len)
public static String toHex(byte... array)
public static String toHex(char sep, byte... array)
public static String toHex(byte[] array, int offset, int len)
public static String toHex(byte[] array, int offset, int len, char sep)
public static <A extends Appendable> A appendHex(A sb, char sep, byte... array) throws IOException
IOException
public static <A extends Appendable> A appendHex(A sb, byte[] array, int offset, int len, char sep) throws IOException
IOException
public static byte[] decodeHex(char separator, CharSequence csq)
separator
- The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
csq
- The CharSequence
containing the HEX encoded bytesIllegalArgumentException
- If invalid HEX sequence lengthNumberFormatException
- If invalid HEX characters founddecodeHex(char, CharSequence, int, int)
public static byte[] decodeHex(char separator, CharSequence csq, int start, int end)
separator
- The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
csq
- The CharSequence
containing the HEX encoded bytesstart
- Start offset of the HEX sequence (inclusive)end
- End offset of the HEX sequence (exclusive)IllegalArgumentException
- If invalid HEX sequence lengthNumberFormatException
- If invalid HEX characters foundpublic static <S extends OutputStream> int decodeHex(S stream, char separator, CharSequence csq) throws IOException
S
- The OutputStream
generic typestream
- The target OutputStream
separator
- The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
csq
- The CharSequence
containing the HEX encoded bytesIOException
- If failed to writeIllegalArgumentException
- If invalid HEX sequence lengthNumberFormatException
- If invalid HEX characters founddecodeHex(OutputStream, char, CharSequence, int, int)
public static <S extends OutputStream> int decodeHex(S stream, char separator, CharSequence csq, int start, int end) throws IOException
S
- The OutputStream
generic typestream
- The target OutputStream
separator
- The separator between the HEX values - may be EMPTY_HEX_SEPARATOR
csq
- The CharSequence
containing the HEX encoded bytesstart
- Start offset of the HEX sequence (inclusive)end
- End offset of the HEX sequence (exclusive)IOException
- If failed to writeIllegalArgumentException
- If invalid HEX sequence lengthNumberFormatException
- If invalid HEX characters foundpublic static byte fromHex(char hi, char lo) throws NumberFormatException
NumberFormatException
public static int readInt(InputStream input, byte[] buf) throws IOException
input
- The InputStream
buf
- Work buffer to useIOException
- If failed to read 4 bytes or not enough room in work bufferreadInt(InputStream, byte[], int, int)
public static int readInt(InputStream input, byte[] buf, int offset, int len) throws IOException
input
- The InputStream
buf
- Work buffer to useoffset
- Offset in buffer to uslen
- Available length - must have at least 4 bytes availableIOException
- If failed to read 4 bytes or not enough room in work bufferreadUInt(InputStream, byte[], int, int)
public static long readUInt(InputStream input, byte[] buf) throws IOException
input
- The InputStream
buf
- Work buffer to useIOException
- If failed to read 4 bytes or not enough room in work bufferreadUInt(InputStream, byte[], int, int)
public static long readUInt(InputStream input, byte[] buf, int offset, int len) throws IOException
input
- The InputStream
buf
- Work buffer to useoffset
- Offset in buffer to uslen
- Available length - must have at least 4 bytes availableIOException
- If failed to read 4 bytes or not enough room in work buffergetUInt(byte[], int, int)
public static long getUInt(byte... buf)
buf
- A buffer holding a 32-bit unsigned integer in big endian format. Note: if more than 4
bytes are available, then only the first 4 bytes in the buffer will be usedlong
whose 32 high-order bits are zerogetUInt(byte[], int, int)
public static long getUInt(byte[] buf, int off, int len)
buf
- A buffer holding a 32-bit unsigned integer in big endian format.off
- The offset of the data in the bufferlen
- The available data length. Note: if more than 4 bytes are available, then only the
first 4 bytes in the buffer will be used (starting at the specified offset)long
whose 32 high-order bits are zeropublic static long getLong(byte[] buf, int off, int len)
public static BigInteger fromMPIntBytes(byte[] mpInt)
public static void writeInt(OutputStream output, int value, byte[] buf) throws IOException
output
- The OutputStream
to write the valuevalue
- The 32-bit valuebuf
- A work buffer to use - must have enough space to contain 4 bytesIOException
- If failed to write the value or work buffer too smallwriteInt(OutputStream, int, byte[], int, int)
public static void writeInt(OutputStream output, int value, byte[] buf, int off, int len) throws IOException
output
- The OutputStream
to write the valuevalue
- The 32-bit valuebuf
- A work buffer to use - must have enough space to contain 4 bytesoff
- The offset to write the valuelen
- The available spaceIOException
- If failed to write the value or work buffer too smallwriteUInt(OutputStream, long, byte[], int, int)
public static void writeUInt(OutputStream output, long value, byte[] buf) throws IOException
output
- The OutputStream
to write the valuevalue
- The 32-bit valuebuf
- A work buffer to use - must have enough space to contain 4 bytesIOException
- If failed to write the value or work buffer too smallwriteUInt(OutputStream, long, byte[], int, int)
public static void writeUInt(OutputStream output, long value, byte[] buf, int off, int len) throws IOException
output
- The OutputStream
to write the valuevalue
- The 32-bit valuebuf
- A work buffer to use - must have enough space to contain 4 bytesoff
- The offset to write the valuelen
- The available spaceIOException
- If failed to write the value or work buffer to smallputUInt(long, byte[], int, int)
public static int putUInt(long value, byte[] buf)
value
- The 32-bit valuebuf
- The bufferIllegalArgumentException
- if not enough space availableputUInt(long, byte[], int, int)
public static int putUInt(long value, byte[] buf, int off, int len)
value
- The 32-bit valuebuf
- The bufferoff
- The offset to write the valuelen
- The available spaceIllegalArgumentException
- if not enough space availablepublic static int putLong(long value, byte[] buf, int off, int len)
public static boolean equals(byte[] a1, byte[] a2)
Mac#equals
method instead.a1
- 1st arraya2
- 2nd arraytrue
if all bytes in the compared arrays are equalpublic static boolean equals(byte[] a1, int a1Offset, byte[] a2, int a2Offset, int length)
Mac#equals
method instead.a1
- 1st arraya1Offset
- Offset to start comparing in 1st arraya2
- 2nd arraya2Offset
- Offset to start comparing in 2nd arraylength
- Number of bytes to comparetrue
if all bytes in the compared arrays are equal when compared from the specified
offsets and up to specified lengthpublic static int getNextPowerOf2(int value)
public static int updateLengthPlaceholder(Buffer buffer, int lenPos)
buffer
- The Buffer
lenPos
- The offset in the buffer where the length placeholder is to be update - Note: assumption is
that the encoded data starts immediately after the placeholderpublic static void updateLengthPlaceholder(Buffer buffer, int lenPos, long dataLength)
buffer
- The Buffer
lenPos
- The offset in the buffer where the length placeholder is to be update - Note: assumption
is that the encoded data starts immediately after the placeholderdataLength
- The length to update - a UINT32 value as a long
public static <B extends Buffer> B clear(B buffer)
Buffer.clear()
B
- The generic buffer typebuffer
- A Buffer
instance - ignored if null
public static long validateInt32Value(long value, String message)
public static boolean isValidInt32Value(long value)
public static long validateUint32Value(long value, String message)
public static long validateUint32Value(long value, String format, Object... args)
public static boolean isValidUint32Value(long value)
Copyright © 2008–2024 The Apache Software Foundation. All rights reserved.