BinaryWire.FixedBinaryValueOut (OpenHFT/Chronicle-Wire 2.26ea3 API)

java.lang.Object
- net.openhft.chronicle.wire.BinaryWire.FixedBinaryValueOut

All Implemented Interfaces:

ValueOut

Direct Known Subclasses:

BinaryWire.BinaryValueOut

Enclosing class:

BinaryWire
```
protected class BinaryWire.FixedBinaryValueOut
extends Object
implements ValueOut
```
Implementation of the ValueOut interface, providing methods to write values in a fixed binary format. This inner class offers various methods to output values in a binary format that retains its order.

Nested Class Summary
- Nested classes/interfaces inherited from interface net.openhft.chronicle.wire.ValueOut
  ValueOut.MapMarshaller<K,V>

Field Summary
- Fields inherited from interface net.openhft.chronicle.wire.ValueOut
  MM_TL, SMALL_MESSAGE, ZEROS_64

Constructor Summary

Constructors
Modifier Constructor and Description

protected FixedBinaryValueOut()

Constructors
Modifier	Constructor and Description
`protected`	`FixedBinaryValueOut()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`@NotNull WireOut`	`bool(@Nullable Boolean flag)` Write a boolean value.
`@NotNull WireOut`	`boolForBinding(boolean value, @NotNull net.openhft.chronicle.core.values.BooleanValue booleanValue)` Writes a boolean value for binding with the given BooleanValue.
`@NotNull WireOut`	`bytes(@NotNull 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, @NotNull 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.
`void`	`bytes0(@NotNull net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes, long remaining)` Writes bytes from the given BytesStore to the byte storage.
`@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.
`WireOut`	`bytesMarshallable(net.openhft.chronicle.bytes.WriteBytesMarshallable object)` Serialize an object implementing the WriteBytesMarshallable interface.
`net.openhft.chronicle.core.pool.ClassLookup`	`classLookup()` Provides a lookup mechanism to resolve class names.
`int`	`compressedSize()`
`@NotNull WireOut`	`date(@NotNull LocalDate localDate)` Write a date value.
`@NotNull WireOut`	`dateTime(@NotNull LocalDateTime localDateTime)` Write a local date-time value, which represents both date and time without a time zone.
`void`	`elementSeparator()` Signifies the end of an element that has been added direcftly to the wire.
`@NotNull WireOut`	`fixedFloat32(float f)` Serialize a float value prefixed with its type.
`@NotNull WireOut`	`fixedFloat64(double d)` Serialize a double value.
`@NotNull WireOut`	`fixedInt16(short i16)` Serialize a short (signed 16-bit) value prefixed with its type.
`@NotNull WireOut`	`fixedInt32(int i32)` Serialize an int (signed 32-bit) value prefixed with its type.
`@NotNull WireOut`	`fixedInt64(long i64)` Serialize a long (signed 64-bit) value.
`@NotNull WireOut`	`fixedInt8(byte i8)` Serialize a byte (signed 8-bit) value prefixed with its type.
`@NotNull WireOut`	`fixedOrderedInt32(int i32)` Writes a 32-bit integer value to the byte storage in an order-preserving binary format.
`@NotNull WireOut`	`float32(float f)` Write a 32-bit floating-point value.
`@NotNull WireOut`	`float64(double d)` Write a 64-bit floating-point value, also known as a double.
`@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 longValue)` Write two signed 64-bit integer values bound to a TwoLongValue object.
`@NotNull WireOut`	`int16(short i16)` Write a signed 16-bit integer value.
`@NotNull WireOut`	`int32(int i32)` 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.
`@NotNull WireOut`	`int64array(long capacity)` Allocate space for writing an array of 64-bit integers.
`@NotNull WireOut`	`int64array(long capacity, @NotNull 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.
`@NotNull WireOut`	`map(Map map)` Writes the contents of a specified map to the wire output.
`@NotNull WireOut`	`marshallable(@NotNull Serializable object)` Writes a value that implements the `Serializable` interface to the wire output.
`@NotNull WireOut`	`marshallable(@NotNull WriteMarshallable object)` Writes a value that implements the `WriteMarshallable` interface to the wire output.
`@NotNull WireOut`	`nu11()` Write a null value.
`@NotNull WireOut`	`rawBytes(@NotNull byte[] value)` Write a raw sequence of bytes.
`void`	`resetState()`
`<T> @NotNull WireOut`	`sequence(T t, @NotNull BiConsumer<T,ValueOut> writer)` Writes a sequence of values using the provided writer.
`<T,K> @NotNull WireOut`	`sequence(T t, K kls, @NotNull TriConsumer<T,K,ValueOut> writer)` Writes a sequence of values using the provided parametrized writer.
`@NotNull WireOut`	`text(@Nullable net.openhft.chronicle.bytes.BytesStore<?,?> s)` Write a text value based on the contents of a `BytesStore` object.
`@NotNull WireOut`	`text(@Nullable CharSequence s)` Write a text value.
`@NotNull WireOut`	`text(@Nullable String s)` Write a text value.
`@NotNull WireOut`	`time(@NotNull LocalTime localTime)` Write a local time value.
`@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(CharSequence typeName)` Write a type literal value.
`@NotNull WireOut`	`typeLiteral(@Nullable Class<?> type)` Write a type literal for a specified `Class`.
`@NotNull ValueOut`	`typePrefix(CharSequence typeName)` Write a prefix that denotes a type for the upcoming value.
`@NotNull WireOut`	`uint16checked(int u16)` Write an unsigned 16-bit integer value.
`@NotNull WireOut`	`uint32checked(long u32)` Write an unsigned 32-bit integer value.
`@NotNull WireOut`	`uint8checked(int u8)` Write an unsigned 8-bit integer value.
`@NotNull WireOut`	`utf8(int codepoint)` Write a single 16-bit Unicode codepoint as UTF-8.
`@NotNull WireOut`	`uuid(@NotNull UUID uuid)` Writes a universally unique identifier (UUID) to the wire.
`@NotNull WireOut`	`wireOut()`
`@NotNull ValueOut`	`writeLength(long length)` Write the length of a value if supported by the implementing class.
`@NotNull WireOut`	`zonedDateTime(@NotNull ZonedDateTime zonedDateTime)` Write a zoned date-time value, which includes information about date, time, and the associated time zone.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.wire.ValueOut
array, array, array, array, array, array, array, arrayDelta, arrayDelta, asEnum, character, collection, compress, endTypePrefix, float32, float64, int16, int32, int32, int64, int8, isAnEnum, isBinary, list, list, marshallable, marshallable, object, object, optionalTyped, rawText, resetBetweenDocuments, sequence, sequence, sequenceWithLength, set, set, swapLeaf, text, throwable, typedMarshallable, typedMarshallable, typedMarshallable, typedScalar, typeLiteral, typePrefix, uint16, uint32, uint8, untypedObject, writeBoolean, writeByte, writeChar, writeDouble, writeFloat, writeInt, writeInt, writeLong, writeLong, writeShort, writeString

- Constructor Detail
  - FixedBinaryValueOut
```
protected FixedBinaryValueOut()
```
- Method Detail
  - bool
```
@NotNull
public @NotNull WireOut bool(@Nullable
                                      @Nullable Boolean flag)
```
    Description copied from interface: ValueOut
    
    Write a boolean value.
    
    Specified by:
    
    bool in interface ValueOut
    
    Parameters:
    
    flag - The boolean value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - nu11
```
@NotNull
public @NotNull WireOut nu11()
```
    Description copied from interface: ValueOut
    
    Write a null value.
    
    Specified by:
    
    nu11 in interface ValueOut
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
public @NotNull WireOut text(@Nullable
                                      @Nullable CharSequence s)
```
    Description copied from interface: ValueOut
    
    Write a text value.
    
    Specified by:
    
    text in interface ValueOut
    
    Parameters:
    
    s - The CharSequence containing the text to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
public @NotNull WireOut text(@Nullable
                                      @Nullable String s)
```
    Description copied from interface: ValueOut
    
    Write a text value. This method delegates the writing to ValueOut.text(CharSequence).
    
    Specified by:
    
    text in interface ValueOut
    
    Parameters:
    
    s - The String containing the text to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - text
```
@NotNull
public @NotNull WireOut text(@Nullable
                                      @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> s)
```
    Description copied from interface: ValueOut
    
    Write a text value based on the contents of a BytesStore object. The method casts the BytesStore to a CharSequence for processing.
    
    Specified by:
    
    text in interface ValueOut
    
    Parameters:
    
    s - The BytesStore whose contents are to be written as text.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytes
```
@NotNull
public @NotNull WireOut bytes(@Nullable
                                       @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Description copied from interface: ValueOut
    
    Write a sequence of bytes based on the content of a BytesStore object.
    
    Specified by:
    
    bytes in interface ValueOut
    
    Parameters:
    
    fromBytes - The BytesStore containing the byte sequence to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytesLiteral
```
@NotNull
public @NotNull WireOut bytesLiteral(@Nullable
                                              @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Description copied from interface: ValueOut
    
    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 ValueOut.bytes(BytesStore).
    
    Specified by:
    
    bytesLiteral in interface ValueOut
    
    Parameters:
    
    fromBytes - The BytesStore containing the byte sequence to be written as a literal.
    
    Returns:
    
    The WireOut instance for chained calls.
  - compressedSize
```
public int compressedSize()
```
    Specified by:
    
    compressedSize in interface ValueOut
  - bytes0
```
public void bytes0(@NotNull
                   @NotNull net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes,
                   long remaining)
```
    Writes bytes from the given BytesStore to the byte storage.
    It first writes the length of the bytes and then the bytes themselves. This method ensures the U8_ARRAY code is prefixed before the actual byte data.
    
    Parameters:
    
    fromBytes - The source of the bytes to be written.
    
    remaining - The number of bytes to be written.
  - rawBytes
```
@NotNull
public @NotNull WireOut rawBytes(@NotNull
                                          @NotNull byte[] value)
```
    Description copied from interface: ValueOut
    
    Write a raw sequence of bytes. The exact behavior of this method depends on the implementation.
    
    Specified by:
    
    rawBytes in interface ValueOut
    
    Parameters:
    
    value - The array of bytes to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - writeLength
```
@NotNull
public @NotNull ValueOut writeLength(long length)
```
    Description copied from interface: ValueOut
    
    Write the length of a value if supported by the implementing class.
    
    Specified by:
    
    writeLength in interface ValueOut
    
    Parameters:
    
    length - The length of the value to be written.
    
    Returns:
    
    A ValueOut instance for chained calls.
  - bytes
```
@NotNull
public @NotNull WireOut bytes(@NotNull
                                       @NotNull byte[] fromBytes)
```
    Description copied from interface: ValueOut
    
    Write a sequence of bytes.
    
    Specified by:
    
    bytes in interface ValueOut
    
    Parameters:
    
    fromBytes - The array of bytes to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - bytes
```
@NotNull
public @NotNull WireOut bytes(String type,
                                       @Nullable
                                       @Nullable net.openhft.chronicle.bytes.BytesStore<?,?> fromBytes)
```
    Description copied from interface: ValueOut
    
    Write a typed sequence of bytes based on the content of a BytesStore object.
    
    Specified by:
    
    bytes in interface ValueOut
    
    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.
  - bytes
```
@NotNull
public @NotNull WireOut bytes(String type,
                                       @NotNull
                                       @NotNull byte[] fromBytes)
```
    Description copied from interface: ValueOut
    
    Write a typed sequence of bytes.
    
    Specified by:
    
    bytes in interface ValueOut
    
    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.
  - int8
```
@NotNull
public @NotNull WireOut int8(byte i8)
```
    Description copied from interface: ValueOut
    
    Write a signed 8-bit integer value.
    
    Specified by:
    
    int8 in interface ValueOut
    
    Parameters:
    
    i8 - The byte value representing the 8-bit integer to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedInt8
```
@NotNull
public @NotNull WireOut fixedInt8(byte i8)
```
    Description copied from interface: ValueOut
    
    Serialize a byte (signed 8-bit) value prefixed with its type.
    
    Specified by:
    
    fixedInt8 in interface ValueOut
  - uint8checked
```
@NotNull
public @NotNull WireOut uint8checked(int u8)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    uint8checked in interface ValueOut
    
    Parameters:
    
    u8 - The unsigned 8-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int16
```
@NotNull
public @NotNull WireOut int16(short i16)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    int16 in interface ValueOut
    
    Parameters:
    
    i16 - The signed 16-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedInt16
```
@NotNull
public @NotNull WireOut fixedInt16(short i16)
```
    Description copied from interface: ValueOut
    
    Serialize a short (signed 16-bit) value prefixed with its type.
    
    Specified by:
    
    fixedInt16 in interface ValueOut
  - uint16checked
```
@NotNull
public @NotNull WireOut uint16checked(int u16)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    uint16checked in interface ValueOut
    
    Parameters:
    
    u16 - The unsigned 16-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - utf8
```
@NotNull
public @NotNull WireOut utf8(int codepoint)
```
    Description copied from interface: ValueOut
    
    Write a single 16-bit Unicode codepoint as UTF-8. The exact behavior of this method depends on the implementation.
    
    Specified by:
    
    utf8 in interface ValueOut
    
    Parameters:
    
    codepoint - The 16-bit Unicode codepoint to be written as UTF-8.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int32
```
@NotNull
public @NotNull WireOut int32(int i32)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    int32 in interface ValueOut
    
    Parameters:
    
    i32 - The signed 32-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedInt32
```
@NotNull
public @NotNull WireOut fixedInt32(int i32)
```
    Description copied from interface: ValueOut
    
    Serialize an int (signed 32-bit) value prefixed with its type.
    
    Specified by:
    
    fixedInt32 in interface ValueOut
  - fixedOrderedInt32
```
@NotNull
public @NotNull WireOut fixedOrderedInt32(int i32)
```
    Writes a 32-bit integer value to the byte storage in an order-preserving binary format.
    Additionally, if hex dump description is retained, it writes a hex dump description.
    
    Parameters:
    
    i32 - The 32-bit integer value to be written.
    
    Returns:
    
    The current WireOut instance.
  - uint32checked
```
@NotNull
public @NotNull WireOut uint32checked(long u32)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    uint32checked in interface ValueOut
    
    Parameters:
    
    u32 - The unsigned 32-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64
```
@NotNull
public @NotNull WireOut int64(long i64)
```
    Description copied from interface: ValueOut
    
    Write a signed 64-bit integer value.
    
    Specified by:
    
    int64 in interface ValueOut
    
    Parameters:
    
    i64 - The signed 64-bit integer value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedInt64
```
@NotNull
public @NotNull WireOut fixedInt64(long i64)
```
    Description copied from interface: ValueOut
    
    Serialize a long (signed 64-bit) value. Again, there's no type prefixing in this default implementation.
    
    Specified by:
    
    fixedInt64 in interface ValueOut
  - int64_0x
```
@NotNull
public @NotNull WireOut int64_0x(long i64)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    int64_0x in interface ValueOut
    
    Parameters:
    
    i64 - The 64-bit integer value to be written in hexadecimal format.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int64array
```
@NotNull
public @NotNull WireOut int64array(long capacity)
```
    Description copied from interface: ValueOut
    
    Allocate space for writing an array of 64-bit integers. The exact behavior might vary depending on the wire type or the underlying implementation.
    
    Specified by:
    
    int64array in interface ValueOut
    
    Parameters:
    
    capacity - The desired capacity of the 64-bit integer array.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int128forBinding
```
@NotNull
public @NotNull WireOut int128forBinding(long value,
                                                  long value2)
```
    Description copied from interface: ValueOut
    
    Throws an unsupported operation exception by default. May be overridden by specific implementations.
    
    Specified by:
    
    int128forBinding in interface ValueOut
  - int64array
```
@NotNull
public @NotNull WireOut int64array(long capacity,
                                            @NotNull
                                            @NotNull net.openhft.chronicle.core.values.LongArrayValues values)
```
    Description copied from interface: ValueOut
    
    Write a sequence of 64-bit integers into an array, using the provided LongArrayValues object as the source of the values.
    
    Specified by:
    
    int64array in interface ValueOut
    
    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
public @NotNull WireOut float32(float f)
```
    Description copied from interface: ValueOut
    
    Write a 32-bit floating-point value.
    
    Specified by:
    
    float32 in interface ValueOut
    
    Parameters:
    
    f - The 32-bit float value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedFloat32
```
@NotNull
public @NotNull WireOut fixedFloat32(float f)
```
    Description copied from interface: ValueOut
    
    Serialize a float value prefixed with its type.
    
    Specified by:
    
    fixedFloat32 in interface ValueOut
  - float64
```
@NotNull
public @NotNull WireOut float64(double d)
```
    Description copied from interface: ValueOut
    
    Write a 64-bit floating-point value, also known as a double.
    
    Specified by:
    
    float64 in interface ValueOut
    
    Parameters:
    
    d - The 64-bit double value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - fixedFloat64
```
@NotNull
public @NotNull WireOut fixedFloat64(double d)
```
    Description copied from interface: ValueOut
    
    Serialize a double value. Notice that there's no type prefixing in this default implementation.
    
    Specified by:
    
    fixedFloat64 in interface ValueOut
  - time
```
@NotNull
public @NotNull WireOut time(@NotNull
                                      @NotNull LocalTime localTime)
```
    Description copied from interface: ValueOut
    
    Write a local time value. The exact format and representation might vary depending on the wire type or the underlying implementation.
    
    Specified by:
    
    time in interface ValueOut
    
    Parameters:
    
    localTime - The LocalTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - zonedDateTime
```
@NotNull
public @NotNull WireOut zonedDateTime(@NotNull
                                               @NotNull ZonedDateTime zonedDateTime)
```
    Description copied from interface: ValueOut
    
    Write a zoned date-time value, which includes information about date, time, and the associated time zone.
    
    Specified by:
    
    zonedDateTime in interface ValueOut
    
    Parameters:
    
    zonedDateTime - The ZonedDateTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - date
```
@NotNull
public @NotNull WireOut date(@NotNull
                                      @NotNull LocalDate localDate)
```
    Description copied from interface: ValueOut
    
    Write a date value. The exact format and representation might vary depending on the wire type or the underlying implementation.
    
    Specified by:
    
    date in interface ValueOut
    
    Parameters:
    
    localDate - The LocalDate instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - dateTime
```
@NotNull
public @NotNull WireOut dateTime(@NotNull
                                          @NotNull LocalDateTime localDateTime)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    dateTime in interface ValueOut
    
    Parameters:
    
    localDateTime - The LocalDateTime instance to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typePrefix
```
@NotNull
public @NotNull ValueOut typePrefix(CharSequence typeName)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    typePrefix in interface ValueOut
    
    Parameters:
    
    typeName - The name of the type as a CharSequence.
    
    Returns:
    
    The ValueOut instance for chained calls.
  - classLookup
```
public net.openhft.chronicle.core.pool.ClassLookup classLookup()
```
    Description copied from interface: ValueOut
    
    Provides a lookup mechanism to resolve class names. The exact mechanism and source of class name data is determined by the implementation.
    
    Specified by:
    
    classLookup in interface ValueOut
    
    Returns:
    
    A ClassLookup instance used for resolving class names.
  - typeLiteral
```
@NotNull
public @NotNull WireOut typeLiteral(CharSequence typeName)
```
    Description copied from interface: ValueOut
    
    Write a type literal value. This is useful for wire formats that require direct type annotations within the serialized data.
    
    Specified by:
    
    typeLiteral in interface ValueOut
    
    Parameters:
    
    typeName - The type name as a CharSequence.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typeLiteral
```
@NotNull
public @NotNull WireOut typeLiteral(@Nullable
                                             @Nullable Class<?> type)
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    typeLiteral in interface ValueOut
    
    Parameters:
    
    type - The Class object for which to write a type literal.
    
    Returns:
    
    The WireOut instance for chained calls.
  - typeLiteral
```
@NotNull
public @NotNull WireOut typeLiteral(@NotNull
                                             @NotNull BiConsumer<Class,net.openhft.chronicle.bytes.Bytes<?>> typeTranslator,
                                             @Nullable
                                             @Nullable Class<?> type)
```
    Description copied from interface: ValueOut
    
    Writes a type literal using the specified type translator function. This allows custom translations for type literals depending on the implementation.
    
    Specified by:
    
    typeLiteral in interface ValueOut
    
    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
public @NotNull WireOut uuid(@NotNull
                                      @NotNull UUID uuid)
```
    Description copied from interface: ValueOut
    
    Writes a universally unique identifier (UUID) to the wire.
    
    Specified by:
    
    uuid in interface ValueOut
    
    Parameters:
    
    uuid - The UUID value to be written.
    
    Returns:
    
    The WireOut instance for chained calls.
  - int32forBinding
```
@NotNull
public @NotNull WireOut int32forBinding(int value)
```
    Description copied from interface: ValueOut
    
    Writes a 32-bit integer for binding. The specifics of "for binding" may be implementation dependent.
    
    Specified by:
    
    int32forBinding in interface ValueOut
  - int64forBinding
```
@NotNull
public @NotNull WireOut int64forBinding(long value)
```
    Description copied from interface: ValueOut
    
    Writes a 64-bit integer for binding. The specifics of "for binding" may be implementation dependent.
    
    Specified by:
    
    int64forBinding in interface ValueOut
  - int32forBinding
```
@NotNull
public @NotNull WireOut int32forBinding(int value,
                                                 @NotNull
                                                 @NotNull net.openhft.chronicle.core.values.IntValue intValue)
```
    Description copied from interface: ValueOut
    
    Writes a 32-bit integer for binding with the given IntValue. This may be used for additional metadata or configuration.
    
    Specified by:
    
    int32forBinding in interface ValueOut
  - int64forBinding
```
@NotNull
public @NotNull WireOut int64forBinding(long value,
                                                 @NotNull
                                                 @NotNull net.openhft.chronicle.core.values.LongValue longValue)
```
    Description copied from interface: ValueOut
    
    Writes a 64-bit integer for binding with the given LongValue. This may be used for additional metadata or configuration.
    
    Specified by:
    
    int64forBinding in interface ValueOut
  - boolForBinding
```
@NotNull
public @NotNull WireOut boolForBinding(boolean value,
                                                @NotNull
                                                @NotNull net.openhft.chronicle.core.values.BooleanValue booleanValue)
```
    Description copied from interface: ValueOut
    
    Writes a boolean value for binding with the given BooleanValue. This may be used for additional metadata or configuration.
    
    Specified by:
    
    boolForBinding in interface ValueOut
  - int128forBinding
```
@NotNull
public @NotNull WireOut int128forBinding(long i64x0,
                                                  long i64x1,
                                                  net.openhft.chronicle.core.values.TwoLongValue longValue)
```
    Description copied from interface: ValueOut
    
    Write two signed 64-bit integer values bound to a TwoLongValue object.
    
    Specified by:
    
    int128forBinding in interface ValueOut
    
    Parameters:
    
    i64x0 - The first 64-bit integer value.
    
    i64x1 - The second 64-bit integer value.
    
    longValue - The TwoLongValue object to which the values are bound.
    
    Returns:
    
    The WireOut instance for chained calls.
  - sequence
```
@NotNull
public <T> @NotNull WireOut sequence(T t,
                                              @NotNull
                                              @NotNull BiConsumer<T,ValueOut> writer)
```
    Description copied from interface: ValueOut
    
    Writes a sequence of values using the provided writer.
    
    Specified by:
    
    sequence in interface ValueOut
    
    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
public <T,K> @NotNull WireOut sequence(T t,
                                                K kls,
                                                @NotNull
                                                @NotNull TriConsumer<T,K,ValueOut> writer)
                                         throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: ValueOut
    
    Writes a sequence of values using the provided parametrized writer.
    
    Specified by:
    
    sequence in interface ValueOut
    
    Parameters:
    
    t - The primary input to be consumed by the writer.
    
    kls - 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.
  - marshallable
```
@NotNull
public @NotNull WireOut marshallable(@NotNull
                                              @NotNull WriteMarshallable object)
                                       throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: ValueOut
    
    Writes a value that implements the WriteMarshallable interface to the wire output.
    
    Specified by:
    
    marshallable in interface ValueOut
    
    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.
  - bytesMarshallable
```
public WireOut bytesMarshallable(net.openhft.chronicle.bytes.WriteBytesMarshallable object)
                          throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: ValueOut
    
    Serialize an object implementing the WriteBytesMarshallable interface. However, this is unsupported in the default implementation and will throw an exception.
    
    Specified by:
    
    bytesMarshallable in interface ValueOut
    
    Throws:
    
    net.openhft.chronicle.core.io.InvalidMarshallableException
  - marshallable
```
@NotNull
public @NotNull WireOut marshallable(@NotNull
                                              @NotNull Serializable object)
                                       throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: ValueOut
    
    Writes a value that implements the Serializable interface to the wire output.
    
    Specified by:
    
    marshallable in interface ValueOut
    
    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
public @NotNull WireOut map(Map map)
                              throws net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: ValueOut
    
    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.
    
    Specified by:
    
    map in interface ValueOut
    
    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.
  - wireOut
```
@NotNull
public @NotNull WireOut wireOut()
```
    Specified by:
    
    wireOut in interface ValueOut
  - resetState
```
public void resetState()
```
    Specified by:
    
    resetState in interface ValueOut
  - elementSeparator
```
public void elementSeparator()
```
    Description copied from interface: ValueOut
    
    Signifies the end of an element that has been added direcftly to the wire.
    
    Specified by:
    
    elementSeparator in interface ValueOut

Class BinaryWire.FixedBinaryValueOut

Nested Class Summary

Nested classes/interfaces inherited from interface net.openhft.chronicle.wire.ValueOut

Field Summary

Fields inherited from interface net.openhft.chronicle.wire.ValueOut

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.chronicle.wire.ValueOut

Constructor Detail

FixedBinaryValueOut

Method Detail

bool

nu11

text

text

text

bytes

bytesLiteral

compressedSize

bytes0

rawBytes

writeLength

bytes

bytes

bytes

int8

fixedInt8

uint8checked

int16

fixedInt16

uint16checked

utf8

int32

fixedInt32

fixedOrderedInt32

uint32checked

int64

fixedInt64

int64_0x

int64array

int128forBinding

int64array

float32

fixedFloat32

float64

fixedFloat64

time

zonedDateTime

date

dateTime

typePrefix

classLookup

typeLiteral

typeLiteral

typeLiteral

uuid

int32forBinding

int64forBinding

int32forBinding

int64forBinding

boolForBinding

int128forBinding

sequence

sequence

marshallable

bytesMarshallable

marshallable

map

wireOut

resetState

elementSeparator