HttpAction.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/iot/IoT_EXPORTS.h>
#include <aws/iot/model/BatchConfig.h>
#include <aws/iot/model/HttpActionHeader.h>
#include <aws/iot/model/HttpAuthorization.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace IoT {
namespace Model {
 
class HttpAction {
 public:
  AWS_IOT_API HttpAction() = default;
  AWS_IOT_API HttpAction(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API HttpAction& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetUrl() const { return m_url; }
  inline bool UrlHasBeenSet() const { return m_urlHasBeenSet; }
  template <typename UrlT = Aws::String>
  void SetUrl(UrlT&& value) {
    m_urlHasBeenSet = true;
    m_url = std::forward<UrlT>(value);
  }
  template <typename UrlT = Aws::String>
  HttpAction& WithUrl(UrlT&& value) {
    SetUrl(std::forward<UrlT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConfirmationUrl() const { return m_confirmationUrl; }
  inline bool ConfirmationUrlHasBeenSet() const { return m_confirmationUrlHasBeenSet; }
  template <typename ConfirmationUrlT = Aws::String>
  void SetConfirmationUrl(ConfirmationUrlT&& value) {
    m_confirmationUrlHasBeenSet = true;
    m_confirmationUrl = std::forward<ConfirmationUrlT>(value);
  }
  template <typename ConfirmationUrlT = Aws::String>
  HttpAction& WithConfirmationUrl(ConfirmationUrlT&& value) {
    SetConfirmationUrl(std::forward<ConfirmationUrlT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<HttpActionHeader>& GetHeaders() const { return m_headers; }
  inline bool HeadersHasBeenSet() const { return m_headersHasBeenSet; }
  template <typename HeadersT = Aws::Vector<HttpActionHeader>>
  void SetHeaders(HeadersT&& value) {
    m_headersHasBeenSet = true;
    m_headers = std::forward<HeadersT>(value);
  }
  template <typename HeadersT = Aws::Vector<HttpActionHeader>>
  HttpAction& WithHeaders(HeadersT&& value) {
    SetHeaders(std::forward<HeadersT>(value));
    return *this;
  }
  template <typename HeadersT = HttpActionHeader>
  HttpAction& AddHeaders(HeadersT&& value) {
    m_headersHasBeenSet = true;
    m_headers.emplace_back(std::forward<HeadersT>(value));
    return *this;
  }
 
 
  inline const HttpAuthorization& GetAuth() const { return m_auth; }
  inline bool AuthHasBeenSet() const { return m_authHasBeenSet; }
  template <typename AuthT = HttpAuthorization>
  void SetAuth(AuthT&& value) {
    m_authHasBeenSet = true;
    m_auth = std::forward<AuthT>(value);
  }
  template <typename AuthT = HttpAuthorization>
  HttpAction& WithAuth(AuthT&& value) {
    SetAuth(std::forward<AuthT>(value));
    return *this;
  }
 
 
  inline bool GetEnableBatching() const { return m_enableBatching; }
  inline bool EnableBatchingHasBeenSet() const { return m_enableBatchingHasBeenSet; }
  inline void SetEnableBatching(bool value) {
    m_enableBatchingHasBeenSet = true;
    m_enableBatching = value;
  }
  inline HttpAction& WithEnableBatching(bool value) {
    SetEnableBatching(value);
    return *this;
  }
 
 
  inline const BatchConfig& GetBatchConfig() const { return m_batchConfig; }
  inline bool BatchConfigHasBeenSet() const { return m_batchConfigHasBeenSet; }
  template <typename BatchConfigT = BatchConfig>
  void SetBatchConfig(BatchConfigT&& value) {
    m_batchConfigHasBeenSet = true;
    m_batchConfig = std::forward<BatchConfigT>(value);
  }
  template <typename BatchConfigT = BatchConfig>
  HttpAction& WithBatchConfig(BatchConfigT&& value) {
    SetBatchConfig(std::forward<BatchConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_url;
 
  Aws::String m_confirmationUrl;
 
  Aws::Vector<HttpActionHeader> m_headers;
 
  HttpAuthorization m_auth;
 
  bool m_enableBatching{false};
 
  BatchConfig m_batchConfig;
  bool m_urlHasBeenSet = false;
  bool m_confirmationUrlHasBeenSet = false;
  bool m_headersHasBeenSet = false;
  bool m_authHasBeenSet = false;
  bool m_enableBatchingHasBeenSet = false;
  bool m_batchConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IoT
}  // namespace Aws