Struct Complex 

pub struct Complex<Message> {
    pub data: Bytes,
    pub message: OnceLock<Message>,
}

A lazy-deserialized message.

It holds the raw wire bytes (data) and only parses them into a Message on first access, caching the result in a OnceLock. When written out, BinWrite emits the original raw bytes and never re-serializes.

Why it is fast

• No parse cost unless needed. A message that is only forwarded or logged is never deserialized, so it skips the full decode cost entirely.
• No re-serialize cost. Writing emits the stored raw bytes, avoiding a re-encode of the already-parsed message.
• Cheap clone. Cloning copies only the reference-counted Bytes and resets the cache, so it does not deep-copy the message. super_clone is used when the cached message must also be cloned.

Fields

data: Bytes

The raw wire bytes of the message.

message: OnceLock<Message>

The lazily-parsed message cache.

Implementations

impl<Message> Complex<Message>

pub fn new(data: Bytes) -> Self

Create a Complex from raw wire bytes, without parsing.

pub fn super_clone(&self) -> Self

where Message: Clone,

Clone the Complex, including the cached message if present.

pub fn bytes(&self) -> &Bytes

Get a reference to the raw wire bytes.

impl<Message> Complex<Message>

where Message: BinWrite, for<'a> <Message as BinWrite>::Args<'a>: Default,

pub fn from_message(message: Message) -> Self

Create a Complex from a parsed message, serializing it to raw bytes.

impl<Message: BinRead> Complex<Message>

where for<'a> <Message as BinRead>::Args<'a>: Default,

pub fn try_get(&self) -> Result<&Message, Error>

Parse the message from the raw bytes on first access, caching it.

pub fn into_inner(self) -> Option<Message>

Consume the Complex, returning the cached message if it was parsed.

Trait Implementations

impl<Message: BinWrite> BinWrite for Complex<Message>

type Args<'a> = <Message as BinWrite>::Args<'a>

The type used for the args parameter of write_args() and write_options().

fn write_options<W: Write>( &self, writer: &mut W, _endian: Endian, _args: Self::Args<'_>, ) -> BinResult<()>

Write Self to the writer using the given Endian and arguments.

fn write_be<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming big-endian byte order.

fn write_le<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write + Seek, Self::Args<'a>: for<'a> Required,

Write Self to the writer assuming little-endian byte order.

fn write_be_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming big-endian byte order, using the given arguments.

fn write_le_args<W>( &self, writer: &mut W, args: Self::Args<'_>, ) -> Result<(), Error>

where W: Write + Seek,

Write Self to the writer, assuming little-endian byte order, using the given arguments.

impl<Message> Clone for Complex<Message>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Message: Debug> Debug for Complex<Message>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Message: BinRead> Deref for Complex<Message>

where for<'a> <Message as BinRead>::Args<'a>: Default,

type Target = Message

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Message> From<&Complex<Message>> for MessageType

fn from(value: &Complex<Message>) -> Self

Converts to this type from the input type.

impl<Message> From<&Complex<Message>> for MessageType

fn from(value: &Complex<Message>) -> Self

Converts to this type from the input type.

impl<Message> From<&Complex<Message>> for MessageType

fn from(value: &Complex<Message>) -> Self

Converts to this type from the input type.

impl<Message: BinRead> From<Bytes> for Complex<Message>

where for<'a> <Message as BinRead>::Args<'a>: Default,

fn from(bytes: Bytes) -> Self

Converts to this type from the input type.

impl<Message> From<Message> for Complex<Message>

where Message: BinRead + BinWrite + PureMessage, for<'a> <Message as BinRead>::Args<'a>: Default, for<'a> <Message as BinWrite>::Args<'a>: Default,

fn from(message: Message) -> Self

Converts to this type from the input type.