ProgressEvent.h

 
#pragma once
#include <aws/cloudcontrol/CloudControlApi_EXPORTS.h>
#include <aws/cloudcontrol/model/HandlerErrorCode.h>
#include <aws/cloudcontrol/model/Operation.h>
#include <aws/cloudcontrol/model/OperationStatus.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CloudControlApi {
namespace Model {
 
class ProgressEvent {
 public:
  AWS_CLOUDCONTROLAPI_API ProgressEvent() = default;
  AWS_CLOUDCONTROLAPI_API ProgressEvent(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDCONTROLAPI_API ProgressEvent& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLOUDCONTROLAPI_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetTypeName() const { return m_typeName; }
  inline bool TypeNameHasBeenSet() const { return m_typeNameHasBeenSet; }
  template <typename TypeNameT = Aws::String>
  void SetTypeName(TypeNameT&& value) {
    m_typeNameHasBeenSet = true;
    m_typeName = std::forward<TypeNameT>(value);
  }
  template <typename TypeNameT = Aws::String>
  ProgressEvent& WithTypeName(TypeNameT&& value) {
    SetTypeName(std::forward<TypeNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIdentifier() const { return m_identifier; }
  inline bool IdentifierHasBeenSet() const { return m_identifierHasBeenSet; }
  template <typename IdentifierT = Aws::String>
  void SetIdentifier(IdentifierT&& value) {
    m_identifierHasBeenSet = true;
    m_identifier = std::forward<IdentifierT>(value);
  }
  template <typename IdentifierT = Aws::String>
  ProgressEvent& WithIdentifier(IdentifierT&& value) {
    SetIdentifier(std::forward<IdentifierT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestToken() const { return m_requestToken; }
  inline bool RequestTokenHasBeenSet() const { return m_requestTokenHasBeenSet; }
  template <typename RequestTokenT = Aws::String>
  void SetRequestToken(RequestTokenT&& value) {
    m_requestTokenHasBeenSet = true;
    m_requestToken = std::forward<RequestTokenT>(value);
  }
  template <typename RequestTokenT = Aws::String>
  ProgressEvent& WithRequestToken(RequestTokenT&& value) {
    SetRequestToken(std::forward<RequestTokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHooksRequestToken() const { return m_hooksRequestToken; }
  inline bool HooksRequestTokenHasBeenSet() const { return m_hooksRequestTokenHasBeenSet; }
  template <typename HooksRequestTokenT = Aws::String>
  void SetHooksRequestToken(HooksRequestTokenT&& value) {
    m_hooksRequestTokenHasBeenSet = true;
    m_hooksRequestToken = std::forward<HooksRequestTokenT>(value);
  }
  template <typename HooksRequestTokenT = Aws::String>
  ProgressEvent& WithHooksRequestToken(HooksRequestTokenT&& value) {
    SetHooksRequestToken(std::forward<HooksRequestTokenT>(value));
    return *this;
  }
 
 
  inline Operation GetOperation() const { return m_operation; }
  inline bool OperationHasBeenSet() const { return m_operationHasBeenSet; }
  inline void SetOperation(Operation value) {
    m_operationHasBeenSet = true;
    m_operation = value;
  }
  inline ProgressEvent& WithOperation(Operation value) {
    SetOperation(value);
    return *this;
  }
 
 
  inline OperationStatus GetOperationStatus() const { return m_operationStatus; }
  inline bool OperationStatusHasBeenSet() const { return m_operationStatusHasBeenSet; }
  inline void SetOperationStatus(OperationStatus value) {
    m_operationStatusHasBeenSet = true;
    m_operationStatus = value;
  }
  inline ProgressEvent& WithOperationStatus(OperationStatus value) {
    SetOperationStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEventTime() const { return m_eventTime; }
  inline bool EventTimeHasBeenSet() const { return m_eventTimeHasBeenSet; }
  template <typename EventTimeT = Aws::Utils::DateTime>
  void SetEventTime(EventTimeT&& value) {
    m_eventTimeHasBeenSet = true;
    m_eventTime = std::forward<EventTimeT>(value);
  }
  template <typename EventTimeT = Aws::Utils::DateTime>
  ProgressEvent& WithEventTime(EventTimeT&& value) {
    SetEventTime(std::forward<EventTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceModel() const { return m_resourceModel; }
  inline bool ResourceModelHasBeenSet() const { return m_resourceModelHasBeenSet; }
  template <typename ResourceModelT = Aws::String>
  void SetResourceModel(ResourceModelT&& value) {
    m_resourceModelHasBeenSet = true;
    m_resourceModel = std::forward<ResourceModelT>(value);
  }
  template <typename ResourceModelT = Aws::String>
  ProgressEvent& WithResourceModel(ResourceModelT&& value) {
    SetResourceModel(std::forward<ResourceModelT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStatusMessage() const { return m_statusMessage; }
  inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
  template <typename StatusMessageT = Aws::String>
  void SetStatusMessage(StatusMessageT&& value) {
    m_statusMessageHasBeenSet = true;
    m_statusMessage = std::forward<StatusMessageT>(value);
  }
  template <typename StatusMessageT = Aws::String>
  ProgressEvent& WithStatusMessage(StatusMessageT&& value) {
    SetStatusMessage(std::forward<StatusMessageT>(value));
    return *this;
  }
 
 
  inline HandlerErrorCode GetErrorCode() const { return m_errorCode; }
  inline bool ErrorCodeHasBeenSet() const { return m_errorCodeHasBeenSet; }
  inline void SetErrorCode(HandlerErrorCode value) {
    m_errorCodeHasBeenSet = true;
    m_errorCode = value;
  }
  inline ProgressEvent& WithErrorCode(HandlerErrorCode value) {
    SetErrorCode(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetRetryAfter() const { return m_retryAfter; }
  inline bool RetryAfterHasBeenSet() const { return m_retryAfterHasBeenSet; }
  template <typename RetryAfterT = Aws::Utils::DateTime>
  void SetRetryAfter(RetryAfterT&& value) {
    m_retryAfterHasBeenSet = true;
    m_retryAfter = std::forward<RetryAfterT>(value);
  }
  template <typename RetryAfterT = Aws::Utils::DateTime>
  ProgressEvent& WithRetryAfter(RetryAfterT&& value) {
    SetRetryAfter(std::forward<RetryAfterT>(value));
    return *this;
  }
 private:
  Aws::String m_typeName;
 
  Aws::String m_identifier;
 
  Aws::String m_requestToken;
 
  Aws::String m_hooksRequestToken;
 
  Operation m_operation{Operation::NOT_SET};
 
  OperationStatus m_operationStatus{OperationStatus::NOT_SET};
 
  Aws::Utils::DateTime m_eventTime{};
 
  Aws::String m_resourceModel;
 
  Aws::String m_statusMessage;
 
  HandlerErrorCode m_errorCode{HandlerErrorCode::NOT_SET};
 
  Aws::Utils::DateTime m_retryAfter{};
  bool m_typeNameHasBeenSet = false;
  bool m_identifierHasBeenSet = false;
  bool m_requestTokenHasBeenSet = false;
  bool m_hooksRequestTokenHasBeenSet = false;
  bool m_operationHasBeenSet = false;
  bool m_operationStatusHasBeenSet = false;
  bool m_eventTimeHasBeenSet = false;
  bool m_resourceModelHasBeenSet = false;
  bool m_statusMessageHasBeenSet = false;
  bool m_errorCodeHasBeenSet = false;
  bool m_retryAfterHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudControlApi
}  // namespace Aws