SendMessageRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/sqs/SQSRequest.h>
#include <aws/sqs/SQS_EXPORTS.h>
#include <aws/sqs/model/MessageAttributeValue.h>
#include <aws/sqs/model/MessageSystemAttributeNameForSends.h>
#include <aws/sqs/model/MessageSystemAttributeValue.h>
 
#include <utility>
 
namespace Aws {
namespace SQS {
namespace Model {
 
class SendMessageRequest : public SQSRequest {
 public:
  AWS_SQS_API SendMessageRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "SendMessage"; }
 
  AWS_SQS_API Aws::String SerializePayload() const override;
 
  AWS_SQS_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetQueueUrl() const { return m_queueUrl; }
  inline bool QueueUrlHasBeenSet() const { return m_queueUrlHasBeenSet; }
  template <typename QueueUrlT = Aws::String>
  void SetQueueUrl(QueueUrlT&& value) {
    m_queueUrlHasBeenSet = true;
    m_queueUrl = std::forward<QueueUrlT>(value);
  }
  template <typename QueueUrlT = Aws::String>
  SendMessageRequest& WithQueueUrl(QueueUrlT&& value) {
    SetQueueUrl(std::forward<QueueUrlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMessageBody() const { return m_messageBody; }
  inline bool MessageBodyHasBeenSet() const { return m_messageBodyHasBeenSet; }
  template <typename MessageBodyT = Aws::String>
  void SetMessageBody(MessageBodyT&& value) {
    m_messageBodyHasBeenSet = true;
    m_messageBody = std::forward<MessageBodyT>(value);
  }
  template <typename MessageBodyT = Aws::String>
  SendMessageRequest& WithMessageBody(MessageBodyT&& value) {
    SetMessageBody(std::forward<MessageBodyT>(value));
    return *this;
  }
 
 
  inline int GetDelaySeconds() const { return m_delaySeconds; }
  inline bool DelaySecondsHasBeenSet() const { return m_delaySecondsHasBeenSet; }
  inline void SetDelaySeconds(int value) {
    m_delaySecondsHasBeenSet = true;
    m_delaySeconds = value;
  }
  inline SendMessageRequest& WithDelaySeconds(int value) {
    SetDelaySeconds(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, MessageAttributeValue>& GetMessageAttributes() const { return m_messageAttributes; }
  inline bool MessageAttributesHasBeenSet() const { return m_messageAttributesHasBeenSet; }
  template <typename MessageAttributesT = Aws::Map<Aws::String, MessageAttributeValue>>
  void SetMessageAttributes(MessageAttributesT&& value) {
    m_messageAttributesHasBeenSet = true;
    m_messageAttributes = std::forward<MessageAttributesT>(value);
  }
  template <typename MessageAttributesT = Aws::Map<Aws::String, MessageAttributeValue>>
  SendMessageRequest& WithMessageAttributes(MessageAttributesT&& value) {
    SetMessageAttributes(std::forward<MessageAttributesT>(value));
    return *this;
  }
  template <typename MessageAttributesKeyT = Aws::String, typename MessageAttributesValueT = MessageAttributeValue>
  SendMessageRequest& AddMessageAttributes(MessageAttributesKeyT&& key, MessageAttributesValueT&& value) {
    m_messageAttributesHasBeenSet = true;
    m_messageAttributes.emplace(std::forward<MessageAttributesKeyT>(key), std::forward<MessageAttributesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<MessageSystemAttributeNameForSends, MessageSystemAttributeValue>& GetMessageSystemAttributes() const {
    return m_messageSystemAttributes;
  }
  inline bool MessageSystemAttributesHasBeenSet() const { return m_messageSystemAttributesHasBeenSet; }
  template <typename MessageSystemAttributesT = Aws::Map<MessageSystemAttributeNameForSends, MessageSystemAttributeValue>>
  void SetMessageSystemAttributes(MessageSystemAttributesT&& value) {
    m_messageSystemAttributesHasBeenSet = true;
    m_messageSystemAttributes = std::forward<MessageSystemAttributesT>(value);
  }
  template <typename MessageSystemAttributesT = Aws::Map<MessageSystemAttributeNameForSends, MessageSystemAttributeValue>>
  SendMessageRequest& WithMessageSystemAttributes(MessageSystemAttributesT&& value) {
    SetMessageSystemAttributes(std::forward<MessageSystemAttributesT>(value));
    return *this;
  }
  inline SendMessageRequest& AddMessageSystemAttributes(MessageSystemAttributeNameForSends key, MessageSystemAttributeValue value) {
    m_messageSystemAttributesHasBeenSet = true;
    m_messageSystemAttributes.emplace(key, value);
    return *this;
  }
 
 
  inline const Aws::String& GetMessageDeduplicationId() const { return m_messageDeduplicationId; }
  inline bool MessageDeduplicationIdHasBeenSet() const { return m_messageDeduplicationIdHasBeenSet; }
  template <typename MessageDeduplicationIdT = Aws::String>
  void SetMessageDeduplicationId(MessageDeduplicationIdT&& value) {
    m_messageDeduplicationIdHasBeenSet = true;
    m_messageDeduplicationId = std::forward<MessageDeduplicationIdT>(value);
  }
  template <typename MessageDeduplicationIdT = Aws::String>
  SendMessageRequest& WithMessageDeduplicationId(MessageDeduplicationIdT&& value) {
    SetMessageDeduplicationId(std::forward<MessageDeduplicationIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMessageGroupId() const { return m_messageGroupId; }
  inline bool MessageGroupIdHasBeenSet() const { return m_messageGroupIdHasBeenSet; }
  template <typename MessageGroupIdT = Aws::String>
  void SetMessageGroupId(MessageGroupIdT&& value) {
    m_messageGroupIdHasBeenSet = true;
    m_messageGroupId = std::forward<MessageGroupIdT>(value);
  }
  template <typename MessageGroupIdT = Aws::String>
  SendMessageRequest& WithMessageGroupId(MessageGroupIdT&& value) {
    SetMessageGroupId(std::forward<MessageGroupIdT>(value));
    return *this;
  }
 private:
  Aws::String m_queueUrl;
 
  Aws::String m_messageBody;
 
  int m_delaySeconds{0};
 
  Aws::Map<Aws::String, MessageAttributeValue> m_messageAttributes;
 
  Aws::Map<MessageSystemAttributeNameForSends, MessageSystemAttributeValue> m_messageSystemAttributes;
 
  Aws::String m_messageDeduplicationId;
 
  Aws::String m_messageGroupId;
  bool m_queueUrlHasBeenSet = false;
  bool m_messageBodyHasBeenSet = false;
  bool m_delaySecondsHasBeenSet = false;
  bool m_messageAttributesHasBeenSet = false;
  bool m_messageSystemAttributesHasBeenSet = false;
  bool m_messageDeduplicationIdHasBeenSet = false;
  bool m_messageGroupIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SQS
}  // namespace Aws