Struct PacketCodec 

pub struct PacketCodec { /* private fields */ }

A codec for encoding and decoding MQTT packets.

The PacketCodec struct implements the Encoder and Decoder traits from the tokio_util::codec module, allowing it to be used with asynchronous I/O frameworks.

Examples

use mqute_codec::codec::PacketCodec;
use mqute_codec::protocol::{FixedHeader, PacketType};
use bytes::BytesMut;

let mut codec = PacketCodec::new(Some(1024), Some(1024));
let mut buffer = BytesMut::from(&[0x30, 0x02, 0x00, 0x01][..]); // Example raw packet
let packet = codec.try_decode(&mut buffer).unwrap();

Implementations

impl PacketCodec

pub fn new( inbound_max_size: Option<usize>, outbound_max_size: Option<usize>, ) -> Self

Creates a new PacketCodec with the specified size limits.

pub fn try_decode(&self, dst: &mut BytesMut) -> Result<RawPacket, Error>

Attempts to decode a raw packet from the provided buffer.

Trait Implementations

impl Clone for PacketCodec

fn clone(&self) -> PacketCodec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PacketCodec

impl Debug for PacketCodec

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

Formats the value using the given formatter.

impl Decoder for PacketCodec

fn decode( &mut self, src: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

Decodes a raw packet from the provided buffer.

Examples

use mqute_codec::codec::PacketCodec;
use mqute_codec::protocol::PacketType;
use tokio_util::codec::Decoder;
use bytes::BytesMut;

let mut codec = PacketCodec::new(Some(1024), Some(1024));
let mut buffer = BytesMut::from(&[0x30, 0x02, 0x00, 0x01][..]); // Example raw packet
let packet = codec.decode(&mut buffer).unwrap().unwrap();

assert_eq!(packet.header.packet_type(), PacketType::Publish);
assert_eq!(packet.payload.len(), 2);

type Item = RawPacket

The type of decoded frames.

type Error = Error

The type of unrecoverable frame decoding errors.

fn decode_eof( &mut self, buf: &mut BytesMut, ) -> Result<Option<Self::Item>, Self::Error>

A default method available to be called when there are no more bytes available to be read from the underlying I/O.

fn framed<T>(self, io: T) -> Framed<T, Self>

where T: AsyncRead + AsyncWrite, Self: Sized,

Provides a Stream and Sink interface for reading and writing to this Io object, using Decode and Encode to read and write the raw data.

impl<T> Encoder<T> for PacketCodec

where T: Encode,

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

Encodes an item into the provided buffer.

Examples

use mqute_codec::codec::{PacketCodec, Encode};
use tokio_util::codec::Encoder;
use bytes::BytesMut;
use mqute_codec::Error;

struct MyPacket;

impl Encode for MyPacket {
    fn encode(&self, dst: &mut BytesMut) -> Result<(), Error> {
        dst.extend_from_slice(&[0x30, 0x02, 0x00, 0x01]);
        Ok(())
    }

fn payload_len(&self) -> usize {
        4
    }
}

let mut codec = PacketCodec::new(Some(1024), Some(1024));
let mut buffer = BytesMut::new();
let packet = MyPacket {};
codec.encode(packet, &mut buffer).unwrap();

assert_eq!(buffer.as_ref(), &[0x30, 0x02, 0x00, 0x01]);

type Error = Error

The type of encoding errors.

impl Eq for PacketCodec

impl PartialEq for PacketCodec

fn eq(&self, other: &PacketCodec) -> 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 StructuralPartialEq for PacketCodec