Struct Frame

pub struct Frame<'a> { /* private fields */ }

Represents some data wrapped in a frame in order to ship it over the network. The format is simple and follows {len}{item} where len is the length of the item as a u64.

Implementations

impl<'a> Frame<'a>

pub fn new(item: &'a [u8]) -> Self

Creates a new frame wrapping the item that will be shipped across the network.

pub fn into_item(self) -> Cow<'a, [u8]>

Consumes the frame and returns its underlying item.

impl Frame<'_>

pub const HEADER_SIZE: usize = 8usize

Total bytes to use as the header field denoting a frame’s size.

pub fn empty() -> Self

Creates a new frame with no item.

pub fn len(&self) -> usize

Returns the len (in bytes) of the item wrapped by the frame.

pub fn is_empty(&self) -> bool

Returns true if the frame is comprised of zero bytes.

pub fn is_nonempty(&self) -> bool

Returns true if the frame is comprised of some bytes.

pub fn as_item(&self) -> &[u8]

Returns a reference to the bytes of the frame’s item.

pub fn to_bytes(&self) -> Vec<u8>

Writes the frame to a new Vec of bytes, returning them on success.

pub fn write(&self, dst: &mut BytesMut)

Writes the frame to the end of dst, including the header representing the length of the item as part of the written bytes.

pub fn read(src: &mut BytesMut) -> Option<OwnedFrame>

Attempts to read a frame from src, returning Some(Frame) if a frame was found (including the header) or None if the current src does not contain a frame.

pub fn available(src: &BytesMut) -> bool

Checks if a full frame is available from src, returning true if a frame was found false if the current src does not contain a frame. Does not consume the frame.

pub fn as_borrowed(&self) -> Frame<'_>

Returns a new frame which is identical but has a lifetime tied to this frame.

pub fn into_owned(self) -> OwnedFrame

Converts the Frame into an owned copy.

If you construct the frame from an item with a non-static lifetime, you may run into lifetime problems due to the way the struct is designed. Calling this function will ensure that the returned value has a static lifetime.

This is different from just cloning. Cloning the frame will just copy the references, and thus the lifetime will remain the same.

Trait Implementations

impl AsRef<[u8]> for Frame<'_>

fn as_ref(&self) -> &[u8]

Returns a reference to this Frame’s item as bytes.

impl<'a> Clone for Frame<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Frame<'a>

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

Formats the value using the given formatter.

impl Extend<u8> for Frame<'_>

fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T)

Extends the Frame’s item with the provided bytes, allocating an owned Vec underneath if this frame had borrowed bytes as an item.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> From<&'a [u8]> for Frame<'a>

fn from(item: &'a [u8]) -> Self

Consumes the byte slice and returns a Frame whose item references those bytes.

impl<'a, const N: usize> From<&'a [u8; N]> for Frame<'a>

fn from(item: &'a [u8; N]) -> Self

Consumes the byte array slice and returns a Frame whose item references those bytes.

impl<'a> PartialEq<&'a [u8]> for Frame<'_>

fn eq(&self, item: &&'a [u8]) -> bool

Test if Frame’s item matches the provided bytes.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, const N: usize> PartialEq<&'a [u8; N]> for Frame<'_>

fn eq(&self, item: &&'a [u8; N]) -> bool

Test if Frame’s item matches the provided bytes.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<[u8]> for Frame<'_>

fn eq(&self, item: &[u8]) -> bool

Test if Frame’s item matches the provided bytes.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> PartialEq<[u8; N]> for Frame<'_>

fn eq(&self, item: &[u8; N]) -> bool

Test if Frame’s item matches the provided bytes.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq for Frame<'a>

fn eq(&self, other: &Frame<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for Frame<'a>

impl<'a> StructuralPartialEq for Frame<'a>