ActionExecution.h

 
#pragma once
#include <aws/codepipeline/CodePipeline_EXPORTS.h>
#include <aws/codepipeline/model/ActionExecutionStatus.h>
#include <aws/codepipeline/model/ErrorDetails.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 CodePipeline {
namespace Model {
 
class ActionExecution {
 public:
  AWS_CODEPIPELINE_API ActionExecution() = default;
  AWS_CODEPIPELINE_API ActionExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEPIPELINE_API ActionExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CODEPIPELINE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetActionExecutionId() const { return m_actionExecutionId; }
  inline bool ActionExecutionIdHasBeenSet() const { return m_actionExecutionIdHasBeenSet; }
  template <typename ActionExecutionIdT = Aws::String>
  void SetActionExecutionId(ActionExecutionIdT&& value) {
    m_actionExecutionIdHasBeenSet = true;
    m_actionExecutionId = std::forward<ActionExecutionIdT>(value);
  }
  template <typename ActionExecutionIdT = Aws::String>
  ActionExecution& WithActionExecutionId(ActionExecutionIdT&& value) {
    SetActionExecutionId(std::forward<ActionExecutionIdT>(value));
    return *this;
  }
 
 
  inline ActionExecutionStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ActionExecutionStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline ActionExecution& WithStatus(ActionExecutionStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSummary() const { return m_summary; }
  inline bool SummaryHasBeenSet() const { return m_summaryHasBeenSet; }
  template <typename SummaryT = Aws::String>
  void SetSummary(SummaryT&& value) {
    m_summaryHasBeenSet = true;
    m_summary = std::forward<SummaryT>(value);
  }
  template <typename SummaryT = Aws::String>
  ActionExecution& WithSummary(SummaryT&& value) {
    SetSummary(std::forward<SummaryT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastStatusChange() const { return m_lastStatusChange; }
  inline bool LastStatusChangeHasBeenSet() const { return m_lastStatusChangeHasBeenSet; }
  template <typename LastStatusChangeT = Aws::Utils::DateTime>
  void SetLastStatusChange(LastStatusChangeT&& value) {
    m_lastStatusChangeHasBeenSet = true;
    m_lastStatusChange = std::forward<LastStatusChangeT>(value);
  }
  template <typename LastStatusChangeT = Aws::Utils::DateTime>
  ActionExecution& WithLastStatusChange(LastStatusChangeT&& value) {
    SetLastStatusChange(std::forward<LastStatusChangeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetToken() const { return m_token; }
  inline bool TokenHasBeenSet() const { return m_tokenHasBeenSet; }
  template <typename TokenT = Aws::String>
  void SetToken(TokenT&& value) {
    m_tokenHasBeenSet = true;
    m_token = std::forward<TokenT>(value);
  }
  template <typename TokenT = Aws::String>
  ActionExecution& WithToken(TokenT&& value) {
    SetToken(std::forward<TokenT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastUpdatedBy() const { return m_lastUpdatedBy; }
  inline bool LastUpdatedByHasBeenSet() const { return m_lastUpdatedByHasBeenSet; }
  template <typename LastUpdatedByT = Aws::String>
  void SetLastUpdatedBy(LastUpdatedByT&& value) {
    m_lastUpdatedByHasBeenSet = true;
    m_lastUpdatedBy = std::forward<LastUpdatedByT>(value);
  }
  template <typename LastUpdatedByT = Aws::String>
  ActionExecution& WithLastUpdatedBy(LastUpdatedByT&& value) {
    SetLastUpdatedBy(std::forward<LastUpdatedByT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalExecutionId() const { return m_externalExecutionId; }
  inline bool ExternalExecutionIdHasBeenSet() const { return m_externalExecutionIdHasBeenSet; }
  template <typename ExternalExecutionIdT = Aws::String>
  void SetExternalExecutionId(ExternalExecutionIdT&& value) {
    m_externalExecutionIdHasBeenSet = true;
    m_externalExecutionId = std::forward<ExternalExecutionIdT>(value);
  }
  template <typename ExternalExecutionIdT = Aws::String>
  ActionExecution& WithExternalExecutionId(ExternalExecutionIdT&& value) {
    SetExternalExecutionId(std::forward<ExternalExecutionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalExecutionUrl() const { return m_externalExecutionUrl; }
  inline bool ExternalExecutionUrlHasBeenSet() const { return m_externalExecutionUrlHasBeenSet; }
  template <typename ExternalExecutionUrlT = Aws::String>
  void SetExternalExecutionUrl(ExternalExecutionUrlT&& value) {
    m_externalExecutionUrlHasBeenSet = true;
    m_externalExecutionUrl = std::forward<ExternalExecutionUrlT>(value);
  }
  template <typename ExternalExecutionUrlT = Aws::String>
  ActionExecution& WithExternalExecutionUrl(ExternalExecutionUrlT&& value) {
    SetExternalExecutionUrl(std::forward<ExternalExecutionUrlT>(value));
    return *this;
  }
 
 
  inline int GetPercentComplete() const { return m_percentComplete; }
  inline bool PercentCompleteHasBeenSet() const { return m_percentCompleteHasBeenSet; }
  inline void SetPercentComplete(int value) {
    m_percentCompleteHasBeenSet = true;
    m_percentComplete = value;
  }
  inline ActionExecution& WithPercentComplete(int value) {
    SetPercentComplete(value);
    return *this;
  }
 
 
  inline const ErrorDetails& GetErrorDetails() const { return m_errorDetails; }
  inline bool ErrorDetailsHasBeenSet() const { return m_errorDetailsHasBeenSet; }
  template <typename ErrorDetailsT = ErrorDetails>
  void SetErrorDetails(ErrorDetailsT&& value) {
    m_errorDetailsHasBeenSet = true;
    m_errorDetails = std::forward<ErrorDetailsT>(value);
  }
  template <typename ErrorDetailsT = ErrorDetails>
  ActionExecution& WithErrorDetails(ErrorDetailsT&& value) {
    SetErrorDetails(std::forward<ErrorDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLogStreamARN() const { return m_logStreamARN; }
  inline bool LogStreamARNHasBeenSet() const { return m_logStreamARNHasBeenSet; }
  template <typename LogStreamARNT = Aws::String>
  void SetLogStreamARN(LogStreamARNT&& value) {
    m_logStreamARNHasBeenSet = true;
    m_logStreamARN = std::forward<LogStreamARNT>(value);
  }
  template <typename LogStreamARNT = Aws::String>
  ActionExecution& WithLogStreamARN(LogStreamARNT&& value) {
    SetLogStreamARN(std::forward<LogStreamARNT>(value));
    return *this;
  }
 private:
  Aws::String m_actionExecutionId;
 
  ActionExecutionStatus m_status{ActionExecutionStatus::NOT_SET};
 
  Aws::String m_summary;
 
  Aws::Utils::DateTime m_lastStatusChange{};
 
  Aws::String m_token;
 
  Aws::String m_lastUpdatedBy;
 
  Aws::String m_externalExecutionId;
 
  Aws::String m_externalExecutionUrl;
 
  int m_percentComplete{0};
 
  ErrorDetails m_errorDetails;
 
  Aws::String m_logStreamARN;
  bool m_actionExecutionIdHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_summaryHasBeenSet = false;
  bool m_lastStatusChangeHasBeenSet = false;
  bool m_tokenHasBeenSet = false;
  bool m_lastUpdatedByHasBeenSet = false;
  bool m_externalExecutionIdHasBeenSet = false;
  bool m_externalExecutionUrlHasBeenSet = false;
  bool m_percentCompleteHasBeenSet = false;
  bool m_errorDetailsHasBeenSet = false;
  bool m_logStreamARNHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CodePipeline
}  // namespace Aws