ValueOut (OpenHFT/Chronicle-Wire 2.26ea3 API)

All Known Implementing Classes:

BinaryWire.BinaryValueOut, BinaryWire.FixedBinaryValueOut
```
public interface ValueOut
```
Defines an interface for writing out values after writing a field. Implementations of this interface should provide methods to handle writing various data types.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class ValueOut.MapMarshaller<K,V>
MapMarshaller is a utility for serializing a Map into a Wire format.

Nested Classes
Modifier and Type	Interface and Description
`static class`	`ValueOut.MapMarshaller<K,V>` MapMarshaller is a utility for serializing a Map into a Wire format.

Field Summary

Fields
Modifier and Type	Field and Description
`static ThreadLocal<ValueOut.MapMarshaller>`	`MM_TL` Thread local instance for MapMarshaller to support thread-safe marshalling operations.
`static int`	`SMALL_MESSAGE` Defines a threshold for small messages.
`static String`	`ZEROS_64` Represents a 64-character sequence of zeros.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default WireOut`	`array(boolean[] array, int length)` Writes an array of boolean values to the wire output.
`default WireOut`	`array(byte[] array, int length)` Writes an array of byte values to the wire output.
`default WireOut`	`array(net.openhft.chronicle.bytes.Bytes[] array, int length)` Writes an array of byte sequences of a specified length.
`default WireOut`	`array(double[] array, int length)` Writes an array of doubles of a specified length.
`default WireOut`	`array(int[] array, int length)` Writes an array of int values to the wire output.
`default WireOut`	`array(long[] array, int length)` Writes an array of long values to the wire output.
`default @NotNull WireOut`	`array(@NotNull WriteValue writer, @NotNull Class<?> arrayType)` Writes an array of specified type objects to the wire output, using the provided writer.
`default WireOut`	`arrayDelta(double[] array, int length)` This write value's relative to the first one using 6 digit precision
`default WireOut`	`arrayDelta(long[] array, int length)` Writes the delta of long values in an array to the wire output.
`default <E extends Enum<E>> @NotNull WireOut`	`asEnum(E e)` Writes an enum value to the wire output.
`@NotNull WireOut`	`bool(Boolean flag)` Write a boolean value.
`@NotNull WireOut`	`boolForBinding(boolean value, @NotNull net.openhft.chronicle.core.values.BooleanValue longValue)` Writes a boolean value for binding with the given BooleanValue.
`@NotNull WireOut`	`bytes(byte[] fromBytes)` Write a sequence of bytes.
`@NotNull WireOut`	`bytes(@Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)` Write a sequence of bytes based on the content of a `BytesStore` object.
`@NotNull WireOut`	`bytes(String type, byte[] fromBytes)` Write a typed sequence of bytes.
`@NotNull WireOut`	`bytes(String type, @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)` Write a typed sequence of bytes based on the content of a `BytesStore` object.
`default @NotNull WireOut`	`bytesLiteral(@Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)` Write a sequence of bytes from a `BytesStore` object as a literal value, if supported by the wire type.
`default WireOut`	`bytesMarshallable(net.openhft.chronicle.bytes.WriteBytesMarshallable value)` Serialize an object implementing the WriteBytesMarshallable interface.
`default @NotNull WireOut`	`character(char c)` Write a character value as text.
`net.openhft.chronicle.core.pool.ClassLookup`	`classLookup()` Provides a lookup mechanism to resolve class names.
`default <V> @NotNull WireOut`	`collection(Collection<V> coll, Class<V> assumedClass)` Writes a collection to the wire output, specifying the type of its entries.
`default @NotNull WireOut`	`compress(@NotNull String compression, @Nullable net.openhft.chronicle.bytes.Bytes<?> uncompressedBytes)` Compresses the given bytes using the specified compression technique.
`default int`	`compressedSize()`
`@NotNull WireOut`	`date(LocalDate localDate)` Write a date value.
`@NotNull WireOut`	`dateTime(LocalDateTime localDateTime)` Write a local date-time value, which represents both date and time without a time zone.
`default void`	`elementSeparator()` Signifies the end of an element that has been added direcftly to the wire.
`default void`	`endTypePrefix()` Ends the type prefix scope for the written data.
`default @NotNull WireOut`	`fixedFloat32(float value)` Serialize a float value prefixed with its type.
`default @NotNull WireOut`	`fixedFloat64(double value)` Serialize a double value.
`default @NotNull WireOut`	`fixedInt16(short value)` Serialize a short (signed 16-bit) value prefixed with its type.
`default @NotNull WireOut`	`fixedInt32(int value)` Serialize an int (signed 32-bit) value prefixed with its type.
`default @NotNull WireOut`	`fixedInt64(long value)` Serialize a long (signed 64-bit) value.
`default @NotNull WireOut`	`fixedInt8(byte value)` Serialize a byte (signed 8-bit) value prefixed with its type.
`@NotNull WireOut`	`float32(float f)` Write a 32-bit floating-point value.
`default @NotNull WireOut`	`float32(float f, float previous)` Write a 32-bit floating-point value.
`@NotNull WireOut`	`float64(double d)` Write a 64-bit floating-point value, also known as a double.
`default @NotNull WireOut`	`float64(double d, double previous)` Write a 64-bit floating-point value.
`default @NotNull WireOut`	`int128forBinding(long value, long value2)` Throws an unsupported operation exception by default.
`@NotNull WireOut`	`int128forBinding(long i64x0, long i64x1, net.openhft.chronicle.core.values.TwoLongValue value)` Write two signed 64-bit integer values bound to a TwoLongValue object.
`default @NotNull WireOut`	`int16(long x)` Write a signed 16-bit integer value.
`@NotNull WireOut`	`int16(short i16)` Write a signed 16-bit integer value.
`@NotNull WireOut`	`int32(int i32)` Write a signed 32-bit integer value.
`default @NotNull WireOut`	`int32(int i32, int previous)` Write a signed 32-bit integer value.
`default @NotNull WireOut`	`int32(long x)` Write a signed 32-bit integer value.
`@NotNull WireOut`	`int32forBinding(int value)` Writes a 32-bit integer for binding.
`@NotNull WireOut`	`int32forBinding(int value, @NotNull net.openhft.chronicle.core.values.IntValue intValue)` Writes a 32-bit integer for binding with the given IntValue.
`@NotNull WireOut`	`int64_0x(long i64)` Write a signed 64-bit integer value as a hexadecimal representation.
`@NotNull WireOut`	`int64(long i64)` Write a signed 64-bit integer value.
`default @NotNull WireOut`	`int64(long i64, long previous)` Write a signed 64-bit integer value.
`@NotNull WireOut`	`int64array(long capacity)` Allocate space for writing an array of 64-bit integers.
`@NotNull WireOut`	`int64array(long capacity, net.openhft.chronicle.core.values.LongArrayValues values)` Write a sequence of 64-bit integers into an array, using the provided LongArrayValues object as the source of the values.
`@NotNull WireOut`	`int64forBinding(long value)` Writes a 64-bit integer for binding.
`@NotNull WireOut`	`int64forBinding(long value, @NotNull net.openhft.chronicle.core.values.LongValue longValue)` Writes a 64-bit integer for binding with the given LongValue.
`@NotNull WireOut`	`int8(byte i8)` Write a signed 8-bit integer value.
`default @NotNull WireOut`	`int8(long x)` Write a signed 8-bit integer value.
`static boolean`	`isAnEnum(Object v)` Checks if the provided object is an instance of Enum or DynamicEnum.
`default boolean`	`isBinary()` Indicates if the current wire type is a binary wire.
`default <V> @NotNull WireOut`	`list(List<V> coll)` Writes a list to the wire output.
`default <V> @NotNull WireOut`	`list(List<V> coll, Class<V> assumedClass)` Writes a list to the wire output, while specifying the type of its entries.
`@NotNull WireOut`	`map(Map map)` Writes the contents of a specified map to the wire output.
`default <K,V> @NotNull WireOut`	`marshallable(Map<K,V> map)` Writes a map to the wire output.
`default <K,V> @NotNull WireOut`	`marshallable(@Nullable Map<K,V> map, @NotNull Class<K> kClass, @NotNull Class<V> vClass, boolean leaf)` Writes a map to the wire output, specifying classes for keys and values.
`@NotNull WireOut`	`marshallable(Serializable object)` Writes a value that implements the `Serializable` interface to the wire output.
`@NotNull WireOut`	`marshallable(WriteMarshallable object)` Writes a value that implements the `WriteMarshallable` interface to the wire output.
`default @NotNull WireOut`	`nu11()` Write a null value.
`default <V> @NotNull WireOut`	`object(@NotNull Class<? extends V> expectedType, V v)` Writes an object to the wire output, specifying its expected type.
`default @NotNull WireOut`	`object(@Nullable Object value)` Writes an object to the wire output.
`default @NotNull ValueOut`	`optionalTyped(Class<?> aClass)` Add an optional type i.e.
`@NotNull WireOut`	`rawBytes(byte[] value)` Write a raw sequence of bytes.
`default @NotNull WireOut`	`rawText(CharSequence value)` Write a raw text value.
`default void`	`resetBetweenDocuments()`
`void`	`resetState()`
`default <T> @NotNull WireOut`	`sequence(Iterable<T> t)` Writes a sequence of values from an `Iterator`.
`<T> @NotNull WireOut`	`sequence(T t, BiConsumer<T,ValueOut> writer)` Writes a sequence of values using the provided writer.
`<T,K> @NotNull WireOut`	`sequence(T t, K param, TriConsumer<T,K,ValueOut> writer)` Writes a sequence of values using the provided parametrized writer.
`default @NotNull WireOut`	`sequence(WriteValue writer)` Writes a sequence of values to the wire using the provided writer.
`default <T> WireOut`	`sequenceWithLength(T t, int length, ObjectIntObjectConsumer<T,ValueOut> writer)` Writes a sequence of values of a specified length.
`default <V> @NotNull WireOut`	`set(Set<V> coll)` Writes a set value to the wire output.
`default <V> @NotNull WireOut`	`set(Set<V> coll, Class<V> assumedClass)` Writes a set to the wire output, while specifying the type of its entries.
`default boolean`	`swapLeaf(boolean isLeaf)` Determines if the current WireOut is in a leaf node state.
`default @NotNull WireOut`	`text(@Nullable net.openhft.chronicle.bytes.BytesStore<?,?> s)` Write a text value based on the contents of a `BytesStore` object.
`default @NotNull WireOut`	`text(char c)` Write a text value that's made up of a single character.
`@NotNull WireOut`	`text(@Nullable CharSequence s)` Write a text value.
`default @NotNull WireOut`	`text(@Nullable String s)` Write a text value.
`default @NotNull WireOut`	`throwable(@NotNull Throwable t)` Write a throwable value.
`@NotNull WireOut`	`time(LocalTime localTime)` Write a local time value.
`default @NotNull WireOut`	`typedMarshallable(CharSequence typeName, WriteMarshallable object)` Writes a value that implements the `WriteMarshallable` interface to the wire output, while prepending it with a specified type prefix.
`default @NotNull WireOut`	`typedMarshallable(@Nullable Serializable object)` Writes a value that implements the `Serializable` interface to the wire output.
`default @NotNull WireOut`	`typedMarshallable(@Nullable WriteMarshallable marshallable)` To be used when you know it is a typed marshallable object.
`default @NotNull WireOut`	`typedScalar(@NotNull Object value)` Write a typed scalar value as type prefixed text.
`@NotNull WireOut`	`typeLiteral(@NotNull BiConsumer<Class,net.openhft.chronicle.bytes.Bytes<?>> typeTranslator, @Nullable Class<?> type)` Writes a type literal using the specified type translator function.
`@NotNull WireOut`	`typeLiteral(@Nullable CharSequence type)` Write a type literal value.
`default @NotNull WireOut`	`typeLiteral(@Nullable Class<?> type)` Write a type literal for a specified `Class`.
`default @NotNull WireOut`	`typeLiteral(@Nullable Type type)` Write a type literal for a specified `Type`.
`@NotNull ValueOut`	`typePrefix(CharSequence typeName)` Write a prefix that denotes a type for the upcoming value.
`default @NotNull ValueOut`	`typePrefix(Class<?> type)` Write a type prefix for a specified `Class` object.
`default @NotNull WireOut`	`uint16(long x)` Write an unsigned 16-bit integer value.
`@NotNull WireOut`	`uint16checked(int u16)` Write an unsigned 16-bit integer value.
`default @NotNull WireOut`	`uint32(long x)` Write an unsigned 32-bit integer value.
`@NotNull WireOut`	`uint32checked(long u32)` Write an unsigned 32-bit integer value.
`default @NotNull WireOut`	`uint8(int x)` Write an unsigned 8-bit integer value.
`@NotNull WireOut`	`uint8checked(int u8)` Write an unsigned 8-bit integer value.
`default @NotNull WireOut`	`untypedObject(@Nullable Object value)` Write an untyped object value.
`@NotNull WireOut`	`utf8(int codepoint)` Write a single 16-bit Unicode codepoint as UTF-8.
`@NotNull WireOut`	`uuid(UUID uuid)` Writes a universally unique identifier (UUID) to the wire.
`@NotNull WireOut`	`wireOut()`
`default WireOut`	`writeBoolean(boolean x)` Writes a boolean value to the wire.
`default WireOut`	`writeByte(byte x)` Writes a byte value to the wire.
`default WireOut`	`writeChar(char x)` Writes a char value to the wire.
`default WireOut`	`writeDouble(double x)` Writes a double value to the wire.
`default WireOut`	`writeFloat(float x)` Writes a float value to the wire.
`default WireOut`	`writeInt(int x)` Writes an int value to the wire.
`default WireOut`	`writeInt(LongConverter converter, int i)` Writes an int value to the wire using a specified converter.
`@NotNull ValueOut`	`writeLength(long remaining)` Write the length of a value if supported by the implementing class.
`default WireOut`	`writeLong(long x)` Writes a long value to the wire.
`default WireOut`	`writeLong(LongConverter longConverter, long l)` Writes a long value to the wire using a specified converter.
`default WireOut`	`writeShort(short x)` Writes a short value to the wire.
`default WireOut`	`writeString(CharSequence x)` Writes a string or a sequence of characters to the wire.
`@NotNull WireOut`	`zonedDateTime(ZonedDateTime zonedDateTime)` Write a zoned date-time value, which includes information about date, time, and the associated time zone.

- Field Detail
  - MM_TL
```
static final ThreadLocal<ValueOut.MapMarshaller> MM_TL
```
    Thread local instance for MapMarshaller to support thread-safe marshalling operations.
  - SMALL_MESSAGE
```
static final int SMALL_MESSAGE
```
    Defines a threshold for small messages.
    
    See Also:
    
    Constant Field Values
  - ZEROS_64
```
static final String ZEROS_64
```
    Represents a 64-character sequence of zeros.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - isAnEnum
```
static boolean isAnEnum(Object v)
```
    Checks if the provided object is an instance of Enum or DynamicEnum.
    
    Parameters:
    
    v - Object to be checked.
    
    Returns:
    
    true if the object is an instance of Enum or DynamicEnum; false otherwise.
  - bool
```
@NotNull
@NotNull WireOut bool(Boolean flag)
```
    Write a boolean value.
    
    Parameters:
    
    flag - The boolean value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
@NotNull WireOut text(@Nullable
                               @Nullable CharSequence s)
```
    Write a text value.
    
    Parameters:
    
    s - The CharSequence containing the text to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
default @NotNull WireOut text(@Nullable
                                       @Nullable String s)
```
    Write a text value. This method delegates the writing to text(CharSequence).
    
    Parameters:
    
    s - The String containing the text to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - nu11
```
@NotNull
default @NotNull WireOut nu11()
```
    Write a null value.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
default @NotNull WireOut text(char c)
```
    Write a text value that's made up of a single character.
    
    Parameters:
    
    c - The character to be written as text.
    
    Returns:
    
    The WireOut instance for chained calls.
  - character
```
@NotNull
default @NotNull WireOut character(char c)
```
    Write a character value as text. This method delegates its functionality to text(char).
    
    Parameters:
    
    c - The character to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
default @NotNull WireOut text(@Nullable
                                       @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> s)
```
    Write a text value based on the contents of a BytesStore object. The method casts the BytesStore to a CharSequence for processing.
    
    Parameters:
    
    s - The BytesStore whose contents are to be written as text.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int8
```
@NotNull
default @NotNull WireOut int8(long x)
```
    Write a signed 8-bit integer value. The provided long value is first checked to ensure it fits within the bounds of a signed 8-bit integer.
    
    Parameters:
    
    x - The long value to be written as an 8-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
    
    Throws:
    
    ArithmeticException - if the supplied argument does not fit in an unsigned 8-bit integer.
  - int8
```
@NotNull
@NotNull WireOut int8(byte i8)
```
    Write a signed 8-bit integer value.
    
    Parameters:
    
    i8 - The byte value representing the 8-bit integer to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytes
```
@NotNull
@NotNull WireOut bytes(@Nullable
                                @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Write a sequence of bytes based on the content of a BytesStore object.
    
    Parameters:
    
    fromBytes - The BytesStore containing the byte sequence to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytesLiteral
```
@NotNull
default @NotNull WireOut bytesLiteral(@Nullable
                                               @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Write a sequence of bytes from a BytesStore object as a literal value, if supported by the wire type. If not supported, this method defaults to bytes(BytesStore).
    
    Parameters:
    
    fromBytes - The BytesStore containing the byte sequence to be written as a literal.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytes
```
@NotNull
@NotNull WireOut bytes(String type,
                                @Nullable
                                @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Write a typed sequence of bytes based on the content of a BytesStore object.
    
    Parameters:
    
    type - The string representing the type of byte sequence.
    
    fromBytes - The BytesStore containing the byte sequence to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - rawBytes
```
@NotNull
@NotNull WireOut rawBytes(byte[] value)
```
    Write a raw sequence of bytes. The exact behavior of this method depends on the implementation.
    
    Parameters:
    
    value - The array of bytes to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - rawText
```
@NotNull
default @NotNull WireOut rawText(CharSequence value)
```
    Write a raw text value. The exact behavior of this method depends on the implementation. If not supported, this method defaults to text(CharSequence).
    
    Parameters:
    
    value - The CharSequence representing the text to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - writeLength
```
@NotNull
@NotNull ValueOut writeLength(long remaining)
```
    Write the length of a value if supported by the implementing class.
    
    Parameters:
    
    remaining - The length of the value to be written.
    
    Returns:
    
    A ValueOut instance for chained calls.
  - bytes
```
@NotNull
@NotNull WireOut bytes(byte[] fromBytes)
```
    Write a sequence of bytes.
    
    Parameters:
    
    fromBytes - The array of bytes to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytes
```
@NotNull
@NotNull WireOut bytes(String type,
                                byte[] fromBytes)
```
    Write a typed sequence of bytes.
    
    Parameters:
    
    type - The string representing the type of byte sequence.
    
    fromBytes - The array of bytes to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uint8
```
@NotNull
default @NotNull WireOut uint8(int x)
```
    Write an unsigned 8-bit integer value. The provided integer value is first checked to ensure it fits within the bounds of an unsigned 8-bit integer.
    
    Parameters:
    
    x - The integer value to be written as an unsigned 8-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
    
    Throws:
    
    ArithmeticException - if the supplied argument does not fit in an unsigned 8-bit integer.
  - uint8checked
```
@NotNull
@NotNull WireOut uint8checked(int u8)
```
    Write an unsigned 8-bit integer value. This method assumes the argument is within the correct bounds of an unsigned 8-bit integer and doesn't perform any additional checks.
    
    Parameters:
    
    u8 - The unsigned 8-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int16
```
@NotNull
default @NotNull WireOut int16(long x)
```
    Write a signed 16-bit integer value. The provided long value is first checked to ensure it fits within the bounds of a signed 16-bit integer.
    
    Parameters:
    
    x - The long value to be written as a signed 16-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
    
    Throws:
    
    ArithmeticException - if the supplied argument does not fit in a signed 16-bit integer.
  - int16
```
@NotNull
@NotNull WireOut int16(short i16)
```
    Write a signed 16-bit integer value. This method assumes the argument is within the correct bounds of a signed 16-bit integer and doesn't perform any additional checks.
    
    Parameters:
    
    i16 - The signed 16-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uint16
```
@NotNull
default @NotNull WireOut uint16(long x)
```
    Write an unsigned 16-bit integer value. The provided long value is directly cast to an integer and passed to uint16checked(int) without additional range checks.
    
    Parameters:
    
    x - The long value to be written as an unsigned 16-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uint16checked
```
@NotNull
@NotNull WireOut uint16checked(int u16)
```
    Write an unsigned 16-bit integer value. This method assumes the argument is within the correct bounds of an unsigned 16-bit integer and doesn't perform any additional checks.
    
    Parameters:
    
    u16 - The unsigned 16-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - utf8
```
@NotNull
@NotNull WireOut utf8(int codepoint)
```
    Write a single 16-bit Unicode codepoint as UTF-8. The exact behavior of this method depends on the implementation.
    
    Parameters:
    
    codepoint - The 16-bit Unicode codepoint to be written as UTF-8.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int32
```
@NotNull
default @NotNull WireOut int32(long x)
```
    Write a signed 32-bit integer value. The provided long value is first checked to ensure it fits within the bounds of a signed 32-bit integer.
    
    Parameters:
    
    x - The long value to be written as a signed 32-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
    
    Throws:
    
    ArithmeticException - if the supplied argument does not fit in a signed 32-bit integer.
  - int32
```
@NotNull
@NotNull WireOut int32(int i32)
```
    Write a signed 32-bit integer value. This method assumes the argument is within the correct bounds of a signed 32-bit integer and doesn't perform any additional checks.
    
    Parameters:
    
    i32 - The signed 32-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int32
```
@NotNull
default @NotNull WireOut int32(int i32,
                                        int previous)
```
    Write a signed 32-bit integer value. This overloaded method accepts a previous value, but currently ignores it and delegates to the simpler int32(int) method.
    
    Parameters:
    
    i32 - The signed 32-bit integer value to be written.
    
    previous - The previous value, currently not used in this method.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uint32
```
@NotNull
default @NotNull WireOut uint32(long x)
```
    Write an unsigned 32-bit integer value. The provided long value is directly passed to uint32checked(long) without additional range checks.
    
    Parameters:
    
    x - The long value to be written as an unsigned 32-bit integer.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uint32checked
```
@NotNull
@NotNull WireOut uint32checked(long u32)
```
    Write an unsigned 32-bit integer value. This method assumes the argument is within the correct bounds of an unsigned 32-bit integer and doesn't perform any additional checks.
    
    Parameters:
    
    u32 - The unsigned 32-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64
```
@NotNull
@NotNull WireOut int64(long i64)
```
    Write a signed 64-bit integer value.
    
    Parameters:
    
    i64 - The signed 64-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64
```
@NotNull
default @NotNull WireOut int64(long i64,
                                        long previous)
```
    Write a signed 64-bit integer value. This overloaded method accepts a previous value, but currently ignores it and delegates to the simpler int64(long) method.
    
    Parameters:
    
    i64 - The signed 64-bit integer value to be written.
    
    previous - The previous value, currently not used in this method.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int128forBinding
```
@NotNull
@NotNull WireOut int128forBinding(long i64x0,
                                           long i64x1,
                                           net.openhft.chronicle.core.values.TwoLongValue value)
```
    Write two signed 64-bit integer values bound to a TwoLongValue object.
    
    Parameters:
    
    i64x0 - The first 64-bit integer value.
    
    i64x1 - The second 64-bit integer value.
    
    value - The TwoLongValue object to which the values are bound.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64_0x
```
@NotNull
@NotNull WireOut int64_0x(long i64)
```
    Write a signed 64-bit integer value as a hexadecimal representation. The behavior of this method might differ based on the wire type in use.
    
    Parameters:
    
    i64 - The 64-bit integer value to be written in hexadecimal format.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64array
```
@NotNull
@NotNull WireOut int64array(long capacity)
```
    Allocate space for writing an array of 64-bit integers. The exact behavior might vary depending on the wire type or the underlying implementation.
    
    Parameters:
    
    capacity - The desired capacity of the 64-bit integer array.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64array
```
@NotNull
@NotNull WireOut int64array(long capacity,
                                     net.openhft.chronicle.core.values.LongArrayValues values)
```
    Write a sequence of 64-bit integers into an array, using the provided LongArrayValues object as the source of the values.
    
    Parameters:
    
    capacity - The desired capacity of the 64-bit integer array.
    
    values - The LongArrayValues object containing the 64-bit integers to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - float32
```
@NotNull
@NotNull WireOut float32(float f)
```
    Write a 32-bit floating-point value.
    
    Parameters:
    
    f - The 32-bit float value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - float64
```
@NotNull
@NotNull WireOut float64(double d)
```
    Write a 64-bit floating-point value, also known as a double.
    
    Parameters:
    
    d - The 64-bit double value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - float32
```
@NotNull
default @NotNull WireOut float32(float f,
                                          float previous)
```
    Write a 32-bit floating-point value. This overloaded method accepts a previous value, but currently ignores it and delegates to the simpler float32(float) method.
    
    Parameters:
    
    f - The 32-bit float value to be written.
    
    previous - The previous float value, currently not used in this method.
    
    Returns:
    
    The WireOut instance for chained calls.
  - float64
```
@NotNull
default @NotNull WireOut float64(double d,
                                          double previous)
```
    Write a 64-bit floating-point value. This overloaded method accepts a previous value, but currently ignores it and delegates to the simpler float64(double) method.
    
    Parameters:
    
    d - The 64-bit double value to be written.
    
    previous - The previous double value, currently not used in this method.
    
    Returns:
    
    The WireOut instance for chained calls.
  - time
```
@NotNull
@NotNull WireOut time(LocalTime localTime)
```
    Write a local time value. The exact format and representation might vary depending on the wire type or the underlying implementation.
    
    Parameters:
    
    localTime - The LocalTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - zonedDateTime
```
@NotNull
@NotNull WireOut zonedDateTime(ZonedDateTime zonedDateTime)
```
    Write a zoned date-time value, which includes information about date, time, and the associated time zone.
    
    Parameters:
    
    zonedDateTime - The ZonedDateTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - date
```
@NotNull
@NotNull WireOut date(LocalDate localDate)
```
    Write a date value. The exact format and representation might vary depending on the wire type or the underlying implementation.
    
    Parameters:
    
    localDate - The LocalDate instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - dateTime
```
@NotNull
@NotNull WireOut dateTime(LocalDateTime localDateTime)
```
    Write a local date-time value, which represents both date and time without a time zone. The exact format and representation might vary depending on the wire type or the underlying implementation.
    
    Parameters:
    
    localDateTime - The LocalDateTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typePrefix
```
@NotNull
@NotNull ValueOut typePrefix(CharSequence typeName)
```
    Write a prefix that denotes a type for the upcoming value. This is useful for wire formats that include type information, allowing for dynamic deserialization.
    
    Parameters:
    
    typeName - The name of the type as a CharSequence.
    
    Returns:
    
    The ValueOut instance for chained calls.
  - typePrefix
```
@NotNull
default @NotNull ValueOut typePrefix(Class<?> type)
```
    Write a type prefix for a specified Class object. If the class object is null, no action is taken; otherwise, it fetches the type name from a lookup method.
    
    Parameters:
    
    type - The Class object representing the type.
    
    Returns:
    
    The ValueOut instance for chained calls.
  - classLookup
```
net.openhft.chronicle.core.pool.ClassLookup classLookup()
```
    Provides a lookup mechanism to resolve class names. The exact mechanism and source of class name data is determined by the implementation.
    
    Returns:
    
    A ClassLookup instance used for resolving class names.
  - typeLiteral
```
@NotNull
default @NotNull WireOut typeLiteral(@Nullable
                                              @Nullable Class<?> type)
```
    Write a type literal for a specified Class. If the class is null, a null value is written. This is used to denote type information directly in the wire format.
    
    Parameters:
    
    type - The Class object for which to write a type literal.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typeLiteral
```
@NotNull
default @NotNull WireOut typeLiteral(@Nullable
                                              @Nullable Type type)
```
    Write a type literal for a specified Type. If the type is null, a null value is written. If the type is an instance of Class, then it delegates to the corresponding method to write a type literal for a class.
    
    Parameters:
    
    type - The Type object for which to write a type literal.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typeLiteral
```
@NotNull
@NotNull WireOut typeLiteral(@Nullable
                                      @Nullable CharSequence type)
```
    Write a type literal value. This is useful for wire formats that require direct type annotations within the serialized data.
    
    Parameters:
    
    type - The type name as a CharSequence.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typeLiteral
```
@NotNull
@NotNull WireOut typeLiteral(@NotNull
                                      @NotNull BiConsumer<Class,net.openhft.chronicle.bytes.Bytes<?>> typeTranslator,
                                      @Nullable
                                      @Nullable Class<?> type)
```
    Writes a type literal using the specified type translator function. This allows custom translations for type literals depending on the implementation.
    
    Parameters:
    
    typeTranslator - A bi-consumer function to transform the Class object into a byte representation.
    
    type - The Class object to be translated.
    
    Returns:
    
    The WireOut instance for chained calls.
  - uuid
```
@NotNull
@NotNull WireOut uuid(UUID uuid)
```
    Writes a universally unique identifier (UUID) to the wire.
    
    Parameters:
    
    uuid - The UUID value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int32forBinding
```
@NotNull
@NotNull WireOut int32forBinding(int value)
```
    Writes a 32-bit integer for binding. The specifics of "for binding" may be implementation dependent.
  - int32forBinding
```
@NotNull
@NotNull WireOut int32forBinding(int value,
                                          @NotNull
                                          @NotNull net.openhft.chronicle.core.values.IntValue intValue)
```
    Writes a 32-bit integer for binding with the given IntValue. This may be used for additional metadata or configuration.
  - int64forBinding
```
@NotNull
@NotNull WireOut int64forBinding(long value)
```
    Writes a 64-bit integer for binding. The specifics of "for binding" may be implementation dependent.
  - int128forBinding
```
@NotNull
default @NotNull WireOut int128forBinding(long value,
                                                   long value2)
```
    Throws an unsupported operation exception by default. May be overridden by specific implementations.
  - int64forBinding
```
@NotNull
@NotNull WireOut int64forBinding(long value,
                                          @NotNull
                                          @NotNull net.openhft.chronicle.core.values.LongValue longValue)
```
    Writes a 64-bit integer for binding with the given LongValue. This may be used for additional metadata or configuration.
  - boolForBinding
```
@NotNull
@NotNull WireOut boolForBinding(boolean value,
                                         @NotNull
                                         @NotNull net.openhft.chronicle.core.values.BooleanValue longValue)
```
    Writes a boolean value for binding with the given BooleanValue. This may be used for additional metadata or configuration.
  - sequence
```
@NotNull
default @NotNull WireOut sequence(WriteValue writer)
```
    Writes a sequence of values to the wire using the provided writer. The default behavior uses the writer's `writeValue` method.
  - sequence
```
@NotNull
default <T> @NotNull WireOut sequence(Iterable<T> t)
```
    Writes a sequence of values from an Iterator. This method handles different types of iterables, applying type prefixes as appropriate for Sets and SortedSets.
    
    Parameters:
    
    t - The Iterable of values to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - sequence
```
@NotNull
<T> @NotNull WireOut sequence(T t,
                                       BiConsumer<T,ValueOut> writer)
```
    Writes a sequence of values using the provided writer.
    
    Parameters:
    
    t - The input to be consumed by the writer.
    
    writer - A bi-consumer that writes values using the given ValueOut instance.
    
    Returns:
    
    The WireOut instance for chained calls.
  - sequence
```
@NotNull
<T,K> @NotNull WireOut sequence(T t,
                                         K param,
                                         TriConsumer<T,K,ValueOut> writer)
                                  throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a sequence of values using the provided parametrized writer.
    
    Parameters:
    
    t - The primary input to be consumed by the writer.
    
    param - A secondary input parameter for the writer.
    
    writer - A tri-consumer that writes values using the given ValueOut instance and additional parameter.
    
    Returns:
    
    The WireOut instance for chained calls.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - When there's an issue marshalling the data.
  - sequenceWithLength
```
default <T> WireOut sequenceWithLength(T t,
                                       int length,
                                       ObjectIntObjectConsumer<T,ValueOut> writer)
```
    Writes a sequence of values of a specified length.
    
    Parameters:
    
    t - The input to be consumed by the writer.
    
    length - The length of the sequence.
    
    writer - An object-int-object consumer that writes values using the given ValueOut instance.
    
    Returns:
    
    The WireOut instance for chained calls.
  - array
```
default WireOut array(net.openhft.chronicle.bytes.Bytes[] array,
                      int length)
```
    Writes an array of byte sequences of a specified length.
    
    Parameters:
    
    array - The array of byte sequences.
    
    length - The length of the sequence.
    
    Returns:
    
    The WireOut instance for chained calls.
  - array
```
default WireOut array(double[] array,
                      int length)
```
    Writes an array of doubles of a specified length.
    
    Parameters:
    
    array - The array of doubles.
    
    length - The length of the sequence.
    
    Returns:
    
    The WireOut instance for chained calls.
  - arrayDelta
```
default WireOut arrayDelta(double[] array,
                           int length)
```
    This write value's relative to the first one using 6 digit precision
    
    Parameters:
    
    array - to write
    
    length - to write
    
    Returns:
    
    this
  - array
```
default WireOut array(boolean[] array,
                      int length)
```
    Writes an array of boolean values to the wire output.
    
    Parameters:
    
    array - The array of booleans to be written.
    
    length - The number of elements from the array to write.
    
    Returns:
    
    The current instance of the WireOut.
  - array
```
default WireOut array(long[] array,
                      int length)
```
    Writes an array of long values to the wire output.
    
    Parameters:
    
    array - The array of longs to be written.
    
    length - The number of elements from the array to write.
    
    Returns:
    
    The current instance of the WireOut.
  - arrayDelta
```
default WireOut arrayDelta(long[] array,
                           int length)
```
    Writes the delta of long values in an array to the wire output. The first value is written as is, and the subsequent values are written as differences from the first value.
    
    Parameters:
    
    array - The array of longs whose deltas are to be written.
    
    length - The number of elements from the array to write.
    
    Returns:
    
    The current instance of the WireOut.
  - array
```
default WireOut array(int[] array,
                      int length)
```
    Writes an array of int values to the wire output.
    
    Parameters:
    
    array - The array of ints to be written.
    
    length - The number of elements from the array to write.
    
    Returns:
    
    The current instance of the WireOut.
  - array
```
default WireOut array(byte[] array,
                      int length)
```
    Writes an array of byte values to the wire output.
    
    Parameters:
    
    array - The array of bytes to be written.
    
    length - The number of elements from the array to write.
    
    Returns:
    
    The current instance of the WireOut.
  - array
```
@NotNull
default @NotNull WireOut array(@NotNull
                                        @NotNull WriteValue writer,
                                        @NotNull
                                        @NotNull Class<?> arrayType)
```
    Writes an array of specified type objects to the wire output, using the provided writer. Recognizes arrays of type String[] and other object arrays, appending appropriate type prefixes.
    
    Parameters:
    
    writer - The writer to use for writing the array.
    
    arrayType - The type of the array to be written.
    
    Returns:
    
    The current instance of the WireOut.
  - marshallable
```
@NotNull
@NotNull WireOut marshallable(WriteMarshallable object)
                                throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a value that implements the WriteMarshallable interface to the wire output.
    
    Parameters:
    
    object - The WriteMarshallable object to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - marshallable
```
@NotNull
@NotNull WireOut marshallable(Serializable object)
                                throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a value that implements the Serializable interface to the wire output.
    
    Parameters:
    
    object - The Serializable object to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - map
```
@NotNull
@NotNull WireOut map(Map map)
                       throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes the contents of a specified map to the wire output. The key and value type of the map must be either Marshallable, String, or Autoboxed primitives.
    
    Parameters:
    
    map - The map whose contents are to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the map cannot be marshalled.
    
    IllegalArgumentException - If the type of the map is not one of those listed above.
  - swapLeaf
```
default boolean swapLeaf(boolean isLeaf)
```
    Determines if the current WireOut is in a leaf node state. This method is intended for internal use. The default behavior is to always return false.
    
    Parameters:
    
    isLeaf - Flag indicating whether the current node is a leaf.
    
    Returns:
    
    A boolean indicating the previous state (always false in the default implementation).
  - typedMarshallable
```
@NotNull
default @NotNull WireOut typedMarshallable(@Nullable
                                                    @Nullable WriteMarshallable marshallable)
                                             throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    To be used when you know it is a typed marshallable object. e.g. an Enum is not, it's a scalar. If you are not sure, use the object(Object) method.
    
    Parameters:
    
    marshallable - to write
    
    Returns:
    
    the original wire
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException
  - endTypePrefix
```
default void endTypePrefix()
```
    Ends the type prefix scope for the written data. In the default implementation, this method does nothing. Override it in subclasses if specific end logic is required.
  - typedMarshallable
```
@NotNull
default @NotNull WireOut typedMarshallable(@Nullable
                                                    @Nullable Serializable object)
                                             throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a value that implements the Serializable interface to the wire output. Specifically used when the object is known to be a typed serializable. If uncertain about the object's type, it's recommended to use the object(Object) method instead.
    
    Parameters:
    
    object - The Serializable object to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - typedMarshallable
```
@NotNull
default @NotNull WireOut typedMarshallable(CharSequence typeName,
                                                    WriteMarshallable object)
                                             throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a value that implements the WriteMarshallable interface to the wire output, while prepending it with a specified type prefix.
    
    Parameters:
    
    typeName - The type prefix to be written before the object.
    
    object - The WriteMarshallable object to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - asEnum
```
@NotNull
default <E extends Enum<E>> @NotNull WireOut asEnum(@Nullable
                                                             E e)
```
    Writes an enum value to the wire output. The enum's name is used as its string representation.
    
    Type Parameters:
    
    E - Type parameter indicating that the provided object is of an Enum type.
    
    Parameters:
    
    e - The enum value to be written.
    
    Returns:
    
    The current instance of the WireOut.
  - set
```
@NotNull
default <V> @NotNull WireOut set(Set<V> coll)
                                   throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a set value to the wire output. The specific type of entries is not specified.
    
    Type Parameters:
    
    V - The type of elements in the set.
    
    Parameters:
    
    coll - The set to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the set cannot be marshalled.
  - set
```
@NotNull
default <V> @NotNull WireOut set(Set<V> coll,
                                          Class<V> assumedClass)
                                   throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a set to the wire output, while specifying the type of its entries.
    
    Type Parameters:
    
    V - The type of elements in the set.
    
    Parameters:
    
    coll - The set to be written.
    
    assumedClass - The expected class type of the set entries.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the set cannot be marshalled.
  - list
```
@NotNull
default <V> @NotNull WireOut list(List<V> coll)
                                    throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a list to the wire output. The specific type of list entries is not specified.
    
    Type Parameters:
    
    V - The type of elements in the list.
    
    Parameters:
    
    coll - The list to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the list cannot be marshalled.
  - list
```
@NotNull
default <V> @NotNull WireOut list(List<V> coll,
                                           Class<V> assumedClass)
                                    throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a list to the wire output, while specifying the type of its entries.
    
    Type Parameters:
    
    V - The type of elements in the list.
    
    Parameters:
    
    coll - The list to be written.
    
    assumedClass - The expected class type of the list entries.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the list cannot be marshalled.
  - collection
```
@NotNull
default <V> @NotNull WireOut collection(Collection<V> coll,
                                                 Class<V> assumedClass)
                                          throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a collection to the wire output, specifying the type of its entries.
    
    Type Parameters:
    
    V - The type of elements in the collection.
    
    Parameters:
    
    coll - The collection to be written.
    
    assumedClass - The expected class type of the collection entries.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the collection cannot be marshalled.
  - object
```
@NotNull
default <V> @NotNull WireOut object(@NotNull
                                             @NotNull Class<? extends V> expectedType,
                                             V v)
                                      throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes an object to the wire output, specifying its expected type.
    
    Type Parameters:
    
    V - Type of the object to be written.
    
    Parameters:
    
    expectedType - The expected class type of the object.
    
    v - The object to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - marshallable
```
@NotNull
default <K,V> @NotNull WireOut marshallable(Map<K,V> map)
                                              throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a map to the wire output. Uses default object classes for keys and values.
    
    Type Parameters:
    
    K - Type of the map key.
    
    V - Type of the map value.
    
    Parameters:
    
    map - The map to be written.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the map cannot be marshalled.
  - marshallable
```
@NotNull
default <K,V> @NotNull WireOut marshallable(@Nullable
                                                     @Nullable Map<K,V> map,
                                                     @NotNull
                                                     @NotNull Class<K> kClass,
                                                     @NotNull
                                                     @NotNull Class<V> vClass,
                                                     boolean leaf)
                                              throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes a map to the wire output, specifying classes for keys and values.
    
    Type Parameters:
    
    K - Type of the map key.
    
    V - Type of the map value.
    
    Parameters:
    
    map - The map to be written. Can be null.
    
    kClass - Class type of the map key.
    
    vClass - Class type of the map value.
    
    leaf - Indicates if the map is a leaf node.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the map cannot be marshalled.
  - object
```
@NotNull
default @NotNull WireOut object(@Nullable
                                         @Nullable Object value)
                                  throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Writes an object to the wire output. This method is optimized to handle various known types and provides custom serialization for each.
    
    Parameters:
    
    value - The object to be written. Can be null.
    
    Returns:
    
    The current instance of the WireOut.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be marshalled.
  - bytesMarshallable
```
default WireOut bytesMarshallable(net.openhft.chronicle.bytes.WriteBytesMarshallable value)
                           throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Serialize an object implementing the WriteBytesMarshallable interface. However, this is unsupported in the default implementation and will throw an exception.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException
  - optionalTyped
```
@NotNull
default @NotNull ValueOut optionalTyped(Class<?> aClass)
```
    Add an optional type i.e. if TEXT is used. In the default implementation, this method doesn't make any changes and returns 'this'.
    
    Parameters:
    
    aClass - to write
    
    Returns:
    
    this
  - fixedFloat32
```
@NotNull
default @NotNull WireOut fixedFloat32(float value)
```
    Serialize a float value prefixed with its type.
  - fixedInt8
```
@NotNull
default @NotNull WireOut fixedInt8(byte value)
```
    Serialize a byte (signed 8-bit) value prefixed with its type.
  - fixedInt16
```
@NotNull
default @NotNull WireOut fixedInt16(short value)
```
    Serialize a short (signed 16-bit) value prefixed with its type.
  - fixedInt32
```
@NotNull
default @NotNull WireOut fixedInt32(int value)
```
    Serialize an int (signed 32-bit) value prefixed with its type.
  - fixedFloat64
```
@NotNull
default @NotNull WireOut fixedFloat64(double value)
```
    Serialize a double value. Notice that there's no type prefixing in this default implementation.
  - fixedInt64
```
@NotNull
default @NotNull WireOut fixedInt64(long value)
```
    Serialize a long (signed 64-bit) value. Again, there's no type prefixing in this default implementation.
  - untypedObject
```
@NotNull
default @NotNull WireOut untypedObject(@Nullable
                                                @Nullable Object value)
                                         throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Write an untyped object value. This method attempts to serialize an object without the caller explicitly specifying the object type. This is done by checking the object's class name against a list of known class names and using appropriate serialization methods.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException
  - typedScalar
```
@NotNull
default @NotNull WireOut typedScalar(@NotNull
                                              @NotNull Object value)
```
    Write a typed scalar value as type prefixed text. This method ensures the serialized value is prefixed with its type to aid deserialization.
  - throwable
```
@NotNull
default @NotNull WireOut throwable(@NotNull
                                            @NotNull Throwable t)
                                     throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Write a throwable value. This method serializes a Throwable object into the wire format. It captures the message, stack trace, and any nested cause of the Throwable.
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException
  - wireOut
```
@NotNull
@NotNull WireOut wireOut()
```
  - compress
```
@NotNull
default @NotNull WireOut compress(@NotNull
                                           @NotNull String compression,
                                           @Nullable
                                           @Nullable net.openhft.chronicle.bytes.Bytes<?> uncompressedBytes)
```
    Compresses the given bytes using the specified compression technique. If the byte size is below a certain threshold (SMALL_MESSAGE), the bytes are written uncompressed.
  - compressedSize
```
default int compressedSize()
```
  - resetBetweenDocuments
```
default void resetBetweenDocuments()
```
  - resetState
```
void resetState()
```
  - isBinary
```
default boolean isBinary()
```
    Indicates if the current wire type is a binary wire. This could be useful for differentiating between textual or binary wire formats.
    
    Returns:
    
    true if this wire type is binary wire, false otherwise.
  - writeBoolean
```
default WireOut writeBoolean(boolean x)
```
    Writes a boolean value to the wire. Internally, this method leverages the bool method to perform the actual writing.
    
    Parameters:
    
    x - The boolean value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeByte
```
default WireOut writeByte(byte x)
```
    Writes a byte value to the wire. Utilizes the int8 method to write the byte.
    
    Parameters:
    
    x - The byte value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeChar
```
default WireOut writeChar(char x)
```
    Writes a char value to the wire. Leverages the uint16 method, characters are stored as unsigned 16-bit integers.
    
    Parameters:
    
    x - The char value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeShort
```
default WireOut writeShort(short x)
```
    Writes a short value to the wire. Uses the int16 method for the writing operation.
    
    Parameters:
    
    x - The short value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeInt
```
default WireOut writeInt(int x)
```
    Writes an int value to the wire. Relies on the int32 method to carry out the write.
    
    Parameters:
    
    x - The integer value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeLong
```
default WireOut writeLong(long x)
```
    Writes a long value to the wire. Uses the int64 method for the operation.
    
    Parameters:
    
    x - The long value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeFloat
```
default WireOut writeFloat(float x)
```
    Writes a float value to the wire. Executes the write using the float32 method.
    
    Parameters:
    
    x - The float value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeDouble
```
default WireOut writeDouble(double x)
```
    Writes a double value to the wire. Uses the float64 method to carry out the writing operation.
    
    Parameters:
    
    x - The double value to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeString
```
default WireOut writeString(CharSequence x)
```
    Writes a string or a sequence of characters to the wire. Uses the text method for the writing process.
    
    Parameters:
    
    x - The sequence of characters to be written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeInt
```
default WireOut writeInt(LongConverter converter,
                         int i)
```
    Writes an int value to the wire using a specified converter. The converter helps in changing the format or representation of the integer.
    
    Parameters:
    
    converter - Converter to use.
    
    i - The integer to be converted and written.
    
    Returns:
    
    The WireOut instance after the operation.
  - writeLong
```
default WireOut writeLong(LongConverter longConverter,
                          long l)
```
    Writes a long value to the wire using a specified converter. The converter helps in changing the format or representation of the long value.
    
    Parameters:
    
    longConverter - Converter to use.
    
    l - The long value to be converted and written.
    
    Returns:
    
    The WireOut instance after the operation.
  - elementSeparator
```
default void elementSeparator()
```
    Signifies the end of an element that has been added direcftly to the wire.

Interface ValueOut

Nested Class Summary

Field Summary

Method Summary

Field Detail

MM_TL

SMALL_MESSAGE

ZEROS_64

Method Detail

isAnEnum

bool

text

text

nu11

text

character

text

int8

int8

bytes

bytesLiteral

bytes

rawBytes

rawText

writeLength

bytes

bytes

uint8

uint8checked

int16

int16

uint16

uint16checked

utf8

int32

int32

int32

uint32

uint32checked

int64

int64

int128forBinding

int64_0x

int64array

int64array

float32

float64

float32

float64

time

zonedDateTime

date

dateTime

typePrefix

typePrefix

classLookup

typeLiteral

typeLiteral

typeLiteral

typeLiteral

uuid

int32forBinding

int32forBinding

int64forBinding

int128forBinding

int64forBinding

boolForBinding

sequence

sequence

sequence

sequence

sequenceWithLength

array

array

arrayDelta

array

array

arrayDelta

array

array