Mqtt5Packets.h

Go to the documentation of this file.

#pragma once
#include <aws/crt/mqtt/Mqtt5Client.h>
#include <aws/crt/mqtt/Mqtt5Types.h>
 
namespace Aws
{
    namespace Crt
    {
        namespace Mqtt5
        {
 
            class AWS_CRT_CPP_API UserProperty
            {
              public:
                UserProperty(const Crt::String &name, const Crt::String &value) noexcept;
                UserProperty(Crt::String &&name, Crt::String &&value) noexcept;
 
                const Crt::String &getName() const noexcept { return m_name; };
                const Crt::String &getValue() const noexcept { return m_value; }
 
                bool operator==(const UserProperty &other) const
                {
                    return m_name == other.m_name && m_value == other.m_value;
                }
 
              private:
                Crt::String m_name;
                Crt::String m_value;
            };
 
            class AWS_CRT_CPP_API IPacket
            {
              public:
                virtual ~IPacket() = default;
                virtual PacketType getType() = 0;
            };
 
            class AWS_CRT_CPP_API PublishPacket : public IPacket
            {
              public:
                PublishPacket(
                    const aws_mqtt5_packet_publish_view &raw_options,
                    Allocator *allocator = ApiAllocator()) noexcept;
                PublishPacket(Allocator *allocator = ApiAllocator()) noexcept;
                PublishPacket(
                    Crt::String topic,
                    ByteCursor payload,
                    Mqtt5::QOS qos,
                    Allocator *allocator = ApiAllocator()) noexcept;
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_PUBLISH; };
 
                PublishPacket &WithPayload(ByteCursor payload) noexcept;
 
                PublishPacket &WithQOS(Mqtt5::QOS packetQOS) noexcept;
 
                PublishPacket &WithRetain(bool retain) noexcept;
 
                PublishPacket &WithTopic(Crt::String topic) noexcept;
 
                PublishPacket &WithPayloadFormatIndicator(PayloadFormatIndicator payloadFormat) noexcept;
 
                PublishPacket &WithMessageExpiryIntervalSec(uint32_t second) noexcept;
 
                PublishPacket &WithTopicAlias(uint16_t topicAlias) noexcept;
 
                PublishPacket &WithResponseTopic(ByteCursor responseTopic) noexcept;
 
                PublishPacket &WithCorrelationData(ByteCursor correlationData) noexcept;
 
                PublishPacket &WithContentType(ByteCursor contentType) noexcept;
 
                PublishPacket &WithUserProperties(const Vector<UserProperty> &userProperties) noexcept;
 
                PublishPacket &WithUserProperties(Vector<UserProperty> &&userProperties) noexcept;
 
                PublishPacket &WithUserProperty(UserProperty &&property) noexcept;
 
                bool initializeRawOptions(aws_mqtt5_packet_publish_view &raw_options) noexcept;
 
                const ByteCursor &getPayload() const noexcept;
 
                Mqtt5::QOS getQOS() const noexcept;
 
                bool getRetain() const noexcept;
 
                const Crt::String &getTopic() const noexcept;
 
                const Crt::Optional<PayloadFormatIndicator> &getPayloadFormatIndicator() const noexcept;
 
                const Crt::Optional<uint32_t> &getMessageExpiryIntervalSec() const noexcept;
 
                const Crt::Optional<uint16_t> &getTopicAlias() const noexcept;
 
                const Crt::Optional<ByteCursor> &getResponseTopic() const noexcept;
 
                const Crt::Optional<ByteCursor> &getCorrelationData() const noexcept;
 
                const Crt::Vector<uint32_t> &getSubscriptionIdentifiers() const noexcept;
 
                const Crt::Optional<ByteCursor> &getContentType() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                virtual ~PublishPacket();
                PublishPacket(const PublishPacket &) = delete;
                PublishPacket(PublishPacket &&) noexcept = delete;
                PublishPacket &operator=(const PublishPacket &) = delete;
                PublishPacket &operator=(PublishPacket &&) noexcept = delete;
 
              private:
                Allocator *m_allocator;
 
                ByteCursor m_payload;
 
                Mqtt5::QOS m_qos;
 
                bool m_retain;
 
                Crt::String m_topicName;
 
                Crt::Optional<PayloadFormatIndicator> m_payloadFormatIndicator;
 
                Crt::Optional<uint32_t> m_messageExpiryIntervalSec;
 
                Crt::Optional<uint16_t> m_topicAlias;
 
                Crt::Optional<ByteCursor> m_responseTopic;
 
                Crt::Optional<ByteCursor> m_correlationData;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                // The following parameters are ignored when building publish operations */
 
                Crt::Vector<uint32_t> m_subscriptionIdentifiers;
 
                Crt::Optional<ByteCursor> m_contentType;
 
                // Underlying data storage for internal use
                ByteBuf m_payloadStorage;
                ByteBuf m_contentTypeStorage;
                ByteBuf m_correlationDataStorage;
                Crt::String m_responseTopicString;
                struct aws_mqtt5_user_property *m_userPropertiesStorage;
            };
 
            class AWS_CRT_CPP_API NegotiatedSettings
            {
              public:
                NegotiatedSettings(
                    const aws_mqtt5_negotiated_settings &negotiated_settings,
 
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                Mqtt5::QOS getMaximumQOS() const noexcept;
 
                uint32_t getSessionExpiryIntervalSec() const noexcept;
 
                uint16_t getReceiveMaximumFromServer() const noexcept;
 
                uint32_t getMaximumPacketSizeBytes() const noexcept;
 
                uint32_t getMaximumPacketSizeToServer() const noexcept;
 
                uint16_t getTopicAliasMaximumToServer() const noexcept;
 
                uint16_t getTopicAliasMaximumToClient() const noexcept;
 
                uint16_t getServerKeepAliveSec() const noexcept;
 
                uint16_t getServerKeepAlive() const noexcept;
 
                bool getRetainAvailable() const noexcept;
 
                bool getWildcardSubscriptionsAvailable() const noexcept;
 
                bool getSubscriptionIdentifiersAvailable() const noexcept;
 
                bool getSharedSubscriptionsAvailable() const noexcept;
 
                bool getRejoinedSession() const noexcept;
 
                const Crt::String &getClientId() const noexcept;
 
                virtual ~NegotiatedSettings() {};
                NegotiatedSettings(const NegotiatedSettings &) = delete;
                NegotiatedSettings(NegotiatedSettings &&) noexcept = delete;
                NegotiatedSettings &operator=(const NegotiatedSettings &) = delete;
                NegotiatedSettings &operator=(NegotiatedSettings &&) noexcept = delete;
 
              private:
                Mqtt5::QOS m_maximumQOS;
 
                uint32_t m_sessionExpiryIntervalSec;
 
                uint16_t m_receiveMaximumFromServer;
 
                uint32_t m_maximumPacketSizeBytes;
 
                uint16_t m_topicAliasMaximumToServer;
 
                uint16_t m_topicAliasMaximumToClient;
 
                uint16_t m_serverKeepAliveSec;
 
                bool m_retainAvailable;
 
                bool m_wildcardSubscriptionsAvailable;
 
                bool m_subscriptionIdentifiersAvailable;
 
                bool m_sharedSubscriptionsAvailable;
 
                bool m_rejoinedSession;
 
                Crt::String m_clientId;
            };
 
            class AWS_CRT_CPP_API ConnectPacket : public IPacket
            {
              public:
                /* Default constructor */
                ConnectPacket(Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_CONNECT; };
 
                ConnectPacket &WithKeepAliveIntervalSec(uint16_t keepAliveInteralSeconds) noexcept;
 
                ConnectPacket &WithClientId(Crt::String clientId) noexcept;
 
                ConnectPacket &WithUserName(Crt::String username) noexcept;
 
                ConnectPacket &WithPassword(ByteCursor password) noexcept;
 
                ConnectPacket &WithSessionExpiryIntervalSec(uint32_t sessionExpiryIntervalSeconds) noexcept;
 
                ConnectPacket &WithRequestResponseInformation(bool requestResponseInformation) noexcept;
 
                ConnectPacket &WithRequestProblemInformation(bool requestProblemInformation) noexcept;
 
                ConnectPacket &WithReceiveMaximum(uint16_t receiveMaximum) noexcept;
 
                ConnectPacket &WithMaximumPacketSizeBytes(uint32_t maximumPacketSizeBytes) noexcept;
 
                ConnectPacket &WithWillDelayIntervalSec(uint32_t willDelayIntervalSeconds) noexcept;
 
                ConnectPacket &WithWill(std::shared_ptr<PublishPacket> will) noexcept;
 
                ConnectPacket &WithUserProperties(const Vector<UserProperty> &userProperties) noexcept;
 
                ConnectPacket &WithUserProperties(Vector<UserProperty> &&userProperties) noexcept;
 
                ConnectPacket &WithUserProperty(UserProperty &&property) noexcept;
 
                /********************************************
                 * Access Functions
                 ********************************************/
 
                uint16_t getKeepAliveIntervalSec() const noexcept;
 
                const Crt::String &getClientId() const noexcept;
 
                const Crt::Optional<Crt::String> &getUsername() const noexcept;
 
                const Crt::Optional<Crt::ByteCursor> &getPassword() const noexcept;
 
                const Crt::Optional<uint32_t> &getSessionExpiryIntervalSec() const noexcept;
 
                const Crt::Optional<bool> &getRequestResponseInformation() const noexcept;
 
                const Crt::Optional<bool> &getRequestProblemInformation() const noexcept;
 
                const Crt::Optional<uint16_t> &getReceiveMaximum() const noexcept;
 
                const Crt::Optional<uint32_t> &getMaximumPacketSizeBytes() const noexcept;
 
                const Crt::Optional<uint32_t> &getMaximumPacketSizeToServer() const noexcept;
 
                const Crt::Optional<uint32_t> &getWillDelayIntervalSec() const noexcept;
 
                const Crt::Optional<std::shared_ptr<PublishPacket>> &getWill() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                bool initializeRawOptions(aws_mqtt5_packet_connect_view &raw_options, Allocator *allocator) noexcept;
 
                virtual ~ConnectPacket();
                ConnectPacket(const ConnectPacket &) = delete;
                ConnectPacket(ConnectPacket &&) noexcept = delete;
                ConnectPacket &operator=(const ConnectPacket &) = delete;
                ConnectPacket &operator=(ConnectPacket &&) noexcept = delete;
 
              private:
                Allocator *m_allocator;
 
                uint16_t m_keepAliveIntervalSec;
 
                Crt::String m_clientId;
 
                Crt::Optional<Crt::String> m_username;
 
                Crt::Optional<ByteCursor> m_password;
 
                Crt::Optional<uint32_t> m_sessionExpiryIntervalSec;
 
                Crt::Optional<bool> m_requestResponseInformation;
 
                Crt::Optional<bool> m_requestProblemInformation;
 
                Crt::Optional<uint16_t> m_receiveMaximum;
 
                Crt::Optional<uint32_t> m_maximumPacketSizeBytes;
 
                Crt::Optional<uint32_t> m_willDelayIntervalSeconds;
 
                Crt::Optional<std::shared_ptr<PublishPacket>> m_will;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                // Underlying data storage for internal use
                struct aws_byte_cursor m_usernameCursor;
                struct aws_byte_buf m_passowrdStorage;
                struct aws_mqtt5_packet_publish_view m_willStorage;
                struct aws_mqtt5_user_property *m_userPropertiesStorage;
                uint8_t m_requestResponseInformationStorage;
                uint8_t m_requestProblemInformationStorage;
            };
 
            class AWS_CRT_CPP_API ConnAckPacket : public IPacket
            {
              public:
                ConnAckPacket(
                    const aws_mqtt5_packet_connack_view &packet,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_CONNACK; };
 
                bool getSessionPresent() const noexcept;
 
                ConnectReasonCode getReasonCode() const noexcept;
 
                const Crt::Optional<uint32_t> &getSessionExpiryIntervalSec() const noexcept;
 
                const Crt::Optional<uint32_t> &getSessionExpiryInterval() const noexcept;
 
                const Crt::Optional<uint16_t> &getReceiveMaximum() const noexcept;
 
                const Crt::Optional<QOS> &getMaximumQOS() const noexcept;
 
                const Crt::Optional<bool> &getRetainAvailable() const noexcept;
 
                const Crt::Optional<uint32_t> &getMaximumPacketSize() const noexcept;
 
                const Crt::Optional<String> &getAssignedClientIdentifier() const noexcept;
 
                const Crt::Optional<uint16_t> getTopicAliasMaximum() const noexcept;
 
                const Crt::Optional<String> &getReasonString() const noexcept;
 
                const Vector<UserProperty> &getUserProperty() const noexcept;
 
                const Crt::Optional<bool> &getWildcardSubscriptionsAvailable() const noexcept;
 
                const Crt::Optional<bool> &getSubscriptionIdentifiersAvailable() const noexcept;
 
                const Crt::Optional<bool> &getSharedSubscriptionsAvailable() const noexcept;
 
                const Crt::Optional<uint16_t> &getServerKeepAliveSec() const noexcept;
 
                const Crt::Optional<uint16_t> &getServerKeepAlive() const noexcept;
 
                const Crt::Optional<String> &getResponseInformation() const noexcept;
 
                const Crt::Optional<String> &getServerReference() const noexcept;
 
                virtual ~ConnAckPacket() {};
                ConnAckPacket(const ConnAckPacket &) = delete;
                ConnAckPacket(ConnAckPacket &&) noexcept = delete;
                ConnAckPacket &operator=(const ConnAckPacket &) = delete;
                ConnAckPacket &operator=(ConnAckPacket &&) noexcept = delete;
 
              private:
                bool m_sessionPresent;
 
                ConnectReasonCode m_reasonCode;
 
                Crt::Optional<uint32_t> m_sessionExpiryIntervalSec;
 
                Crt::Optional<uint16_t> m_receiveMaximum;
 
                Crt::Optional<QOS> m_maximumQOS;
 
                Crt::Optional<bool> m_retainAvailable;
 
                Crt::Optional<uint32_t> m_maximumPacketSize;
 
                Crt::Optional<String> m_assignedClientIdentifier;
 
                Crt::Optional<uint16_t> m_topicAliasMaximum;
 
                Crt::Optional<String> m_reasonString;
 
                Crt::Optional<bool> m_wildcardSubscriptionsAvailable;
 
                Crt::Optional<bool> m_subscriptionIdentifiersAvailable;
 
                Crt::Optional<bool> m_sharedSubscriptionsAvailable;
 
                Crt::Optional<uint16_t> m_serverKeepAliveSec;
 
                Crt::Optional<String> m_responseInformation;
 
                Crt::Optional<String> m_serverReference;
 
                Vector<UserProperty> m_userProperties;
            };
 
            class AWS_CRT_CPP_API DisconnectPacket : public IPacket
            {
              public:
                DisconnectPacket(Allocator *allocator = ApiAllocator()) noexcept;
                DisconnectPacket(
                    const aws_mqtt5_packet_disconnect_view &raw_options,
                    Allocator *allocator = ApiAllocator()) noexcept;
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_DISCONNECT; };
 
                bool initializeRawOptions(aws_mqtt5_packet_disconnect_view &raw_options) noexcept;
 
                DisconnectPacket &WithReasonCode(const DisconnectReasonCode reasonCode) noexcept;
 
                DisconnectPacket &WithSessionExpiryIntervalSec(const uint32_t sessionExpiryIntervalSeconds) noexcept;
 
                DisconnectPacket &WithReasonString(Crt::String reasonString) noexcept;
 
                DisconnectPacket &WithServerReference(Crt::String serverReference) noexcept;
 
                DisconnectPacket &WithUserProperties(const Vector<UserProperty> &userProperties) noexcept;
 
                DisconnectPacket &WithUserProperties(Vector<UserProperty> &&userProperties) noexcept;
 
                DisconnectPacket &WithUserProperty(UserProperty &&property) noexcept;
 
                DisconnectReasonCode getReasonCode() const noexcept;
 
                const Crt::Optional<uint32_t> &getSessionExpiryIntervalSec() const noexcept;
 
                const Crt::Optional<Crt::String> &getReasonString() const noexcept;
 
                const Crt::Optional<Crt::String> &getServerReference() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                virtual ~DisconnectPacket();
                DisconnectPacket(const DisconnectPacket &) = delete;
                DisconnectPacket(DisconnectPacket &&) noexcept = delete;
                DisconnectPacket &operator=(const DisconnectPacket &) = delete;
                DisconnectPacket &operator=(DisconnectPacket &&) noexcept = delete;
 
              private:
                Crt::Allocator *m_allocator;
 
                DisconnectReasonCode m_reasonCode;
 
                Crt::Optional<uint32_t> m_sessionExpiryIntervalSec;
 
                Crt::Optional<Crt::String> m_reasonString;
 
                Crt::Optional<Crt::String> m_serverReference;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                // Underlying data storage for internal use
                struct aws_byte_cursor m_reasonStringCursor;
                struct aws_byte_cursor m_serverReferenceCursor;
                struct aws_mqtt5_user_property *m_userPropertiesStorage;
            };
 
            class AWS_CRT_CPP_API PubAckPacket : public IPacket
            {
              public:
                PubAckPacket(
                    const aws_mqtt5_packet_puback_view &packet,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_PUBACK; };
 
                PubAckReasonCode getReasonCode() const noexcept;
 
                const Crt::Optional<Crt::String> &getReasonString() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                virtual ~PubAckPacket() {};
                PubAckPacket(const PubAckPacket &toCopy) noexcept = delete;
                PubAckPacket(PubAckPacket &&toMove) noexcept = delete;
                PubAckPacket &operator=(const PubAckPacket &toCopy) noexcept = delete;
                PubAckPacket &operator=(PubAckPacket &&toMove) noexcept = delete;
 
              private:
                PubAckReasonCode m_reasonCode;
 
                Crt::Optional<Crt::String> m_reasonString;
 
                Crt::Vector<UserProperty> m_userProperties;
            };
 
            class AWS_CRT_CPP_API PublishResult
            {
              public:
                PublishResult();                                     // QoS 0 success
                PublishResult(std::shared_ptr<PubAckPacket> puback); // Qos 1 success
                PublishResult(int errorCode);                        // any failure
 
                bool wasSuccessful() const { return m_errorCode == 0; };
 
                int getErrorCode() const { return m_errorCode; };
 
                std::shared_ptr<IPacket> getAck() const { return m_ack; };
 
                ~PublishResult() noexcept;
                PublishResult(const PublishResult &toCopy) noexcept = delete;
                PublishResult(PublishResult &&toMove) noexcept = delete;
                PublishResult &operator=(const PublishResult &toCopy) noexcept = delete;
                PublishResult &operator=(PublishResult &&toMove) noexcept = delete;
 
              private:
                std::shared_ptr<IPacket> m_ack;
                int m_errorCode;
            };
 
            class AWS_CRT_CPP_API Subscription
            {
 
              public:
                Subscription(Allocator *allocator = ApiAllocator());
                Subscription(Crt::String topicFilter, Mqtt5::QOS qos, Allocator *allocator = ApiAllocator());
 
                Subscription &WithTopicFilter(Crt::String topicFilter) noexcept;
 
                Subscription &WithQOS(Mqtt5::QOS QOS) noexcept;
 
                Subscription &WithNoLocal(bool noLocal) noexcept;
 
                Subscription &WithRetainAsPublished(bool retain) noexcept;
 
                Subscription &WithRetain(bool retain) noexcept;
 
                Subscription &WithRetainHandlingType(RetainHandlingType retainHandlingType) noexcept;
 
                bool initializeRawOptions(aws_mqtt5_subscription_view &raw_options) const noexcept;
 
                virtual ~Subscription() {};
                Subscription(const Subscription &) noexcept;
                Subscription(Subscription &&) noexcept;
                Subscription &operator=(const Subscription &) noexcept;
                Subscription &operator=(Subscription &&) noexcept;
 
              private:
                Allocator *m_allocator;
 
                Crt::String m_topicFilter;
 
                Mqtt5::QOS m_qos;
 
                bool m_noLocal;
 
                bool m_retainAsPublished;
 
                RetainHandlingType m_retainHnadlingType;
            };
 
            class AWS_CRT_CPP_API SubscribePacket : public IPacket
            {
              public:
                SubscribePacket(Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_SUBSCRIBE; };
 
                SubscribePacket &WithUserProperties(const Vector<UserProperty> &userProperties) noexcept;
 
                SubscribePacket &WithUserProperties(Vector<UserProperty> &&userProperties) noexcept;
 
                SubscribePacket &WithUserProperty(UserProperty &&property) noexcept;
 
                SubscribePacket &WithSubscriptionIdentifier(uint32_t subscriptionIdentifier) noexcept;
 
                SubscribePacket &WithSubscriptions(const Vector<Subscription> &subscriptions) noexcept;
 
                SubscribePacket &WithSubscriptions(Crt::Vector<Subscription> &&subscriptions) noexcept;
 
                SubscribePacket &WithSubscription(Subscription &&subscription) noexcept;
 
                bool initializeRawOptions(aws_mqtt5_packet_subscribe_view &raw_options) noexcept;
 
                virtual ~SubscribePacket();
                SubscribePacket(const SubscribePacket &) noexcept = delete;
                SubscribePacket(SubscribePacket &&) noexcept = delete;
                SubscribePacket &operator=(const SubscribePacket &) noexcept = delete;
                SubscribePacket &operator=(SubscribePacket &&) noexcept = delete;
 
              private:
                Allocator *m_allocator;
 
                Crt::Vector<Subscription> m_subscriptions;
 
                Crt::Optional<uint32_t> m_subscriptionIdentifier;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                // Underlying data storage for internal use
                struct aws_mqtt5_subscription_view *m_subscriptionViewStorage;
                struct aws_mqtt5_user_property *m_userPropertiesStorage;
            };
 
            class AWS_CRT_CPP_API SubAckPacket : public IPacket
            {
              public:
                SubAckPacket(
                    const aws_mqtt5_packet_suback_view &packet,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_SUBACK; };
 
                const Crt::Optional<Crt::String> &getReasonString() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                const Crt::Vector<SubAckReasonCode> &getReasonCodes() const noexcept;
 
                virtual ~SubAckPacket() { m_userProperties.clear(); };
                SubAckPacket(const SubAckPacket &) noexcept = delete;
                SubAckPacket(SubAckPacket &&) noexcept = delete;
                SubAckPacket &operator=(const SubAckPacket &) noexcept = delete;
                SubAckPacket &operator=(SubAckPacket &&) noexcept = delete;
 
              private:
                Crt::Vector<SubAckReasonCode> m_reasonCodes;
 
                Crt::Optional<Crt::String> m_reasonString;
 
                Crt::Vector<UserProperty> m_userProperties;
            };
 
            class AWS_CRT_CPP_API UnsubscribePacket : public IPacket
            {
              public:
                UnsubscribePacket(Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_UNSUBSCRIBE; };
 
                UnsubscribePacket &WithTopicFilter(Crt::String topicFilter) noexcept;
 
                UnsubscribePacket &WithTopicFilters(Crt::Vector<String> topicFilters) noexcept;
 
                UnsubscribePacket &WithUserProperties(const Vector<UserProperty> &userProperties) noexcept;
 
                UnsubscribePacket &WithUserProperties(Vector<UserProperty> &&userProperties) noexcept;
 
                UnsubscribePacket &WithUserProperty(UserProperty &&property) noexcept;
 
                bool initializeRawOptions(aws_mqtt5_packet_unsubscribe_view &raw_options) noexcept;
 
                virtual ~UnsubscribePacket();
                UnsubscribePacket(const UnsubscribePacket &) noexcept = delete;
                UnsubscribePacket(UnsubscribePacket &&) noexcept = delete;
                UnsubscribePacket &operator=(const UnsubscribePacket &) noexcept = delete;
                UnsubscribePacket &operator=(UnsubscribePacket &&) noexcept = delete;
 
              private:
                Allocator *m_allocator;
 
                Crt::Vector<String> m_topicFilters;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                // Underlying data storage for internal use
                struct aws_array_list m_topicFiltersList;
                struct aws_mqtt5_user_property *m_userPropertiesStorage;
            };
 
            class AWS_CRT_CPP_API UnSubAckPacket : public IPacket
            {
              public:
                UnSubAckPacket(
                    const aws_mqtt5_packet_unsuback_view &packet,
                    Allocator *allocator = ApiAllocator()) noexcept;
 
                /* The packet type */
                PacketType getType() override { return PacketType::AWS_MQTT5_PT_UNSUBACK; };
 
                const Crt::Optional<Crt::String> &getReasonString() const noexcept;
 
                const Crt::Vector<UserProperty> &getUserProperties() const noexcept;
 
                const Crt::Vector<UnSubAckReasonCode> &getReasonCodes() const noexcept;
 
                virtual ~UnSubAckPacket() { m_userProperties.clear(); };
                UnSubAckPacket(const UnSubAckPacket &) noexcept = delete;
                UnSubAckPacket(UnSubAckPacket &&) noexcept = delete;
                UnSubAckPacket &operator=(const UnSubAckPacket &) noexcept = delete;
                UnSubAckPacket &operator=(UnSubAckPacket &&) noexcept = delete;
 
              private:
                Crt::Optional<Crt::String> m_reasonString;
 
                Crt::Vector<UserProperty> m_userProperties;
 
                Crt::Vector<UnSubAckReasonCode> m_reasonCodes;
            };
 
        } // namespace Mqtt5
    } // namespace Crt
} // namespace Aws