Job.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/model/CodeGenConfigurationNode.h>
#include <aws/glue/model/ConnectionsList.h>
#include <aws/glue/model/ExecutionClass.h>
#include <aws/glue/model/ExecutionProperty.h>
#include <aws/glue/model/JobCommand.h>
#include <aws/glue/model/JobMode.h>
#include <aws/glue/model/NotificationProperty.h>
#include <aws/glue/model/SourceControlDetails.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 Job {
 public:
  AWS_GLUE_API Job() = default;
  AWS_GLUE_API Job(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Job& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  Job& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline JobMode GetJobMode() const { return m_jobMode; }
  inline bool JobModeHasBeenSet() const { return m_jobModeHasBeenSet; }
  inline void SetJobMode(JobMode value) {
    m_jobModeHasBeenSet = true;
    m_jobMode = value;
  }
  inline Job& WithJobMode(JobMode value) {
    SetJobMode(value);
    return *this;
  }
 
 
  inline bool GetJobRunQueuingEnabled() const { return m_jobRunQueuingEnabled; }
  inline bool JobRunQueuingEnabledHasBeenSet() const { return m_jobRunQueuingEnabledHasBeenSet; }
  inline void SetJobRunQueuingEnabled(bool value) {
    m_jobRunQueuingEnabledHasBeenSet = true;
    m_jobRunQueuingEnabled = value;
  }
  inline Job& WithJobRunQueuingEnabled(bool value) {
    SetJobRunQueuingEnabled(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>
  Job& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLogUri() const { return m_logUri; }
  inline bool LogUriHasBeenSet() const { return m_logUriHasBeenSet; }
  template <typename LogUriT = Aws::String>
  void SetLogUri(LogUriT&& value) {
    m_logUriHasBeenSet = true;
    m_logUri = std::forward<LogUriT>(value);
  }
  template <typename LogUriT = Aws::String>
  Job& WithLogUri(LogUriT&& value) {
    SetLogUri(std::forward<LogUriT>(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>
  Job& WithRole(RoleT&& value) {
    SetRole(std::forward<RoleT>(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>
  Job& 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>
  Job& WithLastModifiedOn(LastModifiedOnT&& value) {
    SetLastModifiedOn(std::forward<LastModifiedOnT>(value));
    return *this;
  }
 
 
  inline const ExecutionProperty& GetExecutionProperty() const { return m_executionProperty; }
  inline bool ExecutionPropertyHasBeenSet() const { return m_executionPropertyHasBeenSet; }
  template <typename ExecutionPropertyT = ExecutionProperty>
  void SetExecutionProperty(ExecutionPropertyT&& value) {
    m_executionPropertyHasBeenSet = true;
    m_executionProperty = std::forward<ExecutionPropertyT>(value);
  }
  template <typename ExecutionPropertyT = ExecutionProperty>
  Job& WithExecutionProperty(ExecutionPropertyT&& value) {
    SetExecutionProperty(std::forward<ExecutionPropertyT>(value));
    return *this;
  }
 
 
  inline const JobCommand& GetCommand() const { return m_command; }
  inline bool CommandHasBeenSet() const { return m_commandHasBeenSet; }
  template <typename CommandT = JobCommand>
  void SetCommand(CommandT&& value) {
    m_commandHasBeenSet = true;
    m_command = std::forward<CommandT>(value);
  }
  template <typename CommandT = JobCommand>
  Job& WithCommand(CommandT&& value) {
    SetCommand(std::forward<CommandT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetDefaultArguments() const { return m_defaultArguments; }
  inline bool DefaultArgumentsHasBeenSet() const { return m_defaultArgumentsHasBeenSet; }
  template <typename DefaultArgumentsT = Aws::Map<Aws::String, Aws::String>>
  void SetDefaultArguments(DefaultArgumentsT&& value) {
    m_defaultArgumentsHasBeenSet = true;
    m_defaultArguments = std::forward<DefaultArgumentsT>(value);
  }
  template <typename DefaultArgumentsT = Aws::Map<Aws::String, Aws::String>>
  Job& WithDefaultArguments(DefaultArgumentsT&& value) {
    SetDefaultArguments(std::forward<DefaultArgumentsT>(value));
    return *this;
  }
  template <typename DefaultArgumentsKeyT = Aws::String, typename DefaultArgumentsValueT = Aws::String>
  Job& AddDefaultArguments(DefaultArgumentsKeyT&& key, DefaultArgumentsValueT&& value) {
    m_defaultArgumentsHasBeenSet = true;
    m_defaultArguments.emplace(std::forward<DefaultArgumentsKeyT>(key), std::forward<DefaultArgumentsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetNonOverridableArguments() const { return m_nonOverridableArguments; }
  inline bool NonOverridableArgumentsHasBeenSet() const { return m_nonOverridableArgumentsHasBeenSet; }
  template <typename NonOverridableArgumentsT = Aws::Map<Aws::String, Aws::String>>
  void SetNonOverridableArguments(NonOverridableArgumentsT&& value) {
    m_nonOverridableArgumentsHasBeenSet = true;
    m_nonOverridableArguments = std::forward<NonOverridableArgumentsT>(value);
  }
  template <typename NonOverridableArgumentsT = Aws::Map<Aws::String, Aws::String>>
  Job& WithNonOverridableArguments(NonOverridableArgumentsT&& value) {
    SetNonOverridableArguments(std::forward<NonOverridableArgumentsT>(value));
    return *this;
  }
  template <typename NonOverridableArgumentsKeyT = Aws::String, typename NonOverridableArgumentsValueT = Aws::String>
  Job& AddNonOverridableArguments(NonOverridableArgumentsKeyT&& key, NonOverridableArgumentsValueT&& value) {
    m_nonOverridableArgumentsHasBeenSet = true;
    m_nonOverridableArguments.emplace(std::forward<NonOverridableArgumentsKeyT>(key), std::forward<NonOverridableArgumentsValueT>(value));
    return *this;
  }
 
 
  inline const ConnectionsList& GetConnections() const { return m_connections; }
  inline bool ConnectionsHasBeenSet() const { return m_connectionsHasBeenSet; }
  template <typename ConnectionsT = ConnectionsList>
  void SetConnections(ConnectionsT&& value) {
    m_connectionsHasBeenSet = true;
    m_connections = std::forward<ConnectionsT>(value);
  }
  template <typename ConnectionsT = ConnectionsList>
  Job& WithConnections(ConnectionsT&& value) {
    SetConnections(std::forward<ConnectionsT>(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 Job& WithMaxRetries(int value) {
    SetMaxRetries(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 Job& WithTimeout(int value) {
    SetTimeout(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 Job& 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 Job& 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 Job& WithNumberOfWorkers(int value) {
    SetNumberOfWorkers(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSecurityConfiguration() const { return m_securityConfiguration; }
  inline bool SecurityConfigurationHasBeenSet() const { return m_securityConfigurationHasBeenSet; }
  template <typename SecurityConfigurationT = Aws::String>
  void SetSecurityConfiguration(SecurityConfigurationT&& value) {
    m_securityConfigurationHasBeenSet = true;
    m_securityConfiguration = std::forward<SecurityConfigurationT>(value);
  }
  template <typename SecurityConfigurationT = Aws::String>
  Job& WithSecurityConfiguration(SecurityConfigurationT&& value) {
    SetSecurityConfiguration(std::forward<SecurityConfigurationT>(value));
    return *this;
  }
 
 
  inline const NotificationProperty& GetNotificationProperty() const { return m_notificationProperty; }
  inline bool NotificationPropertyHasBeenSet() const { return m_notificationPropertyHasBeenSet; }
  template <typename NotificationPropertyT = NotificationProperty>
  void SetNotificationProperty(NotificationPropertyT&& value) {
    m_notificationPropertyHasBeenSet = true;
    m_notificationProperty = std::forward<NotificationPropertyT>(value);
  }
  template <typename NotificationPropertyT = NotificationProperty>
  Job& WithNotificationProperty(NotificationPropertyT&& value) {
    SetNotificationProperty(std::forward<NotificationPropertyT>(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>
  Job& WithGlueVersion(GlueVersionT&& value) {
    SetGlueVersion(std::forward<GlueVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, CodeGenConfigurationNode>& GetCodeGenConfigurationNodes() const { return m_codeGenConfigurationNodes; }
  inline bool CodeGenConfigurationNodesHasBeenSet() const { return m_codeGenConfigurationNodesHasBeenSet; }
  template <typename CodeGenConfigurationNodesT = Aws::Map<Aws::String, CodeGenConfigurationNode>>
  void SetCodeGenConfigurationNodes(CodeGenConfigurationNodesT&& value) {
    m_codeGenConfigurationNodesHasBeenSet = true;
    m_codeGenConfigurationNodes = std::forward<CodeGenConfigurationNodesT>(value);
  }
  template <typename CodeGenConfigurationNodesT = Aws::Map<Aws::String, CodeGenConfigurationNode>>
  Job& WithCodeGenConfigurationNodes(CodeGenConfigurationNodesT&& value) {
    SetCodeGenConfigurationNodes(std::forward<CodeGenConfigurationNodesT>(value));
    return *this;
  }
  template <typename CodeGenConfigurationNodesKeyT = Aws::String, typename CodeGenConfigurationNodesValueT = CodeGenConfigurationNode>
  Job& AddCodeGenConfigurationNodes(CodeGenConfigurationNodesKeyT&& key, CodeGenConfigurationNodesValueT&& value) {
    m_codeGenConfigurationNodesHasBeenSet = true;
    m_codeGenConfigurationNodes.emplace(std::forward<CodeGenConfigurationNodesKeyT>(key),
                                        std::forward<CodeGenConfigurationNodesValueT>(value));
    return *this;
  }
 
 
  inline ExecutionClass GetExecutionClass() const { return m_executionClass; }
  inline bool ExecutionClassHasBeenSet() const { return m_executionClassHasBeenSet; }
  inline void SetExecutionClass(ExecutionClass value) {
    m_executionClassHasBeenSet = true;
    m_executionClass = value;
  }
  inline Job& WithExecutionClass(ExecutionClass value) {
    SetExecutionClass(value);
    return *this;
  }
 
 
  inline const SourceControlDetails& GetSourceControlDetails() const { return m_sourceControlDetails; }
  inline bool SourceControlDetailsHasBeenSet() const { return m_sourceControlDetailsHasBeenSet; }
  template <typename SourceControlDetailsT = SourceControlDetails>
  void SetSourceControlDetails(SourceControlDetailsT&& value) {
    m_sourceControlDetailsHasBeenSet = true;
    m_sourceControlDetails = std::forward<SourceControlDetailsT>(value);
  }
  template <typename SourceControlDetailsT = SourceControlDetails>
  Job& WithSourceControlDetails(SourceControlDetailsT&& value) {
    SetSourceControlDetails(std::forward<SourceControlDetailsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaintenanceWindow() const { return m_maintenanceWindow; }
  inline bool MaintenanceWindowHasBeenSet() const { return m_maintenanceWindowHasBeenSet; }
  template <typename MaintenanceWindowT = Aws::String>
  void SetMaintenanceWindow(MaintenanceWindowT&& value) {
    m_maintenanceWindowHasBeenSet = true;
    m_maintenanceWindow = std::forward<MaintenanceWindowT>(value);
  }
  template <typename MaintenanceWindowT = Aws::String>
  Job& WithMaintenanceWindow(MaintenanceWindowT&& value) {
    SetMaintenanceWindow(std::forward<MaintenanceWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetProfileName() const { return m_profileName; }
  inline bool ProfileNameHasBeenSet() const { return m_profileNameHasBeenSet; }
  template <typename ProfileNameT = Aws::String>
  void SetProfileName(ProfileNameT&& value) {
    m_profileNameHasBeenSet = true;
    m_profileName = std::forward<ProfileNameT>(value);
  }
  template <typename ProfileNameT = Aws::String>
  Job& WithProfileName(ProfileNameT&& value) {
    SetProfileName(std::forward<ProfileNameT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  JobMode m_jobMode{JobMode::NOT_SET};
 
  bool m_jobRunQueuingEnabled{false};
 
  Aws::String m_description;
 
  Aws::String m_logUri;
 
  Aws::String m_role;
 
  Aws::Utils::DateTime m_createdOn{};
 
  Aws::Utils::DateTime m_lastModifiedOn{};
 
  ExecutionProperty m_executionProperty;
 
  JobCommand m_command;
 
  Aws::Map<Aws::String, Aws::String> m_defaultArguments;
 
  Aws::Map<Aws::String, Aws::String> m_nonOverridableArguments;
 
  ConnectionsList m_connections;
 
  int m_maxRetries{0};
 
  int m_timeout{0};
 
  double m_maxCapacity{0.0};
 
  WorkerType m_workerType{WorkerType::NOT_SET};
 
  int m_numberOfWorkers{0};
 
  Aws::String m_securityConfiguration;
 
  NotificationProperty m_notificationProperty;
 
  Aws::String m_glueVersion;
 
  Aws::Map<Aws::String, CodeGenConfigurationNode> m_codeGenConfigurationNodes;
 
  ExecutionClass m_executionClass{ExecutionClass::NOT_SET};
 
  SourceControlDetails m_sourceControlDetails;
 
  Aws::String m_maintenanceWindow;
 
  Aws::String m_profileName;
  bool m_nameHasBeenSet = false;
  bool m_jobModeHasBeenSet = false;
  bool m_jobRunQueuingEnabledHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_logUriHasBeenSet = false;
  bool m_roleHasBeenSet = false;
  bool m_createdOnHasBeenSet = false;
  bool m_lastModifiedOnHasBeenSet = false;
  bool m_executionPropertyHasBeenSet = false;
  bool m_commandHasBeenSet = false;
  bool m_defaultArgumentsHasBeenSet = false;
  bool m_nonOverridableArgumentsHasBeenSet = false;
  bool m_connectionsHasBeenSet = false;
  bool m_maxRetriesHasBeenSet = false;
  bool m_timeoutHasBeenSet = false;
  bool m_maxCapacityHasBeenSet = false;
  bool m_workerTypeHasBeenSet = false;
  bool m_numberOfWorkersHasBeenSet = false;
  bool m_securityConfigurationHasBeenSet = false;
  bool m_notificationPropertyHasBeenSet = false;
  bool m_glueVersionHasBeenSet = false;
  bool m_codeGenConfigurationNodesHasBeenSet = false;
  bool m_executionClassHasBeenSet = false;
  bool m_sourceControlDetailsHasBeenSet = false;
  bool m_maintenanceWindowHasBeenSet = false;
  bool m_profileNameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Glue
}  // namespace Aws