DescribeCompilationJobResult.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/CompilationJobStatus.h>
#include <aws/sagemaker/model/DerivedInformation.h>
#include <aws/sagemaker/model/InputConfig.h>
#include <aws/sagemaker/model/ModelArtifacts.h>
#include <aws/sagemaker/model/ModelDigests.h>
#include <aws/sagemaker/model/NeoVpcConfig.h>
#include <aws/sagemaker/model/OutputConfig.h>
#include <aws/sagemaker/model/StoppingCondition.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
class DescribeCompilationJobResult {
 public:
  AWS_SAGEMAKER_API DescribeCompilationJobResult() = default;
  AWS_SAGEMAKER_API DescribeCompilationJobResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_SAGEMAKER_API DescribeCompilationJobResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetCompilationJobName() const { return m_compilationJobName; }
  template <typename CompilationJobNameT = Aws::String>
  void SetCompilationJobName(CompilationJobNameT&& value) {
    m_compilationJobNameHasBeenSet = true;
    m_compilationJobName = std::forward<CompilationJobNameT>(value);
  }
  template <typename CompilationJobNameT = Aws::String>
  DescribeCompilationJobResult& WithCompilationJobName(CompilationJobNameT&& value) {
    SetCompilationJobName(std::forward<CompilationJobNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCompilationJobArn() const { return m_compilationJobArn; }
  template <typename CompilationJobArnT = Aws::String>
  void SetCompilationJobArn(CompilationJobArnT&& value) {
    m_compilationJobArnHasBeenSet = true;
    m_compilationJobArn = std::forward<CompilationJobArnT>(value);
  }
  template <typename CompilationJobArnT = Aws::String>
  DescribeCompilationJobResult& WithCompilationJobArn(CompilationJobArnT&& value) {
    SetCompilationJobArn(std::forward<CompilationJobArnT>(value));
    return *this;
  }
 
 
  inline CompilationJobStatus GetCompilationJobStatus() const { return m_compilationJobStatus; }
  inline void SetCompilationJobStatus(CompilationJobStatus value) {
    m_compilationJobStatusHasBeenSet = true;
    m_compilationJobStatus = value;
  }
  inline DescribeCompilationJobResult& WithCompilationJobStatus(CompilationJobStatus value) {
    SetCompilationJobStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCompilationStartTime() const { return m_compilationStartTime; }
  template <typename CompilationStartTimeT = Aws::Utils::DateTime>
  void SetCompilationStartTime(CompilationStartTimeT&& value) {
    m_compilationStartTimeHasBeenSet = true;
    m_compilationStartTime = std::forward<CompilationStartTimeT>(value);
  }
  template <typename CompilationStartTimeT = Aws::Utils::DateTime>
  DescribeCompilationJobResult& WithCompilationStartTime(CompilationStartTimeT&& value) {
    SetCompilationStartTime(std::forward<CompilationStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCompilationEndTime() const { return m_compilationEndTime; }
  template <typename CompilationEndTimeT = Aws::Utils::DateTime>
  void SetCompilationEndTime(CompilationEndTimeT&& value) {
    m_compilationEndTimeHasBeenSet = true;
    m_compilationEndTime = std::forward<CompilationEndTimeT>(value);
  }
  template <typename CompilationEndTimeT = Aws::Utils::DateTime>
  DescribeCompilationJobResult& WithCompilationEndTime(CompilationEndTimeT&& value) {
    SetCompilationEndTime(std::forward<CompilationEndTimeT>(value));
    return *this;
  }
 
 
  inline const StoppingCondition& GetStoppingCondition() const { return m_stoppingCondition; }
  template <typename StoppingConditionT = StoppingCondition>
  void SetStoppingCondition(StoppingConditionT&& value) {
    m_stoppingConditionHasBeenSet = true;
    m_stoppingCondition = std::forward<StoppingConditionT>(value);
  }
  template <typename StoppingConditionT = StoppingCondition>
  DescribeCompilationJobResult& WithStoppingCondition(StoppingConditionT&& value) {
    SetStoppingCondition(std::forward<StoppingConditionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInferenceImage() const { return m_inferenceImage; }
  template <typename InferenceImageT = Aws::String>
  void SetInferenceImage(InferenceImageT&& value) {
    m_inferenceImageHasBeenSet = true;
    m_inferenceImage = std::forward<InferenceImageT>(value);
  }
  template <typename InferenceImageT = Aws::String>
  DescribeCompilationJobResult& WithInferenceImage(InferenceImageT&& value) {
    SetInferenceImage(std::forward<InferenceImageT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetModelPackageVersionArn() const { return m_modelPackageVersionArn; }
  template <typename ModelPackageVersionArnT = Aws::String>
  void SetModelPackageVersionArn(ModelPackageVersionArnT&& value) {
    m_modelPackageVersionArnHasBeenSet = true;
    m_modelPackageVersionArn = std::forward<ModelPackageVersionArnT>(value);
  }
  template <typename ModelPackageVersionArnT = Aws::String>
  DescribeCompilationJobResult& WithModelPackageVersionArn(ModelPackageVersionArnT&& value) {
    SetModelPackageVersionArn(std::forward<ModelPackageVersionArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationTime() const { return m_creationTime; }
  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>
  DescribeCompilationJobResult& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModifiedTime() const { return m_lastModifiedTime; }
  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>
  DescribeCompilationJobResult& WithLastModifiedTime(LastModifiedTimeT&& value) {
    SetLastModifiedTime(std::forward<LastModifiedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFailureReason() const { return m_failureReason; }
  template <typename FailureReasonT = Aws::String>
  void SetFailureReason(FailureReasonT&& value) {
    m_failureReasonHasBeenSet = true;
    m_failureReason = std::forward<FailureReasonT>(value);
  }
  template <typename FailureReasonT = Aws::String>
  DescribeCompilationJobResult& WithFailureReason(FailureReasonT&& value) {
    SetFailureReason(std::forward<FailureReasonT>(value));
    return *this;
  }
 
 
  inline const ModelArtifacts& GetModelArtifacts() const { return m_modelArtifacts; }
  template <typename ModelArtifactsT = ModelArtifacts>
  void SetModelArtifacts(ModelArtifactsT&& value) {
    m_modelArtifactsHasBeenSet = true;
    m_modelArtifacts = std::forward<ModelArtifactsT>(value);
  }
  template <typename ModelArtifactsT = ModelArtifacts>
  DescribeCompilationJobResult& WithModelArtifacts(ModelArtifactsT&& value) {
    SetModelArtifacts(std::forward<ModelArtifactsT>(value));
    return *this;
  }
 
 
  inline const ModelDigests& GetModelDigests() const { return m_modelDigests; }
  template <typename ModelDigestsT = ModelDigests>
  void SetModelDigests(ModelDigestsT&& value) {
    m_modelDigestsHasBeenSet = true;
    m_modelDigests = std::forward<ModelDigestsT>(value);
  }
  template <typename ModelDigestsT = ModelDigests>
  DescribeCompilationJobResult& WithModelDigests(ModelDigestsT&& value) {
    SetModelDigests(std::forward<ModelDigestsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRoleArn() const { return m_roleArn; }
  template <typename RoleArnT = Aws::String>
  void SetRoleArn(RoleArnT&& value) {
    m_roleArnHasBeenSet = true;
    m_roleArn = std::forward<RoleArnT>(value);
  }
  template <typename RoleArnT = Aws::String>
  DescribeCompilationJobResult& WithRoleArn(RoleArnT&& value) {
    SetRoleArn(std::forward<RoleArnT>(value));
    return *this;
  }
 
 
  inline const InputConfig& GetInputConfig() const { return m_inputConfig; }
  template <typename InputConfigT = InputConfig>
  void SetInputConfig(InputConfigT&& value) {
    m_inputConfigHasBeenSet = true;
    m_inputConfig = std::forward<InputConfigT>(value);
  }
  template <typename InputConfigT = InputConfig>
  DescribeCompilationJobResult& WithInputConfig(InputConfigT&& value) {
    SetInputConfig(std::forward<InputConfigT>(value));
    return *this;
  }
 
 
  inline const OutputConfig& GetOutputConfig() const { return m_outputConfig; }
  template <typename OutputConfigT = OutputConfig>
  void SetOutputConfig(OutputConfigT&& value) {
    m_outputConfigHasBeenSet = true;
    m_outputConfig = std::forward<OutputConfigT>(value);
  }
  template <typename OutputConfigT = OutputConfig>
  DescribeCompilationJobResult& WithOutputConfig(OutputConfigT&& value) {
    SetOutputConfig(std::forward<OutputConfigT>(value));
    return *this;
  }
 
 
  inline const NeoVpcConfig& GetVpcConfig() const { return m_vpcConfig; }
  template <typename VpcConfigT = NeoVpcConfig>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = NeoVpcConfig>
  DescribeCompilationJobResult& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const DerivedInformation& GetDerivedInformation() const { return m_derivedInformation; }
  template <typename DerivedInformationT = DerivedInformation>
  void SetDerivedInformation(DerivedInformationT&& value) {
    m_derivedInformationHasBeenSet = true;
    m_derivedInformation = std::forward<DerivedInformationT>(value);
  }
  template <typename DerivedInformationT = DerivedInformation>
  DescribeCompilationJobResult& WithDerivedInformation(DerivedInformationT&& value) {
    SetDerivedInformation(std::forward<DerivedInformationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  DescribeCompilationJobResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  Aws::String m_compilationJobName;
 
  Aws::String m_compilationJobArn;
 
  CompilationJobStatus m_compilationJobStatus{CompilationJobStatus::NOT_SET};
 
  Aws::Utils::DateTime m_compilationStartTime{};
 
  Aws::Utils::DateTime m_compilationEndTime{};
 
  StoppingCondition m_stoppingCondition;
 
  Aws::String m_inferenceImage;
 
  Aws::String m_modelPackageVersionArn;
 
  Aws::Utils::DateTime m_creationTime{};
 
  Aws::Utils::DateTime m_lastModifiedTime{};
 
  Aws::String m_failureReason;
 
  ModelArtifacts m_modelArtifacts;
 
  ModelDigests m_modelDigests;
 
  Aws::String m_roleArn;
 
  InputConfig m_inputConfig;
 
  OutputConfig m_outputConfig;
 
  NeoVpcConfig m_vpcConfig;
 
  DerivedInformation m_derivedInformation;
 
  Aws::String m_requestId;
  bool m_compilationJobNameHasBeenSet = false;
  bool m_compilationJobArnHasBeenSet = false;
  bool m_compilationJobStatusHasBeenSet = false;
  bool m_compilationStartTimeHasBeenSet = false;
  bool m_compilationEndTimeHasBeenSet = false;
  bool m_stoppingConditionHasBeenSet = false;
  bool m_inferenceImageHasBeenSet = false;
  bool m_modelPackageVersionArnHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_lastModifiedTimeHasBeenSet = false;
  bool m_failureReasonHasBeenSet = false;
  bool m_modelArtifactsHasBeenSet = false;
  bool m_modelDigestsHasBeenSet = false;
  bool m_roleArnHasBeenSet = false;
  bool m_inputConfigHasBeenSet = false;
  bool m_outputConfigHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_derivedInformationHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws