BytesInternal (OpenHFT/Chronicle-Bytes 2.24ea17 API)

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

All Implemented Interfaces:

Serializable, Comparable<BytesInternal>
```
public enum BytesInternal
extends Enum<BytesInternal>
```
Utility methods to support common functionality in this package. This is not intended to be accessed directly.

Field Summary

Fields
Modifier and Type Field and Description

static ThreadLocal<ByteBuffer> BYTE_BUFFER_TL

static ThreadLocal<ByteBuffer> BYTE_BUFFER2_TL

static StringInternerBytes SI

Fields
Modifier and Type	Field and Description
`static ThreadLocal<ByteBuffer>`	`BYTE_BUFFER_TL`
`static ThreadLocal<ByteBuffer>`	`BYTE_BUFFER2_TL`
`static StringInternerBytes`	`SI`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Bytes<?>`	`acquireBytes()`
`static StringBuilder`	`acquireStringBuilder()`
`static double`	`addAndGetDouble(@NotNull BytesStore<?,?> in, long offset, double adding)`
`static float`	`addAndGetFloat(@NotNull BytesStore<?,?> in, long offset, float adding)`
`static int`	`addAndGetInt(@NotNull BytesStore<?,?> in, long offset, int adding)`
`static long`	`addAndGetLong(@NotNull BytesStore<?,?> in, long offset, long adding)`
`static void`	`append(@NotNull ByteStringAppender bytesStringAppender, double d, int decimalPlaces)`
`static void`	`append(@NotNull ByteStringAppender out, long num, int base)`
`static void`	`append(@NotNull RandomDataOutput out, long offset, long num, int digits)` The length of the number must be fixed otherwise short numbers will not overwrite longer numbers
`static void`	`append(@NotNull StreamingDataOutput out, double d)`
`static void`	`append8bit(long offsetInRDO, RandomDataOutput bytes, @NotNull CharSequence str, int offset, int length)`
`static void`	`appendBase10(@NotNull ByteStringAppender out, int num)`
`static void`	`appendBase10(@NotNull ByteStringAppender out, long num)`
`static void`	`appendBase16(@NotNull ByteStringAppender out, long num, int minDigits)`
`static void`	`appendDateMillis(@NotNull ByteStringAppender b, long timeInMS)`
`static void`	`appendDecimal(@NotNull ByteStringAppender out, long num, int decimalPlaces)`
`static void`	`appendDecimal(@NotNull RandomDataOutput out, long num, long offset, int decimalPlaces, int width)` Appends given long value with given decimalPlaces to RandomDataOutput out
`static void`	`appendTimeMillis(@NotNull ByteStringAppender b, long timeInMS)`
`static long`	`appendUtf8(@NotNull RandomDataOutput out, long outOffset, @NotNull CharSequence str, int strOffset, int length)`
`static void`	`appendUtf8(@NotNull StreamingDataOutput bytes, @NotNull CharSequence str, int offset, int length)`
`static long`	`appendUtf8Char(@NotNull RandomDataOutput out, long offset, int c)`
`static void`	`appendUtf8Char(@NotNull StreamingDataOutput bytes, int c)`
`static ByteBuffer`	`asByteBuffer(@NotNull BytesStore bytesStore)`
`static ByteBuffer`	`asByteBuffer2(@NotNull BytesStore bytesStore)`
`static @NotNull Bytes<?>`	`asBytes(@NotNull RandomDataOutput bytes, long position, long limit)`
`static void`	`assignBytesStoreToByteBuffer(@NotNull BytesStore bytesStore, @NotNull ByteBuffer byteBuffer)`
`static @NotNull Object`	`asSize(long size)`
`static boolean`	`compareUtf8(@NotNull RandomDataInput input, long offset, @Nullable CharSequence other)`
`static boolean`	`contentEqual(@Nullable BytesStore a, @Nullable BytesStore b)`
`static void`	`copy(@NotNull InputStream input, @NotNull StreamingDataOutput output)`
`static void`	`copy(@NotNull RandomDataInput input, @NotNull OutputStream output)`
`static void`	`copy8bit(BytesStore bs, long addressForWrite, long length)`
`static void`	`copyMemory(long from, long to, int length)`
`static int`	`digitsForExponent(int exponent)`
`static boolean`	`equalBytesAny(@NotNull BytesStore b1, @NotNull BytesStore b2, long readRemaining)`
`static <B extends BytesStore<B,U>,U> BytesStore<B,U>`	`failIfBytesOnBytes(BytesStore<B,U> bytesStore)`
`static long`	`findByte(@NotNull RandomDataInput bytes, byte stopByte)`
`static @NotNull Bytes<?>`	`fromHexString(@NotNull String s)`
`static int`	`parse8bit_SB1(long offset, @NotNull NativeBytesStore nbs, @NotNull StringBuilder sb, int length)`
`static String`	`parse8bit(ByteStringParser bsp, StopCharTester stopCharTester)`
`static void`	`parse8bit(long offset, @NotNull RandomDataInput bytesStore, Appendable appendable, int utflen)`
`static void`	`parse8bit(@NotNull StreamingDataInput bytes, @NotNull Bytes<?> builder, @NotNull StopCharsTester tester)`
`static void`	`parse8bit(@NotNull StreamingDataInput bytes, @NotNull Bytes<?> builder, @NotNull StopCharTester tester)`
`static void`	`parse8bit(@NotNull StreamingDataInput bytes, @NotNull StringBuilder builder, @NotNull StopCharsTester tester)`
`static void`	`parse8bit(@NotNull StreamingDataInput bytes, @NotNull StringBuilder builder, @NotNull StopCharTester tester)`
`static void`	`parse8bit1(long offset, @NotNull RandomDataInput bytes, @NotNull Appendable appendable, int utflen)`
`static void`	`parse8bit1(@NotNull StreamingDataInput bytes, @NotNull Appendable appendable, int utflen)`
`static void`	`parse8bit1(@NotNull StreamingDataInput bytes, @NotNull StringBuilder sb, int utflen)`
`static Boolean`	`parseBoolean(@NotNull ByteStringParser parser, @NotNull StopCharTester tester)`
`static double`	`parseDouble(@NotNull StreamingDataInput in)`
`static long`	`parseFlexibleLong(@NotNull StreamingDataInput in)`
`static long`	`parseHexLong(@NotNull StreamingDataInput in)`
`static long`	`parseLong(@NotNull RandomDataInput in, long offset)`
`static long`	`parseLong(@NotNull StreamingDataInput in)`
`static long`	`parseLongDecimal(@NotNull StreamingDataInput in)`
`static void`	`parseUtf8_SB1(@NotNull Bytes<?> bytes, @NotNull StringBuilder sb, boolean utf, int utflen)`
`static void`	`parseUtf8_SB1(@NotNull NativeBytesStore bytes, long offset, @NotNull StringBuilder sb, int utflen)`
`static void`	`parseUtf8(@NotNull RandomDataInput input, long offset, Appendable appendable, boolean utf, int length)`
`static void`	`parseUtf8(@NotNull StreamingDataInput bytes, Appendable appendable, boolean utf, int length)`
`static void`	`parseUtf8(@NotNull StreamingDataInput bytes, @NotNull Appendable builder, @NotNull StopCharsTester tester)`
`static void`	`parseUtf8(@NotNull StreamingDataInput bytes, @NotNull Appendable builder, @NotNull StopCharTester tester)`
`static @Nullable String`	`parseUtf8(@NotNull StreamingDataInput bytes, @NotNull StopCharTester tester)`
`static void`	`parseUtf81(@NotNull RandomDataInput input, long offset, @NotNull Appendable appendable, int utflen)`
`static void`	`parseUtf81(@NotNull StreamingDataInput bytes, @NotNull Appendable appendable, boolean utf, int length)`
`static void`	`prepend(@NotNull BytesPrepender out, long num)`
`static @Nullable String`	`read8bit(@NotNull StreamingDataInput in)`
`static <E extends Enum<E>,S extends StreamingDataInput<S>> E`	`readEnum(@NotNull StreamingDataInput input, @NotNull Class<E> eClass)`
`static void`	`readHistogram(@NotNull StreamingDataInput in, @NotNull net.openhft.chronicle.core.util.Histogram histogram)`
`static long`	`readStopBit(@NotNull StreamingDataInput in)`
`static long`	`readStopBit0(@NotNull StreamingDataInput in, long l)`
`static char`	`readStopBitChar(@NotNull StreamingDataInput in)`
`static double`	`readStopBitDouble(@NotNull StreamingDataInput in)`
`static @Nullable String`	`readUtf8(@NotNull RandomDataInput in, long offset, int maxUtf8Len)`
`static @Nullable String`	`readUtf8(@NotNull StreamingDataInput in)`
`static boolean`	`skipTo(@NotNull ByteStringParser parser, @NotNull StopCharTester tester)`
`static boolean`	`startsWith(@NotNull BytesStore a, @NotNull BytesStore b)`
`static <U extends BytesStore & HasUncheckedRandomDataInput> boolean`	`startsWithUnchecked(U a, @NotNull BytesStore b)`
`static int`	`stopBitLength0(long n)`
`static @NotNull BytesStore`	`subBytes(RandomDataInput from, long start, long length)`
`static String`	`to8bitString(@NotNull BytesStore bytes)`
`static @NotNull byte[]`	`toByteArray(@NotNull RandomDataInput in)`
`static String`	`toDebugString(@NotNull RandomDataInput bytes, long maxLength)`
`static String`	`toHexString(@NotNull Bytes<?> bytes, long offset, long maxLength)` Converts the content of the provided Bytes buffer to a hexadecimal string representation along with comments describing the meaning of the bytes.
`static @NotNull String`	`toString(@NotNull RandomDataInput bytes)`
`static BytesInternal`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static BytesInternal[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`static void`	`writeFully(@NotNull RandomDataInput bytes, long offset, long length, @NotNull StreamingDataOutput sdo)`
`static void`	`writeHistogram(@NotNull StreamingDataOutput out, @NotNull net.openhft.chronicle.core.util.Histogram histogram)`
`static long`	`writeStopBit(long addr, long n)`
`static long`	`writeStopBit(@NotNull RandomDataOutput out, long offset, long n)`
`static void`	`writeStopBit(@NotNull StreamingDataOutput out, char n)`
`static void`	`writeStopBit(@NotNull StreamingDataOutput out, double d)`
`static void`	`writeStopBit(@NotNull StreamingDataOutput out, long n)`
`static void`	`writeStopBit0(@NotNull StreamingDataOutput out, long n)`
`static void`	`writeStopBitNeg1(@NotNull StreamingDataOutput out)`
`static long`	`writeUtf8(@NotNull RandomDataOutput out, long writeOffset, @Nullable CharSequence str)`
`static long`	`writeUtf8(@NotNull RandomDataOutput out, long offset, @Nullable CharSequence str, int maxUtf8Len)`
`static void`	`writeUtf8(@NotNull StreamingDataOutput bytes, @Nullable CharSequence str)`
`static void`	`writeUtf8(@NotNull StreamingDataOutput bytes, @Nullable String str)`

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

Field Detail

BYTE_BUFFER_TL

public static final ThreadLocal<ByteBuffer> BYTE_BUFFER_TL

BYTE_BUFFER2_TL

public static final ThreadLocal<ByteBuffer> BYTE_BUFFER2_TL

SI

public static final StringInternerBytes SI

Method Detail

values
```
public static BytesInternal[] 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 (BytesInternal c : BytesInternal.values())
    System.out.println(c);
```
Returns:

an array containing the constants of this enum type, in the order they are declared

valueOf
```
public static BytesInternal 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

contentEqual

public static boolean contentEqual(@Nullable
                                   @Nullable BytesStore a,
                                   @Nullable
                                   @Nullable BytesStore b)
                            throws IllegalStateException

Throws:: IllegalStateException

startsWith

public static boolean startsWith(@NotNull
                                 @NotNull BytesStore a,
                                 @NotNull
                                 @NotNull BytesStore b)
                          throws IllegalStateException

Throws:: IllegalStateException

startsWithUnchecked

public static <U extends BytesStore & HasUncheckedRandomDataInput> boolean startsWithUnchecked(@NotNull
                                                                                               U a,
                                                                                               @NotNull
                                                                                               @NotNull BytesStore b)

parseUtf8

public static void parseUtf8(@NotNull
                             @NotNull StreamingDataInput bytes,
                             Appendable appendable,
                             boolean utf,
                             int length)
                      throws UTFDataFormatRuntimeException,
                             BufferUnderflowException,
                             IllegalStateException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException; IllegalStateException

parseUtf8

public static void parseUtf8(@NotNull
                             @NotNull RandomDataInput input,
                             long offset,
                             Appendable appendable,
                             boolean utf,
                             int length)
                      throws UTFDataFormatRuntimeException,
                             BufferUnderflowException,
                             IllegalStateException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException; IllegalStateException

compareUtf8

public static boolean compareUtf8(@NotNull
                                  @NotNull RandomDataInput input,
                                  long offset,
                                  @Nullable
                                  @Nullable CharSequence other)
                           throws net.openhft.chronicle.core.io.IORuntimeException,
                                  BufferUnderflowException,
                                  IllegalStateException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException; IllegalStateException

parse8bit

public static void parse8bit(long offset,
                             @NotNull
                             @NotNull RandomDataInput bytesStore,
                             Appendable appendable,
                             int utflen)
                      throws BufferUnderflowException,
                             IOException,
                             IllegalStateException

Throws:: BufferUnderflowException; IOException; IllegalStateException

parseUtf81

public static void parseUtf81(@NotNull
                              @NotNull StreamingDataInput bytes,
                              @NotNull
                              @NotNull Appendable appendable,
                              boolean utf,
                              int length)
                       throws UTFDataFormatRuntimeException,
                              BufferUnderflowException,
                              IllegalStateException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException; IllegalStateException

parseUtf81

public static void parseUtf81(@NotNull
                              @NotNull RandomDataInput input,
                              long offset,
                              @NotNull
                              @NotNull Appendable appendable,
                              int utflen)
                       throws UTFDataFormatRuntimeException,
                              BufferUnderflowException,
                              IllegalStateException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException; IllegalStateException

parse8bit1

public static void parse8bit1(@NotNull
                              @NotNull StreamingDataInput bytes,
                              @NotNull
                              @NotNull StringBuilder sb,
                              int utflen)
                       throws IllegalStateException

Throws:: IllegalStateException

parse8bit1

public static void parse8bit1(@NotNull
                              @NotNull StreamingDataInput bytes,
                              @NotNull
                              @NotNull Appendable appendable,
                              int utflen)
                       throws IllegalStateException,
                              IOException

Throws:: IllegalStateException; IOException

parse8bit1

public static void parse8bit1(long offset,
                              @NotNull
                              @NotNull RandomDataInput bytes,
                              @NotNull
                              @NotNull Appendable appendable,
                              int utflen)
                       throws BufferUnderflowException,
                              IllegalStateException,
                              IOException

Throws:: BufferUnderflowException; IllegalStateException; IOException

parseUtf8_SB1

public static void parseUtf8_SB1(@NotNull
                                 @NotNull Bytes<?> bytes,
                                 @NotNull
                                 @NotNull StringBuilder sb,
                                 boolean utf,
                                 int utflen)
                          throws UTFDataFormatRuntimeException,
                                 BufferUnderflowException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException

parseUtf8_SB1

public static void parseUtf8_SB1(@NotNull
                                 @NotNull NativeBytesStore bytes,
                                 long offset,
                                 @NotNull
                                 @NotNull StringBuilder sb,
                                 int utflen)
                          throws UTFDataFormatRuntimeException,
                                 BufferUnderflowException,
                                 IllegalStateException

Throws:: UTFDataFormatRuntimeException; BufferUnderflowException; IllegalStateException

parse8bit_SB1

public static int parse8bit_SB1(long offset,
                                @NotNull
                                @NotNull NativeBytesStore nbs,
                                @NotNull
                                @NotNull StringBuilder sb,
                                int length)

writeUtf8

public static void writeUtf8(@NotNull
                             @NotNull StreamingDataOutput bytes,
                             @Nullable
                             @Nullable String str)
                      throws BufferOverflowException,
                             IllegalStateException,
                             IllegalArgumentException,
                             BufferUnderflowException

Throws:: BufferOverflowException; IllegalStateException; IllegalArgumentException; BufferUnderflowException

writeUtf8

public static void writeUtf8(@NotNull
                             @NotNull StreamingDataOutput bytes,
                             @Nullable
                             @Nullable CharSequence str)
                      throws BufferOverflowException,
                             IllegalStateException,
                             BufferUnderflowException,
                             IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException; IllegalArgumentException

writeUtf8

public static long writeUtf8(@NotNull
                             @NotNull RandomDataOutput out,
                             long writeOffset,
                             @Nullable
                             @Nullable CharSequence str)
                      throws BufferOverflowException,
                             IllegalStateException,
                             ArithmeticException

Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writeUtf8

public static long writeUtf8(@NotNull
                             @NotNull RandomDataOutput out,
                             long offset,
                             @Nullable
                             @Nullable CharSequence str,
                             int maxUtf8Len)
                      throws BufferOverflowException,
                             IllegalStateException,
                             ArithmeticException

Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

asBytes

@NotNull
public static @NotNull Bytes<?> asBytes(@NotNull
                                                 @NotNull RandomDataOutput bytes,
                                                 long position,
                                                 long limit)
                                          throws IllegalStateException,
                                                 BufferOverflowException,
                                                 BufferUnderflowException

Throws:: IllegalStateException; BufferOverflowException; BufferUnderflowException

appendUtf8

public static void appendUtf8(@NotNull
                              @NotNull StreamingDataOutput bytes,
                              @NotNull
                              @NotNull CharSequence str,
                              int offset,
                              int length)
                       throws IndexOutOfBoundsException

Throws:: IndexOutOfBoundsException

appendUtf8

public static long appendUtf8(@NotNull
                              @NotNull RandomDataOutput out,
                              long outOffset,
                              @NotNull
                              @NotNull CharSequence str,
                              int strOffset,
                              int length)
                       throws IndexOutOfBoundsException,
                              BufferOverflowException,
                              IllegalStateException

Throws:: IndexOutOfBoundsException; BufferOverflowException; IllegalStateException

append8bit

public static void append8bit(long offsetInRDO,
                              RandomDataOutput bytes,
                              @NotNull
                              @NotNull CharSequence str,
                              int offset,
                              int length)
                       throws IllegalArgumentException,
                              BufferOverflowException,
                              BufferUnderflowException,
                              IndexOutOfBoundsException,
                              IllegalStateException,
                              ArithmeticException

Throws:: IllegalArgumentException; BufferOverflowException; BufferUnderflowException; IndexOutOfBoundsException; IllegalStateException; ArithmeticException

appendUtf8Char

public static void appendUtf8Char(@NotNull
                                  @NotNull StreamingDataOutput bytes,
                                  int c)
                           throws BufferOverflowException,
                                  IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

appendUtf8Char

public static long appendUtf8Char(@NotNull
                                  @NotNull RandomDataOutput out,
                                  long offset,
                                  int c)
                           throws BufferOverflowException,
                                  IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBitNeg1

public static void writeStopBitNeg1(@NotNull
                                    @NotNull StreamingDataOutput out)

writeStopBit

public static void writeStopBit(@NotNull
                                @NotNull StreamingDataOutput out,
                                char n)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBit

public static long writeStopBit(long addr,
                                long n)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBit

public static void writeStopBit(@NotNull
                                @NotNull StreamingDataOutput out,
                                long n)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBit

public static long writeStopBit(@NotNull
                                @NotNull RandomDataOutput out,
                                long offset,
                                long n)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBit

public static void writeStopBit(@NotNull
                                @NotNull StreamingDataOutput out,
                                double d)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

readStopBitDouble

public static double readStopBitDouble(@NotNull
                                       @NotNull StreamingDataInput in)
                                throws IllegalStateException

Throws:: IllegalStateException

writeStopBit0

public static void writeStopBit0(@NotNull
                                 @NotNull StreamingDataOutput out,
                                 long n)
                          throws BufferOverflowException,
                                 IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

stopBitLength0

public static int stopBitLength0(long n)

toDebugString

public static String toDebugString(@NotNull
                                   @NotNull RandomDataInput bytes,
                                   long maxLength)
                            throws IllegalStateException,
                                   ArithmeticException

Throws:: IllegalStateException; ArithmeticException

asSize

@NotNull
public static @NotNull Object asSize(long size)

to8bitString

public static String to8bitString(@NotNull
                                  @NotNull BytesStore bytes)

toString

@NotNull
public static @NotNull String toString(@NotNull
                                                @NotNull RandomDataInput bytes)

readStopBitChar

public static char readStopBitChar(@NotNull
                                   @NotNull StreamingDataInput in)
                            throws net.openhft.chronicle.core.io.IORuntimeException,
                                   IllegalStateException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

readStopBit

public static long readStopBit(@NotNull
                               @NotNull StreamingDataInput in)
                        throws net.openhft.chronicle.core.io.IORuntimeException,
                               IllegalStateException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

readStopBit0

public static long readStopBit0(@NotNull
                                @NotNull StreamingDataInput in,
                                long l)
                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                IllegalStateException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

append

public static void append(@NotNull
                          @NotNull ByteStringAppender out,
                          long num,
                          int base)
                   throws IllegalArgumentException,
                          BufferOverflowException,
                          IllegalStateException,
                          IndexOutOfBoundsException

Throws:: IllegalArgumentException; BufferOverflowException; IllegalStateException; IndexOutOfBoundsException

appendBase10

public static void appendBase10(@NotNull
                                @NotNull ByteStringAppender out,
                                int num)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

appendBase10

public static void appendBase10(@NotNull
                                @NotNull ByteStringAppender out,
                                long num)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

appendBase16

public static void appendBase16(@NotNull
                                @NotNull ByteStringAppender out,
                                long num,
                                int minDigits)
                         throws IllegalArgumentException,
                                BufferOverflowException,
                                IllegalStateException

Throws:: IllegalArgumentException; BufferOverflowException; IllegalStateException

appendDecimal

public static void appendDecimal(@NotNull
                                 @NotNull ByteStringAppender out,
                                 long num,
                                 int decimalPlaces)
                          throws BufferOverflowException,
                                 IllegalStateException,
                                 ArithmeticException,
                                 IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; ArithmeticException; IllegalArgumentException

prepend

public static void prepend(@NotNull
                           @NotNull BytesPrepender out,
                           long num)
                    throws BufferOverflowException,
                           IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

append

public static void append(@NotNull
                          @NotNull RandomDataOutput out,
                          long offset,
                          long num,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException

The length of the number must be fixed otherwise short numbers will not overwrite longer numbers

Throws:: BufferOverflowException; IllegalArgumentException; IllegalStateException

appendDecimal

public static void appendDecimal(@NotNull
                                 @NotNull RandomDataOutput out,
                                 long num,
                                 long offset,
                                 int decimalPlaces,
                                 int width)
                          throws net.openhft.chronicle.core.io.IORuntimeException,
                                 IllegalArgumentException,
                                 BufferOverflowException,
                                 ArithmeticException,
                                 IllegalStateException

Appends given long value with given decimalPlaces to RandomDataOutput out

Parameters:: width - Maximum width. I will be padded with zeros to the left if necessary
Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferOverflowException; ArithmeticException; IllegalStateException

append

public static void append(@NotNull
                          @NotNull StreamingDataOutput out,
                          double d)
                   throws BufferOverflowException,
                          IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

append

public static void append(@NotNull
                          @NotNull ByteStringAppender bytesStringAppender,
                          double d,
                          int decimalPlaces)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException,
                          ArithmeticException

Throws:: BufferOverflowException; IllegalArgumentException; IllegalStateException; ArithmeticException

readUtf8

@Nullable
public static @Nullable String readUtf8(@NotNull
                                                  @NotNull StreamingDataInput in)
                                           throws BufferUnderflowException,
                                                  net.openhft.chronicle.core.io.IORuntimeException,
                                                  IllegalStateException,
                                                  ArithmeticException

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException; ArithmeticException

readUtf8

@Nullable
public static @Nullable String readUtf8(@NotNull
                                                  @NotNull RandomDataInput in,
                                                  long offset,
                                                  int maxUtf8Len)
                                           throws BufferUnderflowException,
                                                  IllegalArgumentException,
                                                  IllegalStateException,
                                                  net.openhft.chronicle.core.io.IORuntimeException

Throws:: BufferUnderflowException; IllegalArgumentException; IllegalStateException; net.openhft.chronicle.core.io.IORuntimeException

acquireStringBuilder

public static StringBuilder acquireStringBuilder()

acquireBytes
```
public static Bytes<?> acquireBytes()
```

read8bit

@Nullable
public static @Nullable String read8bit(@NotNull
                                                  @NotNull StreamingDataInput in)
                                           throws BufferUnderflowException,
                                                  net.openhft.chronicle.core.io.IORuntimeException,
                                                  ArithmeticException,
                                                  IllegalStateException

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; ArithmeticException; IllegalStateException

parseUtf8

@Nullable
public static @Nullable String parseUtf8(@NotNull
                                                   @NotNull StreamingDataInput bytes,
                                                   @NotNull
                                                   @NotNull StopCharTester tester)
                                            throws IllegalStateException,
                                                   ArithmeticException

Throws:: IllegalStateException; ArithmeticException

parseUtf8

public static void parseUtf8(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull Appendable builder,
                             @NotNull
                             @NotNull StopCharTester tester)
                      throws BufferUnderflowException,
                             IllegalStateException,
                             ArithmeticException

Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

parseUtf8

public static void parseUtf8(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull Appendable builder,
                             @NotNull
                             @NotNull StopCharsTester tester)
                      throws BufferUnderflowException,
                             net.openhft.chronicle.core.io.IORuntimeException,
                             IllegalStateException

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

parse8bit

public static void parse8bit(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull StringBuilder builder,
                             @NotNull
                             @NotNull StopCharsTester tester)
                      throws IllegalStateException

Throws:: IllegalStateException

parse8bit

public static void parse8bit(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull Bytes<?> builder,
                             @NotNull
                             @NotNull StopCharsTester tester)
                      throws BufferUnderflowException,
                             BufferOverflowException,
                             IllegalStateException,
                             ArithmeticException

Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException; ArithmeticException

parse8bit

public static void parse8bit(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull StringBuilder builder,
                             @NotNull
                             @NotNull StopCharTester tester)
                      throws IllegalStateException

Throws:: IllegalStateException

parse8bit

public static void parse8bit(@NotNull
                             @NotNull StreamingDataInput bytes,
                             @NotNull
                             @NotNull Bytes<?> builder,
                             @NotNull
                             @NotNull StopCharTester tester)
                      throws BufferUnderflowException,
                             BufferOverflowException,
                             IllegalStateException,
                             ArithmeticException

Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException; ArithmeticException

parseFlexibleLong

public static long parseFlexibleLong(@NotNull
                                     @NotNull StreamingDataInput in)
                              throws BufferUnderflowException,
                                     IllegalStateException,
                                     net.openhft.chronicle.core.io.IORuntimeException

Throws:: BufferUnderflowException; IllegalStateException; net.openhft.chronicle.core.io.IORuntimeException

parseDouble

public static double parseDouble(@NotNull
                                 @NotNull StreamingDataInput in)
                          throws BufferUnderflowException,
                                 IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

parseLong

public static long parseLong(@NotNull
                             @NotNull StreamingDataInput in)
                      throws BufferUnderflowException,
                             IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

parseLongDecimal

public static long parseLongDecimal(@NotNull
                                    @NotNull StreamingDataInput in)
                             throws BufferUnderflowException,
                                    IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

parseHexLong

public static long parseHexLong(@NotNull
                                @NotNull StreamingDataInput in)
                         throws BufferUnderflowException,
                                IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

parseLong

public static long parseLong(@NotNull
                             @NotNull RandomDataInput in,
                             long offset)
                      throws BufferUnderflowException,
                             IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

addAndGetFloat

public static float addAndGetFloat(@NotNull
                                   @NotNull BytesStore<?,?> in,
                                   long offset,
                                   float adding)
                            throws BufferUnderflowException,
                                   IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

addAndGetDouble

public static double addAndGetDouble(@NotNull
                                     @NotNull BytesStore<?,?> in,
                                     long offset,
                                     double adding)
                              throws BufferUnderflowException,
                                     IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

addAndGetInt

public static int addAndGetInt(@NotNull
                               @NotNull BytesStore<?,?> in,
                               long offset,
                               int adding)
                        throws BufferUnderflowException,
                               IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

addAndGetLong

public static long addAndGetLong(@NotNull
                                 @NotNull BytesStore<?,?> in,
                                 long offset,
                                 long adding)
                          throws BufferUnderflowException,
                                 IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

toHexString
```
public static String toHexString(@NotNull
                                 @NotNull Bytes<?> bytes,
                                 long offset,
                                 long maxLength)
                          throws BufferUnderflowException,
                                 IllegalStateException
```
Converts the content of the provided Bytes buffer to a hexadecimal string representation along with comments describing the meaning of the bytes.
The method reads the data from the offset with maxLength of the given bytes. Each line of the output string contains hexadecimal representation of 16 bytes, followed by comments describing the meaning of those bytes.
For example, a buffer containing bytes representing the ASCII string "VMH" would produce an output like this:
```
 c3 76 6d 68                                     # vmh:
 b6 03 56 4d 48                                  # VMH
 
```
Parameters:

bytes - The buffer whose content is to be converted to a hexadecimal string. Must not be null.

offset - The starting offset within the buffer to begin the hexadecimal conversion.

maxLength - The number of bytes to convert from the buffer.

Returns:

A hexadecimal representation of the buffer content with comments describing the bytes. Each line of the string contains the hexadecimal representation of 16 bytes.

Throws:

BufferUnderflowException - if there is not enough data in the buffer.

IllegalStateException - if there is a problem with the buffer's state.

IllegalArgumentException - if the provided offset or maxLength are negative.

appendTimeMillis

public static void appendTimeMillis(@NotNull
                                    @NotNull ByteStringAppender b,
                                    long timeInMS)
                             throws BufferOverflowException,
                                    IllegalStateException,
                                    IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; IllegalArgumentException

equalBytesAny

public static boolean equalBytesAny(@NotNull
                                    @NotNull BytesStore b1,
                                    @NotNull
                                    @NotNull BytesStore b2,
                                    long readRemaining)
                             throws BufferUnderflowException,
                                    IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

appendDateMillis

public static void appendDateMillis(@NotNull
                                    @NotNull ByteStringAppender b,
                                    long timeInMS)
                             throws BufferOverflowException,
                                    IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

readEnum

@NotNull
public static <E extends Enum<E>,S extends StreamingDataInput<S>> E readEnum(@NotNull
                                                                                      @NotNull StreamingDataInput input,
                                                                                      @NotNull
                                                                                      @NotNull Class<E> eClass)
                                                                               throws BufferUnderflowException,
                                                                                      net.openhft.chronicle.core.io.IORuntimeException,
                                                                                      BufferOverflowException,
                                                                                      IllegalStateException,
                                                                                      ArithmeticException

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; BufferOverflowException; IllegalStateException; ArithmeticException

writeFully

public static void writeFully(@NotNull
                              @NotNull RandomDataInput bytes,
                              long offset,
                              long length,
                              @NotNull
                              @NotNull StreamingDataOutput sdo)
                       throws BufferUnderflowException,
                              BufferOverflowException,
                              IllegalStateException

Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException

copyMemory

public static void copyMemory(long from,
                              long to,
                              int length)

toByteArray

@NotNull
public static @NotNull byte[] toByteArray(@NotNull
                                                   @NotNull RandomDataInput in)
                                            throws IllegalStateException

Throws:: IllegalStateException

copy

public static void copy(@NotNull
                        @NotNull RandomDataInput input,
                        @NotNull
                        @NotNull OutputStream output)
                 throws IOException,
                        IllegalStateException

Throws:: IOException; IllegalStateException

copy

public static void copy(@NotNull
                        @NotNull InputStream input,
                        @NotNull
                        @NotNull StreamingDataOutput output)
                 throws IOException,
                        BufferOverflowException,
                        IllegalStateException

Throws:: IOException; BufferOverflowException; IllegalStateException

parseBoolean

public static Boolean parseBoolean(@NotNull
                                   @NotNull ByteStringParser parser,
                                   @NotNull
                                   @NotNull StopCharTester tester)
                            throws BufferUnderflowException,
                                   IllegalStateException,
                                   ArithmeticException

Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

subBytes

@NotNull
public static @NotNull BytesStore subBytes(RandomDataInput from,
                                                    long start,
                                                    long length)
                                             throws BufferUnderflowException,
                                                    IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

findByte

public static long findByte(@NotNull
                            @NotNull RandomDataInput bytes,
                            byte stopByte)
                     throws IllegalStateException

Throws:: IllegalStateException

fromHexString

@NotNull
public static @NotNull Bytes<?> fromHexString(@NotNull
                                                       @NotNull String s)

readHistogram

public static void readHistogram(@NotNull
                                 @NotNull StreamingDataInput in,
                                 @NotNull
                                 @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                          throws IllegalStateException,
                                 BufferUnderflowException,
                                 ArithmeticException

Throws:: IllegalStateException; BufferUnderflowException; ArithmeticException

writeHistogram

public static void writeHistogram(@NotNull
                                  @NotNull StreamingDataOutput out,
                                  @NotNull
                                  @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                           throws BufferOverflowException,
                                  IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

asByteBuffer

public static ByteBuffer asByteBuffer(@NotNull
                                      @NotNull BytesStore bytesStore)
                               throws BufferUnderflowException,
                                      IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

asByteBuffer2

public static ByteBuffer asByteBuffer2(@NotNull
                                       @NotNull BytesStore bytesStore)
                                throws BufferUnderflowException,
                                       IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

assignBytesStoreToByteBuffer

public static void assignBytesStoreToByteBuffer(@NotNull
                                                @NotNull BytesStore bytesStore,
                                                @NotNull
                                                @NotNull ByteBuffer byteBuffer)
                                         throws BufferUnderflowException,
                                                IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

parse8bit

public static String parse8bit(ByteStringParser bsp,
                               StopCharTester stopCharTester)
                        throws IllegalStateException

Throws:: IllegalStateException

copy8bit

public static void copy8bit(BytesStore bs,
                            long addressForWrite,
                            long length)

digitsForExponent

public static int digitsForExponent(int exponent)

failIfBytesOnBytes

public static <B extends BytesStore<B,U>,U> BytesStore<B,U> failIfBytesOnBytes(BytesStore<B,U> bytesStore)

Enum BytesInternal

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Field Detail

BYTE_BUFFER_TL

BYTE_BUFFER2_TL

SI

Method Detail

values

valueOf

contentEqual

startsWith

startsWithUnchecked

parseUtf8

parseUtf8

compareUtf8

parse8bit

parseUtf81

parseUtf81

parse8bit1

parse8bit1

parse8bit1

parseUtf8_SB1

parseUtf8_SB1

parse8bit_SB1

writeUtf8

writeUtf8

writeUtf8

writeUtf8

asBytes

appendUtf8

appendUtf8

append8bit

appendUtf8Char

appendUtf8Char

writeStopBitNeg1

writeStopBit

writeStopBit

writeStopBit

writeStopBit

writeStopBit

readStopBitDouble

writeStopBit0

stopBitLength0

toDebugString

asSize

to8bitString

toString

readStopBitChar

readStopBit

readStopBit0

append

appendBase10

appendBase10

appendBase16

appendDecimal

prepend

append

appendDecimal

append

append

readUtf8

readUtf8

acquireStringBuilder

acquireBytes

read8bit

parseUtf8

parseUtf8

parseUtf8

parse8bit

parse8bit

parse8bit

parse8bit

parseFlexibleLong

parseDouble

parseLong

parseLongDecimal

parseHexLong