BytesUtil (OpenHFT/Chronicle-Bytes 2.24ea16 API)

java.lang.Object
- java.lang.Enum<BytesUtil>
- - net.openhft.chronicle.bytes.BytesUtil

All Implemented Interfaces:

Serializable, Comparable<BytesUtil>
```
public enum BytesUtil
extends Enum<BytesUtil>
```
Utility class for performing operations on Bytes and related data types.
This class provides a collection of static methods to manipulate and interact with Bytes objects. These methods include transformations, checks, and complex calculations not provided in the Bytes class itself.
Some of the operations provided in this class include:
- Converting Bytes objects to different representations, such as char arrays.
- Reading and writing specific data formats from/to Bytes objects, such as stop bits.
- Manipulating the content of Bytes objects, such as combining double newlines or reversing contents.
- Performing complex mathematical calculations, like rounding up values based on byte alignment.
- Providing utility methods for exceptions, booleans and byte manipulations.
All methods in this class throw NullPointerException if the objects provided to them are null.
See Also:

Bytes

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`appendBytesFromStart(@NotNull Bytes<?> bytes, long startPosition, @NotNull StringBuilder sb)` Appends bytes from a specified start position of a Bytes object to a StringBuilder.
`static void`	`appendUtf8(@NotNull StreamingDataOutput out, @NotNull CharSequence cs)` Writes a CharSequence as a UTF-8 string to a StreamingDataOutput.
`static int`	`asInt(@NotNull String str)` Converts a string to an integer using ISO_8859_1 encoding.
`static boolean`	`bytesEqual(@Nullable CharSequence cs, @NotNull RandomDataInput bs, long offset, int length)` Compares a CharSequence with bytes from a RandomDataInput object to check if they are equal.
`static boolean`	`bytesEqual(@NotNull RandomDataInput a, long offset, @NotNull RandomDataInput second, long secondOffset, long len)` Compares bytes from two RandomDataInput objects to check if they are equal.
`static boolean`	`byteToBoolean(byte b)` Converts a byte to a boolean.
`static void`	`combineDoubleNewline(Bytes<?> bytes)` Checks the last two characters of the given Bytes object.
`static void`	`copy8bit(BytesStore bs, long addressForWrite, long length)` Copies 8-bit data from a BytesStore object to a specified address.
`static BytesStore<Bytes<Void>,Void>`	`copyOf(@NotNull Bytes<?> bytes)` Returns a copy of the given Bytes object.
`static boolean`	`equals(Object o1, Object o2)` Compares two objects for equality, with special handling for CharSequences.
`static String`	`findFile(@NotNull String name)` Finds the absolute path of a file specified by name.
`static boolean`	`isTriviallyCopyable(@NotNull Class<?> clazz)` Checks if the given class is trivially copyable.
`static boolean`	`isTriviallyCopyable(Class clazz, int offset, int length)` Checks if all the fields in the specified range of the given class are trivially copyable.
`static long`	`padOffset(long from)` Pads an offset to align it to the nearest multiple of 4.
`static void`	`parseUtf8(@NotNull StreamingDataInput in, Appendable appendable, int utflen)` Parses a UTF-8 string from a StreamingDataInput and appends it to an Appendable object.
`static void`	`read8ByteAlignPadding(Bytes<?> bytes)` Reads padding bytes from a Bytes object to align the read position to the nearest 8-byte boundary.
`static Bytes<?>`	`readFile(@NotNull String name)` Reads the content of a file specified by name into a Bytes object.
`static void`	`readMarshallable(@NotNull ReadBytesMarshallable marshallable, BytesIn<?> bytes)` Reads a Marshallable object from a BytesIn object.
`static long`	`readStopBit(@NotNull StreamingDataInput in)` Reads a variable-length integer from a StreamingDataInput using the stop bit encoding.
`static void`	`reverse(Bytes<?> text, int start)` Reverses the contents of a Bytes object from a specified starting position.
`static long`	`roundNup(double d, long factor)` Rounds up a double value to the nearest multiple of a specified factor.
`static long`	`roundUpTo64ByteAlign(long x)` Rounds up a long value to the nearest multiple of 64.
`static long`	`roundUpTo8ByteAlign(long x)` Rounds up a long value to the nearest multiple of 8.
`static int`	`stopBitLength(long n)` Calculates the number of bytes required to store a variable-length integer using the stop bit encoding.
`static @NotNull char[]`	`toCharArray(@NotNull Bytes<?> bytes)` Converts the bytes from a Bytes object into a character array.
`static @NotNull char[]`	`toCharArray(@NotNull Bytes<?> bytes, long position, int length)` Converts a specific range of bytes from a Bytes object into a character array.
`static String`	`toDebugString(@NotNull RandomDataInput bytes, long start, long maxLength)` Returns a debug string representation of a portion of a RandomDataInput object.
`static int`	`triviallyCopyableLength(Class clazz)` Returns the length of the trivially copyable fields in a given class.
`static int[]`	`triviallyCopyableRange(Class clazz)` Returns the range within which a class is trivially copyable.
`static int`	`triviallyCopyableStart(Class clazz)` Returns the offset of the first byte of the trivially copyable fields of a given class.
`static BytesUtil`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static BytesUtil[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`static void`	`write8ByteAlignPadding(Bytes<?> bytes)` Writes padding bytes to a Bytes object to align the write position to the nearest 8-byte boundary.
`static void`	`writeFile(String file, Bytes<byte[]> bytes)` Writes the content of a Bytes object to a file specified by name.
`static void`	`writeMarshallable(@NotNull WriteBytesMarshallable marshallable, BytesOut<?> bytes)` Writes a Marshallable object to a BytesOut object.
`static long`	`writeStopBit(BytesStore bs, long offset, long n)` Writes a variable-length integer to a specific position in a BytesStore using the stop bit encoding.
`static long`	`writeStopBit(long addr, long n)` Writes a variable-length integer to a specific memory address using the stop bit encoding.
`static void`	`writeStopBit(@NotNull StreamingDataOutput out, long n)` Writes a variable-length integer to a StreamingDataOutput using the stop bit encoding.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

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

- Method Detail
  - values
```
public static BytesUtil[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (BytesUtil c : BytesUtil.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static BytesUtil valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - isTriviallyCopyable
```
public static boolean isTriviallyCopyable(@NotNull
                                          @NotNull Class<?> clazz)
```
    Checks if the given class is trivially copyable.
    
    Parameters:
    
    clazz - Class to check.
    
    Returns:
    
    true if the class is trivially copyable, false otherwise.
  - isTriviallyCopyable
```
public static boolean isTriviallyCopyable(Class clazz,
                                          int offset,
                                          int length)
```
    Checks if all the fields in the specified range of the given class are trivially copyable.
    
    Parameters:
    
    clazz - Class to check.
    
    offset - Start of the field area.
    
    length - Length of the field area.
    
    Returns:
    
    true if all fields in the range are trivially copyable, false otherwise.
  - triviallyCopyableRange
```
public static int[] triviallyCopyableRange(Class clazz)
```
    Returns the range within which a class is trivially copyable.
    
    Parameters:
    
    clazz - Class to get the range for.
    
    Returns:
    
    An array of integers representing the range in which the class is trivially copyable.
  - triviallyCopyableStart
```
public static int triviallyCopyableStart(Class clazz)
```
    Returns the offset of the first byte of the trivially copyable fields of a given class.
    
    Parameters:
    
    clazz - The class to examine.
    
    Returns:
    
    The offset of the first byte that is trivially copyable.
  - triviallyCopyableLength
```
public static int triviallyCopyableLength(Class clazz)
```
    Returns the length of the trivially copyable fields in a given class. Note that references are ignored as they are not considered trivially copyable.
    
    Parameters:
    
    clazz - The class to examine.
    
    Returns:
    
    The length of the trivially copyable data.
  - findFile
```
public static String findFile(@NotNull
                              @NotNull String name)
                       throws FileNotFoundException
```
    Finds the absolute path of a file specified by name. Throws an exception if the file does not exist.
    
    Parameters:
    
    name - The name of the file to find.
    
    Returns:
    
    The absolute path of the file.
    
    Throws:
    
    FileNotFoundException - If the file does not exist.
  - readFile
```
public static Bytes<?> readFile(@NotNull
                                @NotNull String name)
                         throws IOException
```
    Reads the content of a file specified by name into a Bytes object. If the name starts with "=", the rest of the name string will be converted to Bytes directly.
    
    Parameters:
    
    name - The name of the file to read.
    
    Returns:
    
    The content of the file as a Bytes object.
    
    Throws:
    
    IOException - If an I/O error occurs.
  - writeFile
```
public static void writeFile(String file,
                             Bytes<byte[]> bytes)
                      throws IOException
```
    Writes the content of a Bytes object to a file specified by name.
    
    Parameters:
    
    file - The name of the file to write to.
    
    bytes - The Bytes object containing the data to write.
    
    Throws:
    
    IOException - If an I/O error occurs.
  - bytesEqual
```
public static boolean bytesEqual(@NotNull
                                 @NotNull RandomDataInput a,
                                 long offset,
                                 @NotNull
                                 @NotNull RandomDataInput second,
                                 long secondOffset,
                                 long len)
                          throws BufferUnderflowException,
                                 IllegalStateException
```
    Compares bytes from two RandomDataInput objects to check if they are equal.
    
    Parameters:
    
    a - The first RandomDataInput object.
    
    offset - The starting position in the first object.
    
    second - The second RandomDataInput object.
    
    secondOffset - The starting position in the second object.
    
    len - The number of bytes to compare.
    
    Returns:
    
    true if the bytes are equal, false otherwise.
    
    Throws:
    
    BufferUnderflowException - If there is insufficient data.
    
    IllegalStateException - If an illegal state is encountered.
  - bytesEqual
```
public static boolean bytesEqual(@Nullable
                                 @Nullable CharSequence cs,
                                 @NotNull
                                 @NotNull RandomDataInput bs,
                                 long offset,
                                 int length)
                          throws IllegalStateException,
                                 BufferUnderflowException
```
    Compares a CharSequence with bytes from a RandomDataInput object to check if they are equal.
    
    Parameters:
    
    cs - The CharSequence to compare.
    
    bs - The RandomDataInput object.
    
    offset - The starting position in the RandomDataInput object.
    
    length - The number of bytes to compare.
    
    Returns:
    
    true if the bytes are equal to the CharSequence, false otherwise.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
  - equals
```
public static boolean equals(Object o1,
                             Object o2)
```
    Compares two objects for equality, with special handling for CharSequences.
    
    Parameters:
    
    o1 - The first object to compare.
    
    o2 - The second object to compare.
    
    Returns:
    
    true if the objects are equal, false otherwise.
  - asInt
```
public static int asInt(@NotNull
                        @NotNull String str)
```
    Converts a string to an integer using ISO_8859_1 encoding.
    
    Parameters:
    
    str - The string to convert.
    
    Returns:
    
    The integer value of the string.
  - stopBitLength
```
public static int stopBitLength(long n)
```
    Calculates the number of bytes required to store a variable-length integer using the stop bit encoding.
    
    Parameters:
    
    n - The integer to calculate the length for.
    
    Returns:
    
    The number of bytes required to store the integer.
  - toCharArray
```
@NotNull
public static @NotNull char[] toCharArray(@NotNull
                                                   @NotNull Bytes<?> bytes)
                                            throws ArithmeticException,
                                                   IllegalStateException,
                                                   BufferUnderflowException
```
    Converts the bytes from a Bytes object into a character array.
    
    Parameters:
    
    bytes - The Bytes object to convert.
    
    Returns:
    
    The character array converted from the bytes.
    
    Throws:
    
    ArithmeticException - If there is an arithmetic error.
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
  - toCharArray
```
@NotNull
public static @NotNull char[] toCharArray(@NotNull
                                                   @NotNull Bytes<?> bytes,
                                                   long position,
                                                   int length)
                                            throws IllegalStateException,
                                                   BufferUnderflowException
```
    Converts a specific range of bytes from a Bytes object into a character array.
    
    Parameters:
    
    bytes - The Bytes object to convert.
    
    position - The starting position in the Bytes object.
    
    length - The number of bytes to convert.
    
    Returns:
    
    The character array converted from the bytes.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
  - readStopBit
```
public static long readStopBit(@NotNull
                               @NotNull StreamingDataInput in)
                        throws net.openhft.chronicle.core.io.IORuntimeException,
                               IllegalStateException
```
    Reads a variable-length integer from a StreamingDataInput using the stop bit encoding.
    
    Parameters:
    
    in - The StreamingDataInput to read from.
    
    Returns:
    
    The integer read.
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an IO error occurs.
    
    IllegalStateException - If an illegal state is encountered.
  - writeStopBit
```
public static void writeStopBit(@NotNull
                                @NotNull StreamingDataOutput out,
                                long n)
                         throws IllegalStateException,
                                BufferOverflowException
```
    Writes a variable-length integer to a StreamingDataOutput using the stop bit encoding.
    
    Parameters:
    
    out - The StreamingDataOutput to write to.
    
    n - The integer to write.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferOverflowException - If there is insufficient space.
  - writeStopBit
```
public static long writeStopBit(BytesStore bs,
                                long offset,
                                long n)
                         throws IllegalStateException,
                                BufferOverflowException
```
    Writes a variable-length integer to a specific position in a BytesStore using the stop bit encoding.
    
    Parameters:
    
    bs - The BytesStore to write to.
    
    offset - The position in the BytesStore to start writing.
    
    n - The integer to write.
    
    Returns:
    
    The resulting offset after writing.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferOverflowException - If there is insufficient space.
  - writeStopBit
```
public static long writeStopBit(long addr,
                                long n)
                         throws IllegalStateException,
                                BufferOverflowException
```
    Writes a variable-length integer to a specific memory address using the stop bit encoding.
    
    Parameters:
    
    addr - The memory address to write to.
    
    n - The integer to write.
    
    Returns:
    
    The resulting memory address after writing.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferOverflowException - If there is insufficient space.
  - parseUtf8
```
public static void parseUtf8(@NotNull
                             @NotNull StreamingDataInput in,
                             Appendable appendable,
                             int utflen)
                      throws UTFDataFormatRuntimeException,
                             IllegalStateException,
                             BufferUnderflowException
```
    Parses a UTF-8 string from a StreamingDataInput and appends it to an Appendable object.
    
    Parameters:
    
    in - The StreamingDataInput to read from.
    
    appendable - The Appendable to append to.
    
    utflen - The length of the UTF-8 string.
    
    Throws:
    
    UTFDataFormatRuntimeException - If the UTF-8 format is invalid.
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
  - appendUtf8
```
public static void appendUtf8(@NotNull
                              @NotNull StreamingDataOutput out,
                              @NotNull
                              @NotNull CharSequence cs)
                       throws IndexOutOfBoundsException
```
    Writes a CharSequence as a UTF-8 string to a StreamingDataOutput.
    
    Parameters:
    
    out - The StreamingDataOutput to write to.
    
    cs - The CharSequence to write.
    
    Throws:
    
    IndexOutOfBoundsException - If the CharSequence length is out of bounds.
  - appendBytesFromStart
```
public static void appendBytesFromStart(@NotNull
                                        @NotNull Bytes<?> bytes,
                                        long startPosition,
                                        @NotNull
                                        @NotNull StringBuilder sb)
                                 throws IllegalStateException
```
    Appends bytes from a specified start position of a Bytes object to a StringBuilder.
    
    Parameters:
    
    bytes - The Bytes object.
    
    startPosition - The start position in the Bytes object.
    
    sb - The StringBuilder to append to.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
  - readMarshallable
```
public static void readMarshallable(@NotNull
                                    @NotNull ReadBytesMarshallable marshallable,
                                    BytesIn<?> bytes)
                             throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Reads a Marshallable object from a BytesIn object.
    
    Parameters:
    
    marshallable - The Marshallable object to read.
    
    bytes - The BytesIn object to read from.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the Marshallable object is invalid.
  - writeMarshallable
```
public static void writeMarshallable(@NotNull
                                     @NotNull WriteBytesMarshallable marshallable,
                                     BytesOut<?> bytes)
                              throws IllegalStateException,
                                     BufferOverflowException,
                                     ArithmeticException,
                                     BufferUnderflowException,
                                     net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a Marshallable object to a BytesOut object.
    
    Parameters:
    
    marshallable - The Marshallable object to write.
    
    bytes - The BytesOut object to write to.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferOverflowException - If there is insufficient space.
    
    ArithmeticException - If an arithmetic error occurs.
    
    BufferUnderflowException - If there is insufficient data.
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the Marshallable object is invalid.
  - byteToBoolean
```
public static boolean byteToBoolean(byte b)
```
    Converts a byte to a boolean. The byte is considered to represent the boolean value false if it equals 0, 'N', or 'n'. Otherwise, it represents true.
    
    Parameters:
    
    b - The byte to convert.
    
    Returns:
    
    The boolean value represented by the byte.
  - roundUpTo64ByteAlign
```
public static long roundUpTo64ByteAlign(long x)
```
    Rounds up a long value to the nearest multiple of 64.
    
    Parameters:
    
    x - The value to round up.
    
    Returns:
    
    The rounded value.
  - roundUpTo8ByteAlign
```
public static long roundUpTo8ByteAlign(long x)
```
    Rounds up a long value to the nearest multiple of 8.
    
    Parameters:
    
    x - The value to round up.
    
    Returns:
    
    The rounded value.
  - read8ByteAlignPadding
```
public static void read8ByteAlignPadding(Bytes<?> bytes)
                                  throws IllegalStateException,
                                         BufferUnderflowException
```
    Reads padding bytes from a Bytes object to align the read position to the nearest 8-byte boundary.
    
    Parameters:
    
    bytes - The Bytes object.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
  - write8ByteAlignPadding
```
public static void write8ByteAlignPadding(Bytes<?> bytes)
                                   throws BufferOverflowException,
                                          IllegalStateException
```
    Writes padding bytes to a Bytes object to align the write position to the nearest 8-byte boundary.
    
    Parameters:
    
    bytes - The Bytes object.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space.
    
    IllegalStateException - If an illegal state is encountered.
  - toDebugString
```
public static String toDebugString(@NotNull
                                   @NotNull RandomDataInput bytes,
                                   long start,
                                   long maxLength)
                            throws IllegalStateException,
                                   BufferUnderflowException,
                                   ArithmeticException
```
    Returns a debug string representation of a portion of a RandomDataInput object.
    
    Parameters:
    
    bytes - The RandomDataInput object.
    
    start - The starting position.
    
    maxLength - The maximum length.
    
    Returns:
    
    The debug string.
    
    Throws:
    
    IllegalStateException - If an illegal state is encountered.
    
    BufferUnderflowException - If there is insufficient data.
    
    ArithmeticException - If an arithmetic error occurs.
  - copy8bit
```
public static void copy8bit(BytesStore bs,
                            long addressForWrite,
                            long length)
```
    Copies 8-bit data from a BytesStore object to a specified address.
    
    Parameters:
    
    bs - The BytesStore object.
    
    addressForWrite - The address for writing.
    
    length - The length of data to copy.
  - reverse
```
public static void reverse(Bytes<?> text,
                           int start)
```
    Reverses the contents of a Bytes object from a specified starting position.
    
    Parameters:
    
    text - The Bytes object.
    
    start - The starting position.
  - roundNup
```
public static long roundNup(double d,
                            long factor)
```
    Rounds up a double value to the nearest multiple of a specified factor.
    
    Parameters:
    
    d - The value to round up.
    
    factor - The factor.
    
    Returns:
    
    The rounded value.
  - padOffset
```
public static long padOffset(long from)
```
    Pads an offset to align it to the nearest multiple of 4.
    
    Parameters:
    
    from - The original offset.
    
    Returns:
    
    The padded offset.
  - combineDoubleNewline
```
public static void combineDoubleNewline(Bytes<?> bytes)
```
    Checks the last two characters of the given Bytes object. If the last two characters are both newlines, one of them is removed to ensure only a single newline remains. If the last character is a space and the character before it is a space, newline or non-printable, the last character is removed.
    
    Parameters:
    
    bytes - to check and trim as needed.
  - copyOf
```
public static BytesStore<Bytes<Void>,Void> copyOf(@NotNull
                                                  @NotNull Bytes<?> bytes)
                                           throws IllegalStateException
```
    Returns a copy of the given Bytes object. The Bytes object must not have been released. If the Bytes object is empty, an empty BytesStore is returned.
    
    Parameters:
    
    bytes - The Bytes object to copy.
    
    Returns:
    
    A copy of the given Bytes object.
    
    Throws:
    
    IllegalStateException - If the Bytes object has been released.

Enum BytesUtil

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Method Detail

values

valueOf

isTriviallyCopyable

isTriviallyCopyable

triviallyCopyableRange

triviallyCopyableStart

triviallyCopyableLength

findFile

readFile

writeFile

bytesEqual

bytesEqual

equals

asInt

stopBitLength

toCharArray

toCharArray

readStopBit

writeStopBit

writeStopBit

writeStopBit

parseUtf8

appendUtf8

appendBytesFromStart

readMarshallable

writeMarshallable

byteToBoolean

roundUpTo64ByteAlign

roundUpTo8ByteAlign

read8ByteAlignPadding

write8ByteAlignPadding

toDebugString

copy8bit

reverse

roundNup

padOffset

combineDoubleNewline

copyOf