PipelineExecution.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/ParallelismConfiguration.h>
#include <aws/sagemaker/model/Parameter.h>
#include <aws/sagemaker/model/PipelineExecutionStatus.h>
#include <aws/sagemaker/model/PipelineExperimentConfig.h>
#include <aws/sagemaker/model/SelectiveExecutionConfig.h>
#include <aws/sagemaker/model/UserContext.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class PipelineExecution {
 public:
  AWS_SAGEMAKER_API PipelineExecution() = default;
  AWS_SAGEMAKER_API PipelineExecution(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API PipelineExecution& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetPipelineArn() const { return m_pipelineArn; }
  inline bool PipelineArnHasBeenSet() const { return m_pipelineArnHasBeenSet; }
  template <typename PipelineArnT = Aws::String>
  void SetPipelineArn(PipelineArnT&& value) {
    m_pipelineArnHasBeenSet = true;
    m_pipelineArn = std::forward<PipelineArnT>(value);
  }
  template <typename PipelineArnT = Aws::String>
  PipelineExecution& WithPipelineArn(PipelineArnT&& value) {
    SetPipelineArn(std::forward<PipelineArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPipelineExecutionArn() const { return m_pipelineExecutionArn; }
  inline bool PipelineExecutionArnHasBeenSet() const { return m_pipelineExecutionArnHasBeenSet; }
  template <typename PipelineExecutionArnT = Aws::String>
  void SetPipelineExecutionArn(PipelineExecutionArnT&& value) {
    m_pipelineExecutionArnHasBeenSet = true;
    m_pipelineExecutionArn = std::forward<PipelineExecutionArnT>(value);
  }
  template <typename PipelineExecutionArnT = Aws::String>
  PipelineExecution& WithPipelineExecutionArn(PipelineExecutionArnT&& value) {
    SetPipelineExecutionArn(std::forward<PipelineExecutionArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPipelineExecutionDisplayName() const { return m_pipelineExecutionDisplayName; }
  inline bool PipelineExecutionDisplayNameHasBeenSet() const { return m_pipelineExecutionDisplayNameHasBeenSet; }
  template <typename PipelineExecutionDisplayNameT = Aws::String>
  void SetPipelineExecutionDisplayName(PipelineExecutionDisplayNameT&& value) {
    m_pipelineExecutionDisplayNameHasBeenSet = true;
    m_pipelineExecutionDisplayName = std::forward<PipelineExecutionDisplayNameT>(value);
  }
  template <typename PipelineExecutionDisplayNameT = Aws::String>
  PipelineExecution& WithPipelineExecutionDisplayName(PipelineExecutionDisplayNameT&& value) {
    SetPipelineExecutionDisplayName(std::forward<PipelineExecutionDisplayNameT>(value));
    return *this;
  }
 
 
  inline PipelineExecutionStatus GetPipelineExecutionStatus() const { return m_pipelineExecutionStatus; }
  inline bool PipelineExecutionStatusHasBeenSet() const { return m_pipelineExecutionStatusHasBeenSet; }
  inline void SetPipelineExecutionStatus(PipelineExecutionStatus value) {
    m_pipelineExecutionStatusHasBeenSet = true;
    m_pipelineExecutionStatus = value;
  }
  inline PipelineExecution& WithPipelineExecutionStatus(PipelineExecutionStatus value) {
    SetPipelineExecutionStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPipelineExecutionDescription() const { return m_pipelineExecutionDescription; }
  inline bool PipelineExecutionDescriptionHasBeenSet() const { return m_pipelineExecutionDescriptionHasBeenSet; }
  template <typename PipelineExecutionDescriptionT = Aws::String>
  void SetPipelineExecutionDescription(PipelineExecutionDescriptionT&& value) {
    m_pipelineExecutionDescriptionHasBeenSet = true;
    m_pipelineExecutionDescription = std::forward<PipelineExecutionDescriptionT>(value);
  }
  template <typename PipelineExecutionDescriptionT = Aws::String>
  PipelineExecution& WithPipelineExecutionDescription(PipelineExecutionDescriptionT&& value) {
    SetPipelineExecutionDescription(std::forward<PipelineExecutionDescriptionT>(value));
    return *this;
  }
 
 
  inline const PipelineExperimentConfig& GetPipelineExperimentConfig() const { return m_pipelineExperimentConfig; }
  inline bool PipelineExperimentConfigHasBeenSet() const { return m_pipelineExperimentConfigHasBeenSet; }
  template <typename PipelineExperimentConfigT = PipelineExperimentConfig>
  void SetPipelineExperimentConfig(PipelineExperimentConfigT&& value) {
    m_pipelineExperimentConfigHasBeenSet = true;
    m_pipelineExperimentConfig = std::forward<PipelineExperimentConfigT>(value);
  }
  template <typename PipelineExperimentConfigT = PipelineExperimentConfig>
  PipelineExecution& WithPipelineExperimentConfig(PipelineExperimentConfigT&& value) {
    SetPipelineExperimentConfig(std::forward<PipelineExperimentConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFailureReason() const { return m_failureReason; }
  inline bool FailureReasonHasBeenSet() const { return m_failureReasonHasBeenSet; }
  template <typename FailureReasonT = Aws::String>
  void SetFailureReason(FailureReasonT&& value) {
    m_failureReasonHasBeenSet = true;
    m_failureReason = std::forward<FailureReasonT>(value);
  }
  template <typename FailureReasonT = Aws::String>
  PipelineExecution& WithFailureReason(FailureReasonT&& value) {
    SetFailureReason(std::forward<FailureReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationTime() const { return m_creationTime; }
  inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  void SetCreationTime(CreationTimeT&& value) {
    m_creationTimeHasBeenSet = true;
    m_creationTime = std::forward<CreationTimeT>(value);
  }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  PipelineExecution& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModifiedTime() const { return m_lastModifiedTime; }
  inline bool LastModifiedTimeHasBeenSet() const { return m_lastModifiedTimeHasBeenSet; }
  template <typename LastModifiedTimeT = Aws::Utils::DateTime>
  void SetLastModifiedTime(LastModifiedTimeT&& value) {
    m_lastModifiedTimeHasBeenSet = true;
    m_lastModifiedTime = std::forward<LastModifiedTimeT>(value);
  }
  template <typename LastModifiedTimeT = Aws::Utils::DateTime>
  PipelineExecution& WithLastModifiedTime(LastModifiedTimeT&& value) {
    SetLastModifiedTime(std::forward<LastModifiedTimeT>(value));
    return *this;
  }
 
 
  inline const UserContext& GetCreatedBy() const { return m_createdBy; }
  inline bool CreatedByHasBeenSet() const { return m_createdByHasBeenSet; }
  template <typename CreatedByT = UserContext>
  void SetCreatedBy(CreatedByT&& value) {
    m_createdByHasBeenSet = true;
    m_createdBy = std::forward<CreatedByT>(value);
  }
  template <typename CreatedByT = UserContext>
  PipelineExecution& WithCreatedBy(CreatedByT&& value) {
    SetCreatedBy(std::forward<CreatedByT>(value));
    return *this;
  }
 
 
  inline const UserContext& GetLastModifiedBy() const { return m_lastModifiedBy; }
  inline bool LastModifiedByHasBeenSet() const { return m_lastModifiedByHasBeenSet; }
  template <typename LastModifiedByT = UserContext>
  void SetLastModifiedBy(LastModifiedByT&& value) {
    m_lastModifiedByHasBeenSet = true;
    m_lastModifiedBy = std::forward<LastModifiedByT>(value);
  }
  template <typename LastModifiedByT = UserContext>
  PipelineExecution& WithLastModifiedBy(LastModifiedByT&& value) {
    SetLastModifiedBy(std::forward<LastModifiedByT>(value));
    return *this;
  }
 
 
  inline const ParallelismConfiguration& GetParallelismConfiguration() const { return m_parallelismConfiguration; }
  inline bool ParallelismConfigurationHasBeenSet() const { return m_parallelismConfigurationHasBeenSet; }
  template <typename ParallelismConfigurationT = ParallelismConfiguration>
  void SetParallelismConfiguration(ParallelismConfigurationT&& value) {
    m_parallelismConfigurationHasBeenSet = true;
    m_parallelismConfiguration = std::forward<ParallelismConfigurationT>(value);
  }
  template <typename ParallelismConfigurationT = ParallelismConfiguration>
  PipelineExecution& WithParallelismConfiguration(ParallelismConfigurationT&& value) {
    SetParallelismConfiguration(std::forward<ParallelismConfigurationT>(value));
    return *this;
  }
 
 
  inline const SelectiveExecutionConfig& GetSelectiveExecutionConfig() const { return m_selectiveExecutionConfig; }
  inline bool SelectiveExecutionConfigHasBeenSet() const { return m_selectiveExecutionConfigHasBeenSet; }
  template <typename SelectiveExecutionConfigT = SelectiveExecutionConfig>
  void SetSelectiveExecutionConfig(SelectiveExecutionConfigT&& value) {
    m_selectiveExecutionConfigHasBeenSet = true;
    m_selectiveExecutionConfig = std::forward<SelectiveExecutionConfigT>(value);
  }
  template <typename SelectiveExecutionConfigT = SelectiveExecutionConfig>
  PipelineExecution& WithSelectiveExecutionConfig(SelectiveExecutionConfigT&& value) {
    SetSelectiveExecutionConfig(std::forward<SelectiveExecutionConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Parameter>& GetPipelineParameters() const { return m_pipelineParameters; }
  inline bool PipelineParametersHasBeenSet() const { return m_pipelineParametersHasBeenSet; }
  template <typename PipelineParametersT = Aws::Vector<Parameter>>
  void SetPipelineParameters(PipelineParametersT&& value) {
    m_pipelineParametersHasBeenSet = true;
    m_pipelineParameters = std::forward<PipelineParametersT>(value);
  }
  template <typename PipelineParametersT = Aws::Vector<Parameter>>
  PipelineExecution& WithPipelineParameters(PipelineParametersT&& value) {
    SetPipelineParameters(std::forward<PipelineParametersT>(value));
    return *this;
  }
  template <typename PipelineParametersT = Parameter>
  PipelineExecution& AddPipelineParameters(PipelineParametersT&& value) {
    m_pipelineParametersHasBeenSet = true;
    m_pipelineParameters.emplace_back(std::forward<PipelineParametersT>(value));
    return *this;
  }
 
 
  inline long long GetPipelineVersionId() const { return m_pipelineVersionId; }
  inline bool PipelineVersionIdHasBeenSet() const { return m_pipelineVersionIdHasBeenSet; }
  inline void SetPipelineVersionId(long long value) {
    m_pipelineVersionIdHasBeenSet = true;
    m_pipelineVersionId = value;
  }
  inline PipelineExecution& WithPipelineVersionId(long long value) {
    SetPipelineVersionId(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPipelineVersionDisplayName() const { return m_pipelineVersionDisplayName; }
  inline bool PipelineVersionDisplayNameHasBeenSet() const { return m_pipelineVersionDisplayNameHasBeenSet; }
  template <typename PipelineVersionDisplayNameT = Aws::String>
  void SetPipelineVersionDisplayName(PipelineVersionDisplayNameT&& value) {
    m_pipelineVersionDisplayNameHasBeenSet = true;
    m_pipelineVersionDisplayName = std::forward<PipelineVersionDisplayNameT>(value);
  }
  template <typename PipelineVersionDisplayNameT = Aws::String>
  PipelineExecution& WithPipelineVersionDisplayName(PipelineVersionDisplayNameT&& value) {
    SetPipelineVersionDisplayName(std::forward<PipelineVersionDisplayNameT>(value));
    return *this;
  }
 private:
  Aws::String m_pipelineArn;
 
  Aws::String m_pipelineExecutionArn;
 
  Aws::String m_pipelineExecutionDisplayName;
 
  PipelineExecutionStatus m_pipelineExecutionStatus{PipelineExecutionStatus::NOT_SET};
 
  Aws::String m_pipelineExecutionDescription;
 
  PipelineExperimentConfig m_pipelineExperimentConfig;
 
  Aws::String m_failureReason;
 
  Aws::Utils::DateTime m_creationTime{};
 
  Aws::Utils::DateTime m_lastModifiedTime{};
 
  UserContext m_createdBy;
 
  UserContext m_lastModifiedBy;
 
  ParallelismConfiguration m_parallelismConfiguration;
 
  SelectiveExecutionConfig m_selectiveExecutionConfig;
 
  Aws::Vector<Parameter> m_pipelineParameters;
 
  long long m_pipelineVersionId{0};
 
  Aws::String m_pipelineVersionDisplayName;
  bool m_pipelineArnHasBeenSet = false;
  bool m_pipelineExecutionArnHasBeenSet = false;
  bool m_pipelineExecutionDisplayNameHasBeenSet = false;
  bool m_pipelineExecutionStatusHasBeenSet = false;
  bool m_pipelineExecutionDescriptionHasBeenSet = false;
  bool m_pipelineExperimentConfigHasBeenSet = false;
  bool m_failureReasonHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_lastModifiedTimeHasBeenSet = false;
  bool m_createdByHasBeenSet = false;
  bool m_lastModifiedByHasBeenSet = false;
  bool m_parallelismConfigurationHasBeenSet = false;
  bool m_selectiveExecutionConfigHasBeenSet = false;
  bool m_pipelineParametersHasBeenSet = false;
  bool m_pipelineVersionIdHasBeenSet = false;
  bool m_pipelineVersionDisplayNameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws