ReceiveMessageRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sqs/SQSRequest.h>
#include <aws/sqs/SQS_EXPORTS.h>
#include <aws/sqs/model/MessageSystemAttributeName.h>
 
#include <utility>
 
namespace Aws {
namespace SQS {
namespace Model {
 
class ReceiveMessageRequest : public SQSRequest {
 public:
  AWS_SQS_API ReceiveMessageRequest() = 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 "ReceiveMessage"; }
 
  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>
  ReceiveMessageRequest& WithQueueUrl(QueueUrlT&& value) {
    SetQueueUrl(std::forward<QueueUrlT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<MessageSystemAttributeName>& GetMessageSystemAttributeNames() const { return m_messageSystemAttributeNames; }
  inline bool MessageSystemAttributeNamesHasBeenSet() const { return m_messageSystemAttributeNamesHasBeenSet; }
  template <typename MessageSystemAttributeNamesT = Aws::Vector<MessageSystemAttributeName>>
  void SetMessageSystemAttributeNames(MessageSystemAttributeNamesT&& value) {
    m_messageSystemAttributeNamesHasBeenSet = true;
    m_messageSystemAttributeNames = std::forward<MessageSystemAttributeNamesT>(value);
  }
  template <typename MessageSystemAttributeNamesT = Aws::Vector<MessageSystemAttributeName>>
  ReceiveMessageRequest& WithMessageSystemAttributeNames(MessageSystemAttributeNamesT&& value) {
    SetMessageSystemAttributeNames(std::forward<MessageSystemAttributeNamesT>(value));
    return *this;
  }
  inline ReceiveMessageRequest& AddMessageSystemAttributeNames(MessageSystemAttributeName value) {
    m_messageSystemAttributeNamesHasBeenSet = true;
    m_messageSystemAttributeNames.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetMessageAttributeNames() const { return m_messageAttributeNames; }
  inline bool MessageAttributeNamesHasBeenSet() const { return m_messageAttributeNamesHasBeenSet; }
  template <typename MessageAttributeNamesT = Aws::Vector<Aws::String>>
  void SetMessageAttributeNames(MessageAttributeNamesT&& value) {
    m_messageAttributeNamesHasBeenSet = true;
    m_messageAttributeNames = std::forward<MessageAttributeNamesT>(value);
  }
  template <typename MessageAttributeNamesT = Aws::Vector<Aws::String>>
  ReceiveMessageRequest& WithMessageAttributeNames(MessageAttributeNamesT&& value) {
    SetMessageAttributeNames(std::forward<MessageAttributeNamesT>(value));
    return *this;
  }
  template <typename MessageAttributeNamesT = Aws::String>
  ReceiveMessageRequest& AddMessageAttributeNames(MessageAttributeNamesT&& value) {
    m_messageAttributeNamesHasBeenSet = true;
    m_messageAttributeNames.emplace_back(std::forward<MessageAttributeNamesT>(value));
    return *this;
  }
 
 
  inline int GetMaxNumberOfMessages() const { return m_maxNumberOfMessages; }
  inline bool MaxNumberOfMessagesHasBeenSet() const { return m_maxNumberOfMessagesHasBeenSet; }
  inline void SetMaxNumberOfMessages(int value) {
    m_maxNumberOfMessagesHasBeenSet = true;
    m_maxNumberOfMessages = value;
  }
  inline ReceiveMessageRequest& WithMaxNumberOfMessages(int value) {
    SetMaxNumberOfMessages(value);
    return *this;
  }
 
 
  inline int GetVisibilityTimeout() const { return m_visibilityTimeout; }
  inline bool VisibilityTimeoutHasBeenSet() const { return m_visibilityTimeoutHasBeenSet; }
  inline void SetVisibilityTimeout(int value) {
    m_visibilityTimeoutHasBeenSet = true;
    m_visibilityTimeout = value;
  }
  inline ReceiveMessageRequest& WithVisibilityTimeout(int value) {
    SetVisibilityTimeout(value);
    return *this;
  }
 
 
  inline int GetWaitTimeSeconds() const { return m_waitTimeSeconds; }
  inline bool WaitTimeSecondsHasBeenSet() const { return m_waitTimeSecondsHasBeenSet; }
  inline void SetWaitTimeSeconds(int value) {
    m_waitTimeSecondsHasBeenSet = true;
    m_waitTimeSeconds = value;
  }
  inline ReceiveMessageRequest& WithWaitTimeSeconds(int value) {
    SetWaitTimeSeconds(value);
    return *this;
  }
 
 
  inline const Aws::String& GetReceiveRequestAttemptId() const { return m_receiveRequestAttemptId; }
  inline bool ReceiveRequestAttemptIdHasBeenSet() const { return m_receiveRequestAttemptIdHasBeenSet; }
  template <typename ReceiveRequestAttemptIdT = Aws::String>
  void SetReceiveRequestAttemptId(ReceiveRequestAttemptIdT&& value) {
    m_receiveRequestAttemptIdHasBeenSet = true;
    m_receiveRequestAttemptId = std::forward<ReceiveRequestAttemptIdT>(value);
  }
  template <typename ReceiveRequestAttemptIdT = Aws::String>
  ReceiveMessageRequest& WithReceiveRequestAttemptId(ReceiveRequestAttemptIdT&& value) {
    SetReceiveRequestAttemptId(std::forward<ReceiveRequestAttemptIdT>(value));
    return *this;
  }
 private:
  Aws::String m_queueUrl;
 
  Aws::Vector<MessageSystemAttributeName> m_messageSystemAttributeNames;
 
  Aws::Vector<Aws::String> m_messageAttributeNames;
 
  int m_maxNumberOfMessages{0};
 
  int m_visibilityTimeout{0};
 
  int m_waitTimeSeconds{0};
 
  Aws::String m_receiveRequestAttemptId;
  bool m_queueUrlHasBeenSet = false;
  bool m_messageSystemAttributeNamesHasBeenSet = false;
  bool m_messageAttributeNamesHasBeenSet = false;
  bool m_maxNumberOfMessagesHasBeenSet = false;
  bool m_visibilityTimeoutHasBeenSet = false;
  bool m_waitTimeSecondsHasBeenSet = false;
  bool m_receiveRequestAttemptIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SQS
}  // namespace Aws