Struct Frame 

pub struct Frame<T> { /* private fields */ }

An immutable view into a SOFH-enclosed message, complete with its encoding type tag and message payload.

Type parameters

Frame is generic over T, which must implement AsRef<[u8]> and is the payload type. Common choices for T are &'a [u8] for some lifetime 'a, bytes::Bytes, and bytes::BytesMut.

Implementations

impl<T> Frame<T>

where T: AsRef<[u8]>,

pub fn new(encoding_type: u16, payload: T) -> Self

Creates a new Frame with the given encoding_type and payload.

Panics

This function panics if message.len() > u32::MAX as usize - 6, which would cause encoding issues.

Examples

use minisofh::Frame;

let frame = Frame::new(0xF500, b"{}" as &[u8]);
assert_eq!(frame.payload().len(), 2);

pub fn encoding_type(&self) -> u16

Returns the 16-bits encoding type of self. You may want to convert this value to an EncodingType, which allows for nice pattern matching.

Examples

use minisofh::{EncodingType, Frame};

let frame = Frame::new(0xF500, &[] as &[u8]);
let encoding_type = EncodingType::new(frame.encoding_type());
assert_eq!(encoding_type, Some(EncodingType::Json));

pub fn payload(&self) -> &T

Returns an immutable reference to the payload of self, i.e. without its header.

Examples

use minisofh::Frame;

let frame = Frame::new(0x0, &[42u8] as &[u8]);
assert_eq!(frame.payload(), &[42]);

pub fn payload_mut(&mut self) -> &mut T

Returns a mutable reference to the payload of self.

pub fn serialize<W>(&self, writer: &mut W) -> Result<usize>

where W: Write,

Serializes self to a Writer. This requires copying and thus is potentially expensive.

Examples

use minisofh::Frame;

// Message_Length:
//            ~~~~~~~~~~~~~
// Encoding_Type:           ~~~~~~~~~
// Message:                           ~~
let bytes = &[0u8, 0, 0, 7, 0x0, 0x0, 42] as &[u8];
let frame = Frame::<&[u8]>::deserialize(bytes).unwrap();
let buffer = &mut Vec::new();
frame.serialize(buffer).unwrap();
assert_eq!(&buffer[..], bytes);

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

pub fn deserialize(data: &'a [u8]) -> Result<Self, Error>

Tries to deserialize a Frame from data. Returns an Err if invalid. Zero-copy.

This function ignores trailing bytes that are not part of the message.

Examples

use minisofh::Frame;

// Message_Length:                        ~~~~~~~~~~~
// Encoding_Type:                                     ~~~~~~~~~
// Message:                                                     ~~
let frame = Frame::<&[u8]>::deserialize(&[0, 0, 0, 7, 0x0, 0x0, 42]).unwrap();
assert_eq!(frame.payload(), &[42]);

Trait Implementations

impl<T: Clone> Clone for Frame<T>

fn clone(&self) -> Frame<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Frame<T>

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

Formats the value using the given formatter.

impl<T> Encoder<Frame<T>> for TokioCodec

where T: AsRef<[u8]>,

Available on crate feature utils-tokio-codec only.

type Error = Error

The type of encoding errors.

fn encode( &mut self, frame: Frame<T>, dst: &mut BytesMut, ) -> Result<(), Self::Error>

Encodes a frame into the buffer provided.

impl<T: PartialEq> PartialEq for Frame<T>

fn eq(&self, other: &Frame<T>) -> 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<T: Copy> Copy for Frame<T>

impl<T: Eq> Eq for Frame<T>

impl<T> StructuralPartialEq for Frame<T>