Struct GenericPuback

pub struct GenericPuback<PacketIdType>
where
    PacketIdType: IsPacketId,
{
    pub props: Option<Properties>,
    /* private fields */
}

A PUBACK packet for MQTT v5.0 protocol.

The PUBACK packet is the response to a PUBLISH packet with QoS level 1. This packet acknowledges the receipt of a PUBLISH packet and may contain a reason code and properties to provide additional information about the acknowledgment status.

MQTT v5.0 Specification

According to the MQTT v5.0 specification, the PUBACK packet:

• Is sent by the receiver of a PUBLISH packet with QoS 1
• Contains the same Packet Identifier as the PUBLISH packet being acknowledged
• May optionally include a reason code indicating the result of the PUBLISH processing
• May optionally include properties for additional metadata

Generic Support

This struct supports generic packet identifiers through the PacketIdType parameter, allowing for extended packet ID ranges (e.g., u32) for broker clustering scenarios. The standard type alias Puback uses u16 packet identifiers as per MQTT specification.

Examples

Creating a basic PUBACK packet:

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::prelude::*;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(123u16)
    .build()
    .unwrap();

assert_eq!(puback.packet_id(), 123u16);

Creating a PUBACK with reason code:

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::prelude::*;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(456u16)
    .reason_code(mqtt::result_code::PubackReasonCode::Success)
    .build()
    .unwrap();

assert_eq!(puback.packet_id(), 456u16);
assert_eq!(puback.reason_code(), Some(mqtt::result_code::PubackReasonCode::Success));

Fields

props: Option<Properties>

Optional MQTT v5.0 properties associated with this PUBACK packet.

Properties can include:

• ReasonString: Human readable string designed for diagnostics
• UserProperty: Name-value pairs for application-specific metadata

Only one ReasonString property is allowed per packet.

Implementations

impl<PacketIdType> GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

pub fn props(&self) -> &Option<Properties>

Optional MQTT v5.0 properties associated with this PUBACK packet.

Properties can include:

• ReasonString: Human readable string designed for diagnostics
• UserProperty: Name-value pairs for application-specific metadata

Only one ReasonString property is allowed per packet.

impl<PacketIdType> GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

pub fn builder() -> GenericPubackBuilder<PacketIdType>

Creates a new builder for constructing a PUBACK packet.

Returns

A new GenericPubackBuilder instance for building PUBACK packets.

Examples

use mqtt_protocol_core::mqtt;

let builder = mqtt::packet::v5_0::Puback::builder();
let puback = builder
    .packet_id(42u16)
    .build()
    .unwrap();

pub fn packet_type() -> PacketType

Returns the packet type for PUBACK packets.

Returns

Always returns PacketType::Puback.

Examples

use mqtt_protocol_core::mqtt;

let packet_type = mqtt::packet::v5_0::Puback::packet_type();
assert_eq!(packet_type, mqtt::packet::packet_type::PacketType::Puback);

pub fn packet_id(&self) -> PacketIdType

Returns the packet identifier of this PUBACK packet.

The packet identifier must match the packet identifier of the PUBLISH packet that this PUBACK is acknowledging.

Returns

The packet identifier as the specified PacketIdType.

Examples

use mqtt_protocol_core::mqtt;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(1337u16)
    .build()
    .unwrap();

assert_eq!(puback.packet_id(), 1337u16);

pub fn reason_code(&self) -> Option<PubackReasonCode>

Returns the reason code of this PUBACK packet, if present.

The reason code indicates the result of the PUBLISH packet processing. If no reason code is present, it implies successful processing (equivalent to PubackReasonCode::Success).

Returns

An Option<PubackReasonCode> containing the reason code if present, or None if no reason code was included in the packet.

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::prelude::*;

// PUBACK without reason code (implies success)
let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(1u16)
    .build()
    .unwrap();

assert_eq!(puback.reason_code(), None);

// PUBACK with explicit reason code
let puback_with_reason = mqtt::packet::v5_0::Puback::builder()
    .packet_id(2u16)
    .reason_code(mqtt::result_code::PubackReasonCode::NoMatchingSubscribers)
    .build()
    .unwrap();

assert_eq!(puback_with_reason.reason_code(),
           Some(mqtt::result_code::PubackReasonCode::NoMatchingSubscribers));

pub fn size(&self) -> usize

Returns the total size of the PUBACK packet in bytes.

This includes the fixed header, remaining length field, packet identifier, optional reason code, optional property length, and optional properties.

Returns

The total packet size in bytes.

Examples

use mqtt_protocol_core::mqtt;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(1u16)
    .build()
    .unwrap();

let size = puback.size();
// Minimum size: 1 (fixed header) + 1 (remaining length) + 2 (packet id) = 4 bytes
assert!(size >= 4);

pub fn to_buffers(&self) -> Vec<IoSlice<'_>>

Converts the PUBACK packet into a vector of I/O slices for efficient transmission.

This method prepares the packet data for network transmission by organizing it into a series of byte slices that can be sent without additional copying.

Returns

A Vec<IoSlice<'_>> containing the packet data organized as I/O slices. The slices are ordered as: fixed header, remaining length, packet identifier, optional reason code, optional property length, and optional properties.

Examples

use mqtt_protocol_core::mqtt;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(1u16)
    .build()
    .unwrap();

let buffers = puback.to_buffers();
assert!(!buffers.is_empty());

pub fn parse(data: &[u8]) -> Result<(Self, usize), MqttError>

Parses a PUBACK packet from raw bytes.

This method deserializes a byte array into a PUBACK packet structure, validating the packet format and extracting all components including packet identifier, optional reason code, and optional properties.

Parameters

• data - A byte slice containing the PUBACK packet data (excluding fixed header and remaining length)

Returns

A Result containing:

• Ok((Self, usize)) - The parsed PUBACK packet and the number of bytes consumed
• Err(MqttError) - An error if the packet is malformed or invalid

Errors

Returns MqttError::MalformedPacket if:

• The packet identifier is zero (invalid)
• The data is too short to contain a valid packet identifier
• The reason code is invalid
• Properties are malformed

Returns MqttError::ProtocolError if:

• Invalid properties are present for PUBACK packets
• More than one ReasonString property is present

Examples

use mqtt_protocol_core::mqtt;

// Parse PUBACK packet data
let data = &[0x00, 0x01]; // packet_id = 1
let (puback, consumed) = mqtt::packet::v5_0::Puback::parse(data).unwrap();

assert_eq!(puback.packet_id(), 1u16);
assert_eq!(consumed, 2);

Trait Implementations

impl AsConcrete<GenericPuback<u16>> for Packet

fn as_concrete(&self) -> Option<&Puback>

impl<PacketIdType> Clone for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Clone, PacketIdType::Buffer: Clone,

fn clone(&self) -> GenericPuback<PacketIdType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<PacketIdType> Debug for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

Debug implementation for GenericPuback.

Uses the same JSON formatting as the Display implementation to provide consistent debug output across the library.

Examples

use mqtt_protocol_core::mqtt;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(456u16)
    .build()
    .unwrap();

println!("{:?}", puback);
// Output: {"type":"puback","packet_id":456}

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

Formats the value using the given formatter.

impl<PacketIdType> Display for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

Display implementation for GenericPuback.

Formats the PUBACK packet as JSON for human-readable output. This is useful for logging, debugging, and diagnostic purposes.

Output Format

The output is JSON formatted and includes all packet fields. If serialization fails, an error message is displayed instead.

Examples

use mqtt_protocol_core::mqtt;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(123u16)
    .build()
    .unwrap();

println!("{}", puback);
// Output: {"type":"puback","packet_id":123}

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

Formats the value using the given formatter.

impl<PacketIdType> From<GenericPuback<PacketIdType>> for GenericPacket<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

fn from(v: GenericPuback<PacketIdType>) -> GenericPacket<PacketIdType>

Converts to this type from the input type.

impl<PacketIdType> GenericPacketDisplay for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

GenericPacketDisplay implementation for GenericPuback.

Provides formatted display capabilities for the PUBACK packet that can be used by the generic packet display system. This enables consistent formatting across all packet types.

Trait Methods

• fmt_debug(): Debug formatting (JSON output)
• fmt_display(): Display formatting (JSON output)

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

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

impl<PacketIdType> GenericPacketTrait for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

GenericPacketTrait implementation for GenericPuback.

Provides the core packet interface methods required by the MQTT protocol library. This trait enables the PUBACK packet to be used generically alongside other packet types in the protocol processing pipeline.

Trait Methods

• size(): Returns the total packet size in bytes
• to_buffers(): Converts the packet to I/O slices for transmission

fn size(&self) -> usize

fn to_buffers(&self) -> Vec<IoSlice<'_>>

impl IntoConcreteOwned<GenericPuback<u16>> for Packet

fn into_concrete_owned(self) -> Option<Puback>

impl<PacketIdType> PacketKind for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

const IS_PUBACK: bool = true

true if this is a PUBACK packet

const IS_V5_0: bool = true

true if this is an MQTT v5.0 packet

const IS_CONNECT: bool = false

true if this is a CONNECT packet

const IS_CONNACK: bool = false

true if this is a CONNACK packet

const IS_PUBLISH: bool = false

true if this is a PUBLISH packet

const IS_PUBREC: bool = false

true if this is a PUBREC packet

const IS_PUBREL: bool = false

true if this is a PUBREL packet

const IS_PUBCOMP: bool = false

true if this is a PUBCOMP packet

const IS_SUBSCRIBE: bool = false

true if this is a SUBSCRIBE packet

const IS_SUBACK: bool = false

true if this is a SUBACK packet

const IS_UNSUBSCRIBE: bool = false

true if this is an UNSUBSCRIBE packet

const IS_UNSUBACK: bool = false

true if this is an UNSUBACK packet

const IS_PINGREQ: bool = false

true if this is a PINGREQ packet

const IS_PINGRESP: bool = false

true if this is a PINGRESP packet

const IS_DISCONNECT: bool = false

true if this is a DISCONNECT packet

const IS_AUTH: bool = false

true if this is an AUTH packet (v5.0 only)

const IS_V3_1_1: bool = false

true if this is an MQTT v3.1.1 packet

impl<PacketIdType> PartialEq for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + PartialEq, PacketIdType::Buffer: PartialEq,

fn eq(&self, other: &GenericPuback<PacketIdType>) -> 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<PacketIdType> Serialize for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

Serialize implementation for GenericPuback.

Serializes the PUBACK packet into a structured format suitable for JSON output or other serialization formats. The serialization includes the packet type, packet identifier, optional reason code, and optional properties.

Serialized Fields

• type: Always “puback”
• packet_id: The packet identifier
• reason_code: Present only if a reason code was set
• props: Present only if properties were set

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::prelude::*;

let puback = mqtt::packet::v5_0::Puback::builder()
    .packet_id(42u16)
    .reason_code(mqtt::result_code::PubackReasonCode::Success)
    .build()
    .unwrap();

let json = serde_json::to_string(&puback).unwrap();
// JSON will contain: {"type":"puback","packet_id":42,"reason_code":"Success"}

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<PacketIdType> TryInto<GenericPuback<PacketIdType>> for GenericPacket<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into( self, ) -> Result<GenericPuback<PacketIdType>, <Self as TryInto<GenericPuback<PacketIdType>>>::Error>

Performs the conversion.

impl<PacketIdType> Eq for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId + Eq, PacketIdType::Buffer: Eq,

impl<PacketIdType> SendableRole<Any> for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

impl<PacketIdType> SendableRole<Client> for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

impl<PacketIdType> SendableRole<Server> for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,

impl<PacketIdType> StructuralPartialEq for GenericPuback<PacketIdType>

where PacketIdType: IsPacketId,