UpdateMaintenanceWindowTaskResult.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ssm/SSM_EXPORTS.h>
#include <aws/ssm/model/AlarmConfiguration.h>
#include <aws/ssm/model/LoggingInfo.h>
#include <aws/ssm/model/MaintenanceWindowTaskCutoffBehavior.h>
#include <aws/ssm/model/MaintenanceWindowTaskInvocationParameters.h>
#include <aws/ssm/model/MaintenanceWindowTaskParameterValueExpression.h>
#include <aws/ssm/model/Target.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace SSM {
namespace Model {
class UpdateMaintenanceWindowTaskResult {
 public:
  AWS_SSM_API UpdateMaintenanceWindowTaskResult() = default;
  AWS_SSM_API UpdateMaintenanceWindowTaskResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_SSM_API UpdateMaintenanceWindowTaskResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetWindowId() const { return m_windowId; }
  template <typename WindowIdT = Aws::String>
  void SetWindowId(WindowIdT&& value) {
    m_windowIdHasBeenSet = true;
    m_windowId = std::forward<WindowIdT>(value);
  }
  template <typename WindowIdT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithWindowId(WindowIdT&& value) {
    SetWindowId(std::forward<WindowIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWindowTaskId() const { return m_windowTaskId; }
  template <typename WindowTaskIdT = Aws::String>
  void SetWindowTaskId(WindowTaskIdT&& value) {
    m_windowTaskIdHasBeenSet = true;
    m_windowTaskId = std::forward<WindowTaskIdT>(value);
  }
  template <typename WindowTaskIdT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithWindowTaskId(WindowTaskIdT&& value) {
    SetWindowTaskId(std::forward<WindowTaskIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Target>& GetTargets() const { return m_targets; }
  template <typename TargetsT = Aws::Vector<Target>>
  void SetTargets(TargetsT&& value) {
    m_targetsHasBeenSet = true;
    m_targets = std::forward<TargetsT>(value);
  }
  template <typename TargetsT = Aws::Vector<Target>>
  UpdateMaintenanceWindowTaskResult& WithTargets(TargetsT&& value) {
    SetTargets(std::forward<TargetsT>(value));
    return *this;
  }
  template <typename TargetsT = Target>
  UpdateMaintenanceWindowTaskResult& AddTargets(TargetsT&& value) {
    m_targetsHasBeenSet = true;
    m_targets.emplace_back(std::forward<TargetsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTaskArn() const { return m_taskArn; }
  template <typename TaskArnT = Aws::String>
  void SetTaskArn(TaskArnT&& value) {
    m_taskArnHasBeenSet = true;
    m_taskArn = std::forward<TaskArnT>(value);
  }
  template <typename TaskArnT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithTaskArn(TaskArnT&& value) {
    SetTaskArn(std::forward<TaskArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceRoleArn() const { return m_serviceRoleArn; }
  template <typename ServiceRoleArnT = Aws::String>
  void SetServiceRoleArn(ServiceRoleArnT&& value) {
    m_serviceRoleArnHasBeenSet = true;
    m_serviceRoleArn = std::forward<ServiceRoleArnT>(value);
  }
  template <typename ServiceRoleArnT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithServiceRoleArn(ServiceRoleArnT&& value) {
    SetServiceRoleArn(std::forward<ServiceRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, MaintenanceWindowTaskParameterValueExpression>& GetTaskParameters() const { return m_taskParameters; }
  template <typename TaskParametersT = Aws::Map<Aws::String, MaintenanceWindowTaskParameterValueExpression>>
  void SetTaskParameters(TaskParametersT&& value) {
    m_taskParametersHasBeenSet = true;
    m_taskParameters = std::forward<TaskParametersT>(value);
  }
  template <typename TaskParametersT = Aws::Map<Aws::String, MaintenanceWindowTaskParameterValueExpression>>
  UpdateMaintenanceWindowTaskResult& WithTaskParameters(TaskParametersT&& value) {
    SetTaskParameters(std::forward<TaskParametersT>(value));
    return *this;
  }
  template <typename TaskParametersKeyT = Aws::String, typename TaskParametersValueT = MaintenanceWindowTaskParameterValueExpression>
  UpdateMaintenanceWindowTaskResult& AddTaskParameters(TaskParametersKeyT&& key, TaskParametersValueT&& value) {
    m_taskParametersHasBeenSet = true;
    m_taskParameters.emplace(std::forward<TaskParametersKeyT>(key), std::forward<TaskParametersValueT>(value));
    return *this;
  }
 
 
  inline const MaintenanceWindowTaskInvocationParameters& GetTaskInvocationParameters() const { return m_taskInvocationParameters; }
  template <typename TaskInvocationParametersT = MaintenanceWindowTaskInvocationParameters>
  void SetTaskInvocationParameters(TaskInvocationParametersT&& value) {
    m_taskInvocationParametersHasBeenSet = true;
    m_taskInvocationParameters = std::forward<TaskInvocationParametersT>(value);
  }
  template <typename TaskInvocationParametersT = MaintenanceWindowTaskInvocationParameters>
  UpdateMaintenanceWindowTaskResult& WithTaskInvocationParameters(TaskInvocationParametersT&& value) {
    SetTaskInvocationParameters(std::forward<TaskInvocationParametersT>(value));
    return *this;
  }
 
 
  inline int GetPriority() const { return m_priority; }
  inline void SetPriority(int value) {
    m_priorityHasBeenSet = true;
    m_priority = value;
  }
  inline UpdateMaintenanceWindowTaskResult& WithPriority(int value) {
    SetPriority(value);
    return *this;
  }
 
 
  inline const Aws::String& GetMaxConcurrency() const { return m_maxConcurrency; }
  template <typename MaxConcurrencyT = Aws::String>
  void SetMaxConcurrency(MaxConcurrencyT&& value) {
    m_maxConcurrencyHasBeenSet = true;
    m_maxConcurrency = std::forward<MaxConcurrencyT>(value);
  }
  template <typename MaxConcurrencyT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithMaxConcurrency(MaxConcurrencyT&& value) {
    SetMaxConcurrency(std::forward<MaxConcurrencyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaxErrors() const { return m_maxErrors; }
  template <typename MaxErrorsT = Aws::String>
  void SetMaxErrors(MaxErrorsT&& value) {
    m_maxErrorsHasBeenSet = true;
    m_maxErrors = std::forward<MaxErrorsT>(value);
  }
  template <typename MaxErrorsT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithMaxErrors(MaxErrorsT&& value) {
    SetMaxErrors(std::forward<MaxErrorsT>(value));
    return *this;
  }
 
 
  inline const LoggingInfo& GetLoggingInfo() const { return m_loggingInfo; }
  template <typename LoggingInfoT = LoggingInfo>
  void SetLoggingInfo(LoggingInfoT&& value) {
    m_loggingInfoHasBeenSet = true;
    m_loggingInfo = std::forward<LoggingInfoT>(value);
  }
  template <typename LoggingInfoT = LoggingInfo>
  UpdateMaintenanceWindowTaskResult& WithLoggingInfo(LoggingInfoT&& value) {
    SetLoggingInfo(std::forward<LoggingInfoT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  UpdateMaintenanceWindowTaskResult& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline MaintenanceWindowTaskCutoffBehavior GetCutoffBehavior() const { return m_cutoffBehavior; }
  inline void SetCutoffBehavior(MaintenanceWindowTaskCutoffBehavior value) {
    m_cutoffBehaviorHasBeenSet = true;
    m_cutoffBehavior = value;
  }
  inline UpdateMaintenanceWindowTaskResult& WithCutoffBehavior(MaintenanceWindowTaskCutoffBehavior value) {
    SetCutoffBehavior(value);
    return *this;
  }
 
 
  inline const AlarmConfiguration& GetAlarmConfiguration() const { return m_alarmConfiguration; }
  template <typename AlarmConfigurationT = AlarmConfiguration>
  void SetAlarmConfiguration(AlarmConfigurationT&& value) {
    m_alarmConfigurationHasBeenSet = true;
    m_alarmConfiguration = std::forward<AlarmConfigurationT>(value);
  }
  template <typename AlarmConfigurationT = AlarmConfiguration>
  UpdateMaintenanceWindowTaskResult& WithAlarmConfiguration(AlarmConfigurationT&& value) {
    SetAlarmConfiguration(std::forward<AlarmConfigurationT>(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>
  UpdateMaintenanceWindowTaskResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
 private:
  Aws::String m_windowId;
 
  Aws::String m_windowTaskId;
 
  Aws::Vector<Target> m_targets;
 
  Aws::String m_taskArn;
 
  Aws::String m_serviceRoleArn;
 
  Aws::Map<Aws::String, MaintenanceWindowTaskParameterValueExpression> m_taskParameters;
 
  MaintenanceWindowTaskInvocationParameters m_taskInvocationParameters;
 
  int m_priority{0};
 
  Aws::String m_maxConcurrency;
 
  Aws::String m_maxErrors;
 
  LoggingInfo m_loggingInfo;
 
  Aws::String m_name;
 
  Aws::String m_description;
 
  MaintenanceWindowTaskCutoffBehavior m_cutoffBehavior{MaintenanceWindowTaskCutoffBehavior::NOT_SET};
 
  AlarmConfiguration m_alarmConfiguration;
 
  Aws::String m_requestId;
  bool m_windowIdHasBeenSet = false;
  bool m_windowTaskIdHasBeenSet = false;
  bool m_targetsHasBeenSet = false;
  bool m_taskArnHasBeenSet = false;
  bool m_serviceRoleArnHasBeenSet = false;
  bool m_taskParametersHasBeenSet = false;
  bool m_taskInvocationParametersHasBeenSet = false;
  bool m_priorityHasBeenSet = false;
  bool m_maxConcurrencyHasBeenSet = false;
  bool m_maxErrorsHasBeenSet = false;
  bool m_loggingInfoHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_cutoffBehaviorHasBeenSet = false;
  bool m_alarmConfigurationHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SSM
}  // namespace Aws