SQSQueue.h

 
#pragma once
 
#include <aws/queues/Queue.h>
#include <aws/sqs/model/Message.h>
#include <aws/queues/Queues_EXPORTS.h>
#include <memory>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/sqs/SQSClient.h>
 
namespace Aws
{
    namespace SQS
    {
        namespace Model
        {
            class DeleteMessageRequest;
            class SendMessageRequest;
        }
    }
 
    namespace Queues
    {
        namespace Sqs
        {
            class AWS_QUEUES_API SQSQueue : public Queue<Aws::SQS::Model::Message>
            {
 
                typedef std::function<void(const SQSQueue*, const Aws::SQS::Model::GetQueueAttributesOutcome&)> QueueAttributeSuccessEventHandler;
                typedef std::function<void(const SQSQueue*, const Aws::SQS::Model::GetQueueAttributesRequest&)> QueueAttributeFailedEventHandler;
                typedef std::function<void(const SQSQueue*, const Aws::SQS::Model::GetQueueAttributesRequest&)> QueueArnFailedEventHandler;
                typedef std::function<void(const SQSQueue*, const Aws::String&)> QueueArnSuccessEventHandler;
 
            public:
 
                inline void SetQueueArnSuccessEventHandler(const QueueArnSuccessEventHandler& messageHandler) { m_queueArnSuccessHandler = messageHandler; }
                inline void SetQueueArnSuccessEventHandler(QueueArnSuccessEventHandler&& messageHandler) { m_queueArnSuccessHandler = messageHandler; }
 
                inline void SetQueueArnFailedEventHandler(const QueueArnFailedEventHandler& messageHandler) { m_queueArnFailedHandler = messageHandler; }
                inline void SetQueueArnFailedEventHandler(QueueArnFailedEventHandler&& messageHandler) { m_queueArnFailedHandler = messageHandler; }
 
                inline void SetQueueAttributeSuccessEventHandler(const QueueAttributeSuccessEventHandler& messageHandler) { m_queueAttributeSuccessHandler = messageHandler; }
                inline void SetQueueAttributeSuccessEventHandler(QueueAttributeSuccessEventHandler&& messageHandler) { m_queueAttributeSuccessHandler = messageHandler; }
 
                inline void SetQueueAttributeFailedEventHandler(const QueueAttributeFailedEventHandler& messageHandler) { m_queueAttributeFailedHandler = messageHandler; }
                inline void SetQueueAttributeFailedEventHandler(QueueAttributeFailedEventHandler&& messageHandler) { m_queueAttributeFailedHandler = messageHandler; }
 
                inline const QueueArnSuccessEventHandler& GetQueueArnSuccessEventHandler() const { return m_queueArnSuccessHandler; }
                inline const QueueArnFailedEventHandler& GetQueueArnFailedEventHandler() const { return m_queueArnFailedHandler; }
 
                inline const QueueAttributeSuccessEventHandler& GetQueueAttributeSuccessEventHandler() const { return m_queueAttributeSuccessHandler; }
                inline const QueueAttributeFailedEventHandler& GetQueueAttributeFailedEventHandler() const { return m_queueAttributeFailedHandler; }
 
 
                SQSQueue(const std::shared_ptr<SQS::SQSClient>& client, const char* queueName, unsigned visibilityTimeout, unsigned pollingFrequencyMs = 10000);
 
                Aws::SQS::Model::Message Top() const override;
 
                void Delete(const  Aws::SQS::Model::Message&) override;
 
                void Push(const  Aws::SQS::Model::Message&) override;
 
                void RequestArn();
 
                void EnsureQueueIsInitialized();
 
                inline bool IsInitialized() const { return !m_queueUrl.empty(); }
                inline const Aws::String& GetQueueUrl() const { return m_queueUrl; }
 
            private:
                std::shared_ptr<SQS::SQSClient> m_client;
                Aws::String m_queueUrl;
                Aws::String m_queueName;
                unsigned m_visibilityTimeout;
 
                void OnMessageDeletedOutcomeReceived(const SQS::SQSClient*, const SQS::Model::DeleteMessageRequest&,
                                                     const SQS::Model::DeleteMessageOutcome& deleteMessageOutcome, const std::shared_ptr<const Client::AsyncCallerContext>&);
 
                void OnMessageSentOutcomeReceived(const SQS::SQSClient*, const SQS::Model::SendMessageRequest&,
                          const SQS::Model::SendMessageOutcome& deleteMessageOutcome, const std::shared_ptr<const Client::AsyncCallerContext>&);
 
                void OnGetQueueAttributesOutcomeReceived(const SQS::SQSClient*, const SQS::Model::GetQueueAttributesRequest&,
                             const SQS::Model::GetQueueAttributesOutcome& deleteMessageOutcome, const std::shared_ptr<const Client::AsyncCallerContext>&);
 
                QueueArnSuccessEventHandler m_queueArnSuccessHandler;
                QueueArnFailedEventHandler m_queueArnFailedHandler;
                QueueAttributeSuccessEventHandler m_queueAttributeSuccessHandler;
                QueueAttributeFailedEventHandler m_queueAttributeFailedHandler;
 
            };
        }
    }
}