Enum WireBytes 

#[non_exhaustive]
pub enum WireBytes<'a> {
    InBuffer,
    Own(&'a [u8]),
}

Where a Serialized value’s bytes are: in the buffer it was handed, or in the value itself.

It is the answer Serialized::wire_bytes gives, and the publish path needs it because the two are not interchangeable underneath: a transport that keeps the payload takes the buffer where the value wrote into it, and copies where the bytes belong to the value. A pointer comparison would guess at the same fact; this states it.

Examples

use std::convert::Infallible;

use ruststream::prelude::*;

/// A frame that already holds its encoded bytes: it lends them, and the buffer it was handed
/// stays untouched.
struct Frame(Vec<u8>);

impl Serialized for Frame {
    type Error = Infallible;

    fn wire_bytes(&self, _buf: &mut BytesMut) -> Result<WireBytes<'_>, Infallible> {
        Ok(WireBytes::Own(&self.0))
    }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InBuffer

The value wrote its bytes into the buffer it was handed.

Own(&'a [u8])

The bytes are the value’s own, lent for the length of the publish.

Implementations

impl<'a> WireBytes<'a>

pub fn of(self, buf: &'a BytesMut) -> &'a [u8]

The bytes themselves, given the buffer the value was handed.

What a caller that only reads them uses; the publish path answers the two arms differently, because only one of them can be taken.

Examples

use ruststream::BytesMut;
use ruststream::runtime::Serialized;

/// The size a value has on the wire, for a check against the broker's payload limit before
/// the publish is attempted.
fn wire_len<T: Serialized>(value: &T) -> Result<usize, T::Error> {
    let mut buf = BytesMut::new();
    Ok(value.wire_bytes(&mut buf)?.of(&buf).len())
}

Trait Implementations

impl<'a> Clone for WireBytes<'a>

fn clone(&self) -> WireBytes<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for WireBytes<'a>

impl<'a> Debug for WireBytes<'a>

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

Formats the value using the given formatter.