JobRun.h

 
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/glue/model/JobMode.h>
#include <aws/core/utils/DateTime.h>
#include <aws/glue/model/JobRunState.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/glue/model/WorkerType.h>
#include <aws/glue/model/NotificationProperty.h>
#include <aws/glue/model/ExecutionClass.h>
#include <aws/glue/model/Predecessor.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Glue
{
namespace Model
{
 
  class JobRun
  {
  public:
    AWS_GLUE_API JobRun() = default;
    AWS_GLUE_API JobRun(Aws::Utils::Json::JsonView jsonValue);
    AWS_GLUE_API JobRun& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_GLUE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetId() const { return m_id; }
    inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
    template<typename IdT = Aws::String>
    void SetId(IdT&& value) { m_idHasBeenSet = true; m_id = std::forward<IdT>(value); }
    template<typename IdT = Aws::String>
    JobRun& WithId(IdT&& value) { SetId(std::forward<IdT>(value)); return *this;}
 
 
    inline int GetAttempt() const { return m_attempt; }
    inline bool AttemptHasBeenSet() const { return m_attemptHasBeenSet; }
    inline void SetAttempt(int value) { m_attemptHasBeenSet = true; m_attempt = value; }
    inline JobRun& WithAttempt(int value) { SetAttempt(value); return *this;}
 
 
    inline const Aws::String& GetPreviousRunId() const { return m_previousRunId; }
    inline bool PreviousRunIdHasBeenSet() const { return m_previousRunIdHasBeenSet; }
    template<typename PreviousRunIdT = Aws::String>
    void SetPreviousRunId(PreviousRunIdT&& value) { m_previousRunIdHasBeenSet = true; m_previousRunId = std::forward<PreviousRunIdT>(value); }
    template<typename PreviousRunIdT = Aws::String>
    JobRun& WithPreviousRunId(PreviousRunIdT&& value) { SetPreviousRunId(std::forward<PreviousRunIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetTriggerName() const { return m_triggerName; }
    inline bool TriggerNameHasBeenSet() const { return m_triggerNameHasBeenSet; }
    template<typename TriggerNameT = Aws::String>
    void SetTriggerName(TriggerNameT&& value) { m_triggerNameHasBeenSet = true; m_triggerName = std::forward<TriggerNameT>(value); }
    template<typename TriggerNameT = Aws::String>
    JobRun& WithTriggerName(TriggerNameT&& value) { SetTriggerName(std::forward<TriggerNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetJobName() const { return m_jobName; }
    inline bool JobNameHasBeenSet() const { return m_jobNameHasBeenSet; }
    template<typename JobNameT = Aws::String>
    void SetJobName(JobNameT&& value) { m_jobNameHasBeenSet = true; m_jobName = std::forward<JobNameT>(value); }
    template<typename JobNameT = Aws::String>
    JobRun& WithJobName(JobNameT&& value) { SetJobName(std::forward<JobNameT>(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 JobRun& 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 JobRun& WithJobRunQueuingEnabled(bool value) { SetJobRunQueuingEnabled(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetStartedOn() const { return m_startedOn; }
    inline bool StartedOnHasBeenSet() const { return m_startedOnHasBeenSet; }
    template<typename StartedOnT = Aws::Utils::DateTime>
    void SetStartedOn(StartedOnT&& value) { m_startedOnHasBeenSet = true; m_startedOn = std::forward<StartedOnT>(value); }
    template<typename StartedOnT = Aws::Utils::DateTime>
    JobRun& WithStartedOn(StartedOnT&& value) { SetStartedOn(std::forward<StartedOnT>(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>
    JobRun& WithLastModifiedOn(LastModifiedOnT&& value) { SetLastModifiedOn(std::forward<LastModifiedOnT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetCompletedOn() const { return m_completedOn; }
    inline bool CompletedOnHasBeenSet() const { return m_completedOnHasBeenSet; }
    template<typename CompletedOnT = Aws::Utils::DateTime>
    void SetCompletedOn(CompletedOnT&& value) { m_completedOnHasBeenSet = true; m_completedOn = std::forward<CompletedOnT>(value); }
    template<typename CompletedOnT = Aws::Utils::DateTime>
    JobRun& WithCompletedOn(CompletedOnT&& value) { SetCompletedOn(std::forward<CompletedOnT>(value)); return *this;}
 
 
    inline JobRunState GetJobRunState() const { return m_jobRunState; }
    inline bool JobRunStateHasBeenSet() const { return m_jobRunStateHasBeenSet; }
    inline void SetJobRunState(JobRunState value) { m_jobRunStateHasBeenSet = true; m_jobRunState = value; }
    inline JobRun& WithJobRunState(JobRunState value) { SetJobRunState(value); return *this;}
 
 
    inline const Aws::Map<Aws::String, Aws::String>& GetArguments() const { return m_arguments; }
    inline bool ArgumentsHasBeenSet() const { return m_argumentsHasBeenSet; }
    template<typename ArgumentsT = Aws::Map<Aws::String, Aws::String>>
    void SetArguments(ArgumentsT&& value) { m_argumentsHasBeenSet = true; m_arguments = std::forward<ArgumentsT>(value); }
    template<typename ArgumentsT = Aws::Map<Aws::String, Aws::String>>
    JobRun& WithArguments(ArgumentsT&& value) { SetArguments(std::forward<ArgumentsT>(value)); return *this;}
    template<typename ArgumentsKeyT = Aws::String, typename ArgumentsValueT = Aws::String>
    JobRun& AddArguments(ArgumentsKeyT&& key, ArgumentsValueT&& value) {
      m_argumentsHasBeenSet = true; m_arguments.emplace(std::forward<ArgumentsKeyT>(key), std::forward<ArgumentsValueT>(value)); return *this;
    }
 
 
    inline const Aws::String& GetErrorMessage() const { return m_errorMessage; }
    inline bool ErrorMessageHasBeenSet() const { return m_errorMessageHasBeenSet; }
    template<typename ErrorMessageT = Aws::String>
    void SetErrorMessage(ErrorMessageT&& value) { m_errorMessageHasBeenSet = true; m_errorMessage = std::forward<ErrorMessageT>(value); }
    template<typename ErrorMessageT = Aws::String>
    JobRun& WithErrorMessage(ErrorMessageT&& value) { SetErrorMessage(std::forward<ErrorMessageT>(value)); return *this;}
 
 
    inline const Aws::Vector<Predecessor>& GetPredecessorRuns() const { return m_predecessorRuns; }
    inline bool PredecessorRunsHasBeenSet() const { return m_predecessorRunsHasBeenSet; }
    template<typename PredecessorRunsT = Aws::Vector<Predecessor>>
    void SetPredecessorRuns(PredecessorRunsT&& value) { m_predecessorRunsHasBeenSet = true; m_predecessorRuns = std::forward<PredecessorRunsT>(value); }
    template<typename PredecessorRunsT = Aws::Vector<Predecessor>>
    JobRun& WithPredecessorRuns(PredecessorRunsT&& value) { SetPredecessorRuns(std::forward<PredecessorRunsT>(value)); return *this;}
    template<typename PredecessorRunsT = Predecessor>
    JobRun& AddPredecessorRuns(PredecessorRunsT&& value) { m_predecessorRunsHasBeenSet = true; m_predecessorRuns.emplace_back(std::forward<PredecessorRunsT>(value)); return *this; }
 
 
    inline int GetExecutionTime() const { return m_executionTime; }
    inline bool ExecutionTimeHasBeenSet() const { return m_executionTimeHasBeenSet; }
    inline void SetExecutionTime(int value) { m_executionTimeHasBeenSet = true; m_executionTime = value; }
    inline JobRun& WithExecutionTime(int value) { SetExecutionTime(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 JobRun& 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 JobRun& 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 JobRun& 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 JobRun& 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>
    JobRun& WithSecurityConfiguration(SecurityConfigurationT&& value) { SetSecurityConfiguration(std::forward<SecurityConfigurationT>(value)); return *this;}
 
 
    inline const Aws::String& GetLogGroupName() const { return m_logGroupName; }
    inline bool LogGroupNameHasBeenSet() const { return m_logGroupNameHasBeenSet; }
    template<typename LogGroupNameT = Aws::String>
    void SetLogGroupName(LogGroupNameT&& value) { m_logGroupNameHasBeenSet = true; m_logGroupName = std::forward<LogGroupNameT>(value); }
    template<typename LogGroupNameT = Aws::String>
    JobRun& WithLogGroupName(LogGroupNameT&& value) { SetLogGroupName(std::forward<LogGroupNameT>(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>
    JobRun& 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>
    JobRun& WithGlueVersion(GlueVersionT&& value) { SetGlueVersion(std::forward<GlueVersionT>(value)); return *this;}
 
 
    inline double GetDPUSeconds() const { return m_dPUSeconds; }
    inline bool DPUSecondsHasBeenSet() const { return m_dPUSecondsHasBeenSet; }
    inline void SetDPUSeconds(double value) { m_dPUSecondsHasBeenSet = true; m_dPUSeconds = value; }
    inline JobRun& WithDPUSeconds(double value) { SetDPUSeconds(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 JobRun& WithExecutionClass(ExecutionClass value) { SetExecutionClass(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>
    JobRun& 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>
    JobRun& WithProfileName(ProfileNameT&& value) { SetProfileName(std::forward<ProfileNameT>(value)); return *this;}
 
 
    inline const Aws::String& GetStateDetail() const { return m_stateDetail; }
    inline bool StateDetailHasBeenSet() const { return m_stateDetailHasBeenSet; }
    template<typename StateDetailT = Aws::String>
    void SetStateDetail(StateDetailT&& value) { m_stateDetailHasBeenSet = true; m_stateDetail = std::forward<StateDetailT>(value); }
    template<typename StateDetailT = Aws::String>
    JobRun& WithStateDetail(StateDetailT&& value) { SetStateDetail(std::forward<StateDetailT>(value)); return *this;}
  private:
 
    Aws::String m_id;
    bool m_idHasBeenSet = false;
 
    int m_attempt{0};
    bool m_attemptHasBeenSet = false;
 
    Aws::String m_previousRunId;
    bool m_previousRunIdHasBeenSet = false;
 
    Aws::String m_triggerName;
    bool m_triggerNameHasBeenSet = false;
 
    Aws::String m_jobName;
    bool m_jobNameHasBeenSet = false;
 
    JobMode m_jobMode{JobMode::NOT_SET};
    bool m_jobModeHasBeenSet = false;
 
    bool m_jobRunQueuingEnabled{false};
    bool m_jobRunQueuingEnabledHasBeenSet = false;
 
    Aws::Utils::DateTime m_startedOn{};
    bool m_startedOnHasBeenSet = false;
 
    Aws::Utils::DateTime m_lastModifiedOn{};
    bool m_lastModifiedOnHasBeenSet = false;
 
    Aws::Utils::DateTime m_completedOn{};
    bool m_completedOnHasBeenSet = false;
 
    JobRunState m_jobRunState{JobRunState::NOT_SET};
    bool m_jobRunStateHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_arguments;
    bool m_argumentsHasBeenSet = false;
 
    Aws::String m_errorMessage;
    bool m_errorMessageHasBeenSet = false;
 
    Aws::Vector<Predecessor> m_predecessorRuns;
    bool m_predecessorRunsHasBeenSet = false;
 
    int m_executionTime{0};
    bool m_executionTimeHasBeenSet = false;
 
    int m_timeout{0};
    bool m_timeoutHasBeenSet = false;
 
    double m_maxCapacity{0.0};
    bool m_maxCapacityHasBeenSet = false;
 
    WorkerType m_workerType{WorkerType::NOT_SET};
    bool m_workerTypeHasBeenSet = false;
 
    int m_numberOfWorkers{0};
    bool m_numberOfWorkersHasBeenSet = false;
 
    Aws::String m_securityConfiguration;
    bool m_securityConfigurationHasBeenSet = false;
 
    Aws::String m_logGroupName;
    bool m_logGroupNameHasBeenSet = false;
 
    NotificationProperty m_notificationProperty;
    bool m_notificationPropertyHasBeenSet = false;
 
    Aws::String m_glueVersion;
    bool m_glueVersionHasBeenSet = false;
 
    double m_dPUSeconds{0.0};
    bool m_dPUSecondsHasBeenSet = false;
 
    ExecutionClass m_executionClass{ExecutionClass::NOT_SET};
    bool m_executionClassHasBeenSet = false;
 
    Aws::String m_maintenanceWindow;
    bool m_maintenanceWindowHasBeenSet = false;
 
    Aws::String m_profileName;
    bool m_profileNameHasBeenSet = false;
 
    Aws::String m_stateDetail;
    bool m_stateDetailHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Glue
} // namespace Aws