MLTransform.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/glue/Glue_EXPORTS.h>
#include <aws/glue/model/EvaluationMetrics.h>
#include <aws/glue/model/GlueTable.h>
#include <aws/glue/model/SchemaColumn.h>
#include <aws/glue/model/TransformEncryption.h>
#include <aws/glue/model/TransformParameters.h>
#include <aws/glue/model/TransformStatusType.h>
#include <aws/glue/model/WorkerType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Glue {
namespace Model {
 
class MLTransform {
 public:
  AWS_GLUE_API MLTransform() = default;
  AWS_GLUE_API MLTransform(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API MLTransform& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetTransformId() const { return m_transformId; }
  inline bool TransformIdHasBeenSet() const { return m_transformIdHasBeenSet; }
  template <typename TransformIdT = Aws::String>
  void SetTransformId(TransformIdT&& value) {
    m_transformIdHasBeenSet = true;
    m_transformId = std::forward<TransformIdT>(value);
  }
  template <typename TransformIdT = Aws::String>
  MLTransform& WithTransformId(TransformIdT&& value) {
    SetTransformId(std::forward<TransformIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  MLTransform& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  MLTransform& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline TransformStatusType GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(TransformStatusType value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline MLTransform& WithStatus(TransformStatusType value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedOn() const { return m_createdOn; }
  inline bool CreatedOnHasBeenSet() const { return m_createdOnHasBeenSet; }
  template <typename CreatedOnT = Aws::Utils::DateTime>
  void SetCreatedOn(CreatedOnT&& value) {
    m_createdOnHasBeenSet = true;
    m_createdOn = std::forward<CreatedOnT>(value);
  }
  template <typename CreatedOnT = Aws::Utils::DateTime>
  MLTransform& WithCreatedOn(CreatedOnT&& value) {
    SetCreatedOn(std::forward<CreatedOnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModifiedOn() const { return m_lastModifiedOn; }
  inline bool LastModifiedOnHasBeenSet() const { return m_lastModifiedOnHasBeenSet; }
  template <typename LastModifiedOnT = Aws::Utils::DateTime>
  void SetLastModifiedOn(LastModifiedOnT&& value) {
    m_lastModifiedOnHasBeenSet = true;
    m_lastModifiedOn = std::forward<LastModifiedOnT>(value);
  }
  template <typename LastModifiedOnT = Aws::Utils::DateTime>
  MLTransform& WithLastModifiedOn(LastModifiedOnT&& value) {
    SetLastModifiedOn(std::forward<LastModifiedOnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GlueTable>& GetInputRecordTables() const { return m_inputRecordTables; }
  inline bool InputRecordTablesHasBeenSet() const { return m_inputRecordTablesHasBeenSet; }
  template <typename InputRecordTablesT = Aws::Vector<GlueTable>>
  void SetInputRecordTables(InputRecordTablesT&& value) {
    m_inputRecordTablesHasBeenSet = true;
    m_inputRecordTables = std::forward<InputRecordTablesT>(value);
  }
  template <typename InputRecordTablesT = Aws::Vector<GlueTable>>
  MLTransform& WithInputRecordTables(InputRecordTablesT&& value) {
    SetInputRecordTables(std::forward<InputRecordTablesT>(value));
    return *this;
  }
  template <typename InputRecordTablesT = GlueTable>
  MLTransform& AddInputRecordTables(InputRecordTablesT&& value) {
    m_inputRecordTablesHasBeenSet = true;
    m_inputRecordTables.emplace_back(std::forward<InputRecordTablesT>(value));
    return *this;
  }
 
 
  inline const TransformParameters& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = TransformParameters>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = TransformParameters>
  MLTransform& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
 
 
  inline const EvaluationMetrics& GetEvaluationMetrics() const { return m_evaluationMetrics; }
  inline bool EvaluationMetricsHasBeenSet() const { return m_evaluationMetricsHasBeenSet; }
  template <typename EvaluationMetricsT = EvaluationMetrics>
  void SetEvaluationMetrics(EvaluationMetricsT&& value) {
    m_evaluationMetricsHasBeenSet = true;
    m_evaluationMetrics = std::forward<EvaluationMetricsT>(value);
  }
  template <typename EvaluationMetricsT = EvaluationMetrics>
  MLTransform& WithEvaluationMetrics(EvaluationMetricsT&& value) {
    SetEvaluationMetrics(std::forward<EvaluationMetricsT>(value));
    return *this;
  }
 
 
  inline int GetLabelCount() const { return m_labelCount; }
  inline bool LabelCountHasBeenSet() const { return m_labelCountHasBeenSet; }
  inline void SetLabelCount(int value) {
    m_labelCountHasBeenSet = true;
    m_labelCount = value;
  }
  inline MLTransform& WithLabelCount(int value) {
    SetLabelCount(value);
    return *this;
  }
 
 
  inline const Aws::Vector<SchemaColumn>& GetSchema() const { return m_schema; }
  inline bool SchemaHasBeenSet() const { return m_schemaHasBeenSet; }
  template <typename SchemaT = Aws::Vector<SchemaColumn>>
  void SetSchema(SchemaT&& value) {
    m_schemaHasBeenSet = true;
    m_schema = std::forward<SchemaT>(value);
  }
  template <typename SchemaT = Aws::Vector<SchemaColumn>>
  MLTransform& WithSchema(SchemaT&& value) {
    SetSchema(std::forward<SchemaT>(value));
    return *this;
  }
  template <typename SchemaT = SchemaColumn>
  MLTransform& AddSchema(SchemaT&& value) {
    m_schemaHasBeenSet = true;
    m_schema.emplace_back(std::forward<SchemaT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRole() const { return m_role; }
  inline bool RoleHasBeenSet() const { return m_roleHasBeenSet; }
  template <typename RoleT = Aws::String>
  void SetRole(RoleT&& value) {
    m_roleHasBeenSet = true;
    m_role = std::forward<RoleT>(value);
  }
  template <typename RoleT = Aws::String>
  MLTransform& WithRole(RoleT&& value) {
    SetRole(std::forward<RoleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGlueVersion() const { return m_glueVersion; }
  inline bool GlueVersionHasBeenSet() const { return m_glueVersionHasBeenSet; }
  template <typename GlueVersionT = Aws::String>
  void SetGlueVersion(GlueVersionT&& value) {
    m_glueVersionHasBeenSet = true;
    m_glueVersion = std::forward<GlueVersionT>(value);
  }
  template <typename GlueVersionT = Aws::String>
  MLTransform& WithGlueVersion(GlueVersionT&& value) {
    SetGlueVersion(std::forward<GlueVersionT>(value));
    return *this;
  }
 
 
  inline double GetMaxCapacity() const { return m_maxCapacity; }
  inline bool MaxCapacityHasBeenSet() const { return m_maxCapacityHasBeenSet; }
  inline void SetMaxCapacity(double value) {
    m_maxCapacityHasBeenSet = true;
    m_maxCapacity = value;
  }
  inline MLTransform& WithMaxCapacity(double value) {
    SetMaxCapacity(value);
    return *this;
  }
 
 
  inline WorkerType GetWorkerType() const { return m_workerType; }
  inline bool WorkerTypeHasBeenSet() const { return m_workerTypeHasBeenSet; }
  inline void SetWorkerType(WorkerType value) {
    m_workerTypeHasBeenSet = true;
    m_workerType = value;
  }
  inline MLTransform& WithWorkerType(WorkerType value) {
    SetWorkerType(value);
    return *this;
  }
 
 
  inline int GetNumberOfWorkers() const { return m_numberOfWorkers; }
  inline bool NumberOfWorkersHasBeenSet() const { return m_numberOfWorkersHasBeenSet; }
  inline void SetNumberOfWorkers(int value) {
    m_numberOfWorkersHasBeenSet = true;
    m_numberOfWorkers = value;
  }
  inline MLTransform& WithNumberOfWorkers(int value) {
    SetNumberOfWorkers(value);
    return *this;
  }
 
 
  inline int GetTimeout() const { return m_timeout; }
  inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }
  inline void SetTimeout(int value) {
    m_timeoutHasBeenSet = true;
    m_timeout = value;
  }
  inline MLTransform& WithTimeout(int value) {
    SetTimeout(value);
    return *this;
  }
 
 
  inline int GetMaxRetries() const { return m_maxRetries; }
  inline bool MaxRetriesHasBeenSet() const { return m_maxRetriesHasBeenSet; }
  inline void SetMaxRetries(int value) {
    m_maxRetriesHasBeenSet = true;
    m_maxRetries = value;
  }
  inline MLTransform& WithMaxRetries(int value) {
    SetMaxRetries(value);
    return *this;
  }
 
 
  inline const TransformEncryption& GetTransformEncryption() const { return m_transformEncryption; }
  inline bool TransformEncryptionHasBeenSet() const { return m_transformEncryptionHasBeenSet; }
  template <typename TransformEncryptionT = TransformEncryption>
  void SetTransformEncryption(TransformEncryptionT&& value) {
    m_transformEncryptionHasBeenSet = true;
    m_transformEncryption = std::forward<TransformEncryptionT>(value);
  }
  template <typename TransformEncryptionT = TransformEncryption>
  MLTransform& WithTransformEncryption(TransformEncryptionT&& value) {
    SetTransformEncryption(std::forward<TransformEncryptionT>(value));
    return *this;
  }
 private:
  Aws::String m_transformId;
 
  Aws::String m_name;
 
  Aws::String m_description;
 
  TransformStatusType m_status{TransformStatusType::NOT_SET};
 
  Aws::Utils::DateTime m_createdOn{};
 
  Aws::Utils::DateTime m_lastModifiedOn{};
 
  Aws::Vector<GlueTable> m_inputRecordTables;
 
  TransformParameters m_parameters;
 
  EvaluationMetrics m_evaluationMetrics;
 
  int m_labelCount{0};
 
  Aws::Vector<SchemaColumn> m_schema;
 
  Aws::String m_role;
 
  Aws::String m_glueVersion;
 
  double m_maxCapacity{0.0};
 
  WorkerType m_workerType{WorkerType::NOT_SET};
 
  int m_numberOfWorkers{0};
 
  int m_timeout{0};
 
  int m_maxRetries{0};
 
  TransformEncryption m_transformEncryption;
  bool m_transformIdHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_createdOnHasBeenSet = false;
  bool m_lastModifiedOnHasBeenSet = false;
  bool m_inputRecordTablesHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_evaluationMetricsHasBeenSet = false;
  bool m_labelCountHasBeenSet = false;
  bool m_schemaHasBeenSet = false;
  bool m_roleHasBeenSet = false;
  bool m_glueVersionHasBeenSet = false;
  bool m_maxCapacityHasBeenSet = false;
  bool m_workerTypeHasBeenSet = false;
  bool m_numberOfWorkersHasBeenSet = false;
  bool m_timeoutHasBeenSet = false;
  bool m_maxRetriesHasBeenSet = false;
  bool m_transformEncryptionHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws