Struct Pingresp

pub struct Pingresp { /* private fields */ }

MQTT 5.0 PINGRESP packet representation

The PINGRESP packet is a heartbeat response packet sent by an MQTT server to a client in response to a PINGREQ packet. This packet acknowledges that the server has received the client’s keep-alive request and confirms that the connection is still active.

According to MQTT 5.0 specification, the PINGRESP packet:

• Has no variable header
• Has no payload
• Has a remaining length of 0
• Must be sent by the server in response to a PINGREQ packet

Protocol Information

• Packet Type: 13 (0xD0)
• Remaining Length: 0 (no variable header or payload)
• Direction: Server to Client

Keep Alive Mechanism

The PINGRESP packet is used to:

• Acknowledge the client’s PINGREQ packet
• Confirm to the client that the server is alive and responsive
• Maintain the network connection’s keep-alive state
• Prevent connection timeouts due to network inactivity

The server must send a PINGRESP packet in response to each PINGREQ packet received. If the client does not receive a PINGRESP within a reasonable time after sending a PINGREQ, it should consider the connection broken and close the network connection.

Timing Requirements

The server should send a PINGRESP packet:

• Immediately upon receiving a PINGREQ packet
• With minimal delay to ensure timely keep-alive acknowledgment
• Before processing other non-urgent packets

Examples

use mqtt_protocol_core::mqtt;

// Create a PINGRESP packet
let pingresp = mqtt::packet::v5_0::Pingresp::new();

assert_eq!(pingresp.packet_type(), mqtt::packet::packet_type::PacketType::Pingresp);
assert_eq!(pingresp.size(), 2); // Fixed header (1 byte) + remaining length (1 byte)

// Build using builder pattern
let pingresp = mqtt::packet::v5_0::Pingresp::builder()
    .build()
    .unwrap();

// Serialize to bytes for network transmission
let buffers = pingresp.to_buffers();
assert_eq!(buffers.len(), 2); // Fixed header + remaining length

Implementations

impl Pingresp

pub fn new() -> Self

Creates a new PINGRESP packet

This method creates a PINGRESP packet with the standard fixed header and zero remaining length, as specified by the MQTT 5.0 protocol. The PINGRESP packet is typically created by the server in response to a PINGREQ packet from the client.

Returns

A new Pingresp instance ready for transmission

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
assert_eq!(pingresp.size(), 2);

pub fn builder() -> PingrespBuilder

Creates a new builder for constructing a PINGRESP packet

The builder pattern provides a consistent interface for packet creation, even though PINGRESP packets have no configurable parameters.

Returns

A PingrespBuilder instance

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::builder()
    .build()
    .unwrap();

pub fn packet_type() -> PacketType

Returns the packet type for PINGRESP packets

Returns

PacketType::Pingresp (value 13)

Examples

use mqtt_protocol_core::mqtt;

assert_eq!(
    mqtt::packet::v5_0::Pingresp::packet_type(),
    mqtt::packet::packet_type::PacketType::Pingresp
);

pub fn size(&self) -> usize

Returns the total size of the PINGRESP packet in bytes

The size includes the fixed header (1 byte) and the remaining length field (1 byte). Since PINGRESP has no variable header or payload, the total size is always 2 bytes.

Returns

The packet size in bytes (always 2 for PINGRESP)

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
assert_eq!(pingresp.size(), 2);

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

Converts the PINGRESP packet to a vector of I/O slices for efficient network transmission

This method provides zero-copy serialization by returning references to the internal packet data as I/O slices, which can be used directly with vectored I/O operations.

Returns

A vector containing:

• Fixed header slice (1 byte)
• Remaining length slice (1 byte)

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
let buffers = pingresp.to_buffers();
assert_eq!(buffers.len(), 2);

// Can be used with vectored write operations
// stream.write_vectored(&buffers).await?;

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

Parses a PINGRESP packet from raw bytes

Since PINGRESP packets have no variable header or payload, this method simply creates a new PINGRESP packet instance. The data parameter is not used but is kept for consistency with other packet types.

Parameters

• _data - Raw byte data (unused for PINGRESP)

Returns

A tuple containing:

• The created Pingresp instance
• The number of bytes consumed (always 0 for PINGRESP)

Errors

This method always succeeds for PINGRESP packets.

Examples

use mqtt_protocol_core::mqtt;

let data = &[];
let (pingresp, consumed) = mqtt::packet::v5_0::Pingresp::parse(data).unwrap();
assert_eq!(consumed, 0);
assert_eq!(pingresp.size(), 2);

Trait Implementations

impl AsConcrete<Pingresp> for Packet

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

impl Clone for Pingresp

fn clone(&self) -> Pingresp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pingresp

Implements debug formatting for PINGRESP packets

This implementation uses the same format as Display to provide consistent output for debugging purposes.

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
println!("Debug: {:?}", pingresp);
// Output: {"type":"pingresp"}

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

Formats the value using the given formatter.

impl Display for Pingresp

Implements display formatting for PINGRESP packets

This implementation provides a JSON representation of the PINGRESP packet for human-readable output, debugging, and logging purposes.

Examples

use mqtt_protocol_core::mqtt;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
println!("PINGRESP: {}", pingresp);
// Output: {"type":"pingresp"}

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

Formats the value using the given formatter.

impl<PacketIdType> From<Pingresp> for GenericPacket<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

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

Converts to this type from the input type.

impl GenericPacketDisplay for Pingresp

Implements the generic packet display trait for PINGRESP packets

This trait provides a common interface for formatting MQTT packets, allowing them to be displayed consistently across different packet types.

Methods

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

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

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

impl GenericPacketTrait for Pingresp

Implements the generic packet trait for PINGRESP packets

This trait provides a common interface for all MQTT packet types, allowing them to be used polymorphically in generic contexts.

Methods

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

fn size(&self) -> usize

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

impl IntoConcreteOwned<Pingresp> for Packet

fn into_concrete_owned(self) -> Option<Pingresp>

impl PacketKind for Pingresp

const IS_PINGRESP: bool = true

true if this is a PINGRESP 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_PUBACK: bool = false

true if this is a PUBACK 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_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 PartialEq for Pingresp

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

Implements JSON serialization for PINGRESP packets

This implementation allows PINGRESP packets to be serialized to JSON format, which is useful for debugging, logging, and protocol analysis.

The serialized format includes:

• type: The packet type as a string (“pingresp”)

Examples

use mqtt_protocol_core::mqtt;
use serde_json;

let pingresp = mqtt::packet::v5_0::Pingresp::new();
let json = serde_json::to_string(&pingresp).unwrap();
assert!(json.contains("pingresp"));

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<Pingresp> 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<Pingresp, <Self as TryInto<Pingresp>>::Error>

Performs the conversion.

impl Eq for Pingresp

impl SendableRole<Any> for Pingresp

impl SendableRole<Server> for Pingresp

impl StructuralPartialEq for Pingresp