MqttRequestResponseClient.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/Exports.h>
 
#include <aws/crt/Allocator.h>
#include <aws/crt/Optional.h>
#include <aws/crt/Types.h>
#include <aws/crt/Variant.h>
#include <aws/crt/mqtt/Mqtt5Packets.h>
#include <aws/mqtt/request-response/request_response_client.h>
 
#include <functional>
 
namespace Aws
{
 
    namespace Crt
    {
        namespace Mqtt
        {
            class MqttConnection;
        }
 
        namespace Mqtt5
        {
            class Mqtt5Client;
        }
    } // namespace Crt
 
    namespace Iot
    {
        namespace RequestResponse
        {
            enum class SubscriptionStatusEventType
            {
 
                SubscriptionEstablished = ARRSSET_SUBSCRIPTION_ESTABLISHED,
 
                SubscriptionLost = ARRSSET_SUBSCRIPTION_LOST,
 
                SubscriptionHalted = ARRSSET_SUBSCRIPTION_HALTED,
            };
 
            class AWS_CRT_CPP_API SubscriptionStatusEvent
            {
              public:
                SubscriptionStatusEvent &WithType(SubscriptionStatusEventType type)
                {
                    m_type = type;
                    return *this;
                }
 
                SubscriptionStatusEvent &WithErrorCode(int errorCode)
                {
                    m_errorCode = errorCode;
                    return *this;
                }
 
                SubscriptionStatusEventType GetType() const { return m_type; }
 
                int GetErrorCode() const { return m_errorCode; }
 
              private:
                SubscriptionStatusEventType m_type = SubscriptionStatusEventType::SubscriptionEstablished;
                int m_errorCode = 0;
            };
 
            using SubscriptionStatusEventHandler = std::function<void(SubscriptionStatusEvent &&)>;
 
            struct AWS_CRT_CPP_API UserPropertyView
            {
                UserPropertyView(Aws::Crt::ByteCursor name, Aws::Crt::ByteCursor value) : m_name(name), m_value(value)
                {
                }
                Aws::Crt::ByteCursor m_name;
                Aws::Crt::ByteCursor m_value;
            };
 
            class AWS_CRT_CPP_API IncomingPublishEvent
            {
              public:
                IncomingPublishEvent() : m_topic(), m_payload()
                {
                    AWS_ZERO_STRUCT(m_topic);
                    AWS_ZERO_STRUCT(m_payload);
                }
 
                IncomingPublishEvent &WithTopic(Aws::Crt::ByteCursor topic)
                {
                    m_topic = topic;
                    return *this;
                }
 
                IncomingPublishEvent &WithPayload(Aws::Crt::ByteCursor payload)
                {
                    m_payload = payload;
                    return *this;
                }
 
                IncomingPublishEvent &WithContentType(Aws::Crt::ByteCursor contentType)
                {
                    m_contentType = contentType;
                    return *this;
                }
 
                IncomingPublishEvent &WithUserProperties(Aws::Crt::Vector<UserPropertyView> userProperties)
                {
                    m_userProperties = std::move(userProperties);
                    return *this;
                }
 
                IncomingPublishEvent &WithMessageExpiryIntervalSeconds(uint32_t messageExpiryIntervalSeconds)
                {
                    m_messageExpiryIntervalSeconds = messageExpiryIntervalSeconds;
                    return *this;
                }
 
                Aws::Crt::ByteCursor GetTopic() const { return m_topic; }
 
                Aws::Crt::ByteCursor GetPayload() const { return m_payload; }
 
                const Aws::Crt::Optional<Aws::Crt::ByteCursor> &GetContentType() const { return m_contentType; }
 
                const Aws::Crt::Optional<Aws::Crt::Vector<UserPropertyView>> &GetUserProperties() const
                {
                    return m_userProperties;
                }
 
                const Aws::Crt::Optional<uint32_t> &GetMessageExpiryIntervalSeconds() const
                {
                    return m_messageExpiryIntervalSeconds;
                }
 
              private:
                Aws::Crt::ByteCursor m_topic;
                Aws::Crt::ByteCursor m_payload;
                Aws::Crt::Optional<Aws::Crt::ByteCursor> m_contentType;
                Aws::Crt::Optional<Aws::Crt::Vector<UserPropertyView>> m_userProperties;
                Aws::Crt::Optional<uint32_t> m_messageExpiryIntervalSeconds;
            };
 
            using IncomingPublishEventHandler = std::function<void(IncomingPublishEvent &&)>;
 
            class AWS_CRT_CPP_API UnmodeledResponse
            {
              public:
                UnmodeledResponse() : m_topic(), m_payload()
                {
                    AWS_ZERO_STRUCT(m_payload);
                    AWS_ZERO_STRUCT(m_topic);
                }
 
                UnmodeledResponse &WithPayload(Aws::Crt::ByteCursor payload)
                {
                    m_payload = payload;
                    return *this;
                }
 
                UnmodeledResponse &WithTopic(Aws::Crt::ByteCursor topic)
                {
                    m_topic = topic;
                    return *this;
                }
 
                Aws::Crt::ByteCursor GetPayload() const { return m_payload; }
 
                Aws::Crt::ByteCursor GetTopic() const { return m_topic; }
 
              private:
                Aws::Crt::ByteCursor m_topic;
 
                Aws::Crt::ByteCursor m_payload;
            };
 
            template <typename R, typename E> class Result
            {
              public:
                Result() = delete;
 
                explicit Result(const R &response) : m_rawResult(response) {}
                explicit Result(R &&response) : m_rawResult(std::move(response)) {}
                explicit Result(const E &error) : m_rawResult(error) {}
                explicit Result(E &&error) : m_rawResult(std::move(error)) {}
 
                Result &operator=(const R &response)
                {
                    this->m_rawResult = response;
 
                    return *this;
                }
 
                Result &operator=(R &&response)
                {
                    this->m_rawResult = std::move(response);
 
                    return *this;
                }
 
                Result &operator=(const E &error)
                {
                    this->m_rawResult = error;
                    return *this;
                }
 
                Result &operator=(E &&error)
                {
                    this->m_rawResult = std::move(error);
 
                    return *this;
                }
 
                bool IsSuccess() const { return m_rawResult.template holds_alternative<R>(); }
 
                const R &GetResponse() const
                {
                    AWS_FATAL_ASSERT(IsSuccess());
 
                    return m_rawResult.template get<R>();
                }
 
                const E &GetError() const
                {
                    AWS_FATAL_ASSERT(!IsSuccess());
 
                    return m_rawResult.template get<E>();
                }
 
              private:
                Aws::Crt::Variant<R, E> m_rawResult;
            };
 
            using UnmodeledResult = Result<UnmodeledResponse, int>;
 
            using UnmodeledResultHandler = std::function<void(UnmodeledResult &&)>;
 
            template <typename T> class StreamingOperationOptions
            {
              public:
                StreamingOperationOptions &WithSubscriptionStatusEventHandler(
                    const SubscriptionStatusEventHandler &handler)
                {
                    m_subscriptionStatusEventHandler = handler;
                    return *this;
                }
 
                StreamingOperationOptions &WithStreamHandler(const std::function<void(T &&)> &handler)
                {
                    m_streamHandler = handler;
                    return *this;
                }
 
                const SubscriptionStatusEventHandler &GetSubscriptionStatusEventHandler() const
                {
                    return m_subscriptionStatusEventHandler;
                }
 
                const std::function<void(T &&)> &GetStreamHandler() const { return m_streamHandler; }
 
              private:
                SubscriptionStatusEventHandler m_subscriptionStatusEventHandler;
 
                std::function<void(T &&)> m_streamHandler;
            };
 
            struct AWS_CRT_CPP_API StreamingOperationOptionsInternal
            {
              public:
                StreamingOperationOptionsInternal()
                    : subscriptionTopicFilter(), subscriptionStatusEventHandler(), incomingPublishEventHandler()
                {
                    AWS_ZERO_STRUCT(subscriptionTopicFilter);
                }
 
                Aws::Crt::ByteCursor subscriptionTopicFilter;
 
                SubscriptionStatusEventHandler subscriptionStatusEventHandler;
 
                IncomingPublishEventHandler incomingPublishEventHandler;
            };
 
            class AWS_CRT_CPP_API IStreamingOperation
            {
              public:
                virtual ~IStreamingOperation() = default;
 
                virtual void Open() = 0;
            };
 
            class AWS_CRT_CPP_API RequestResponseClientOptions
            {
              public:
                RequestResponseClientOptions &WithMaxRequestResponseSubscriptions(
                    uint32_t maxRequestResponseSubscriptions)
                {
                    m_maxRequestResponseSubscriptions = maxRequestResponseSubscriptions;
                    return *this;
                }
 
                RequestResponseClientOptions &WithMaxStreamingSubscriptions(uint32_t maxStreamingSubscriptions)
                {
                    m_maxStreamingSubscriptions = maxStreamingSubscriptions;
                    return *this;
                }
 
                RequestResponseClientOptions &WithOperationTimeoutInSeconds(uint32_t operationTimeoutInSeconds)
                {
                    m_operationTimeoutInSeconds = operationTimeoutInSeconds;
                    return *this;
                }
 
                uint32_t GetMaxRequestResponseSubscriptions() const { return m_maxRequestResponseSubscriptions; }
 
                uint32_t GetMaxStreamingSubscriptions() const { return m_maxStreamingSubscriptions; }
 
                uint32_t GetOperationTimeoutInSeconds() const { return m_operationTimeoutInSeconds; }
 
              private:
                uint32_t m_maxRequestResponseSubscriptions = 0;
 
                uint32_t m_maxStreamingSubscriptions = 0;
 
                uint32_t m_operationTimeoutInSeconds = 0;
            };
 
            class AWS_CRT_CPP_API IMqttRequestResponseClient
            {
              public:
                virtual ~IMqttRequestResponseClient() = default;
 
                virtual int SubmitRequest(
                    const aws_mqtt_request_operation_options &requestOptions,
                    UnmodeledResultHandler &&resultHandler) = 0;
 
                virtual std::shared_ptr<IStreamingOperation> CreateStream(
                    const StreamingOperationOptionsInternal &options) = 0;
            };
 
            AWS_CRT_CPP_API std::shared_ptr<IMqttRequestResponseClient> NewClientFrom5(
                const Aws::Crt::Mqtt5::Mqtt5Client &protocolClient,
                const RequestResponseClientOptions &options,
                Aws::Crt::Allocator *allocator = Aws::Crt::ApiAllocator());
 
            AWS_CRT_CPP_API std::shared_ptr<IMqttRequestResponseClient> NewClientFrom311(
                const Aws::Crt::Mqtt::MqttConnection &protocolClient,
                const RequestResponseClientOptions &options,
                Aws::Crt::Allocator *allocator = Aws::Crt::ApiAllocator());
 
        } // namespace RequestResponse
    } // namespace Iot
} // namespace Aws