Schedule.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/imagebuilder/Imagebuilder_EXPORTS.h>
#include <aws/imagebuilder/model/AutoDisablePolicy.h>
#include <aws/imagebuilder/model/PipelineExecutionStartCondition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace imagebuilder {
namespace Model {
 
class Schedule {
 public:
  AWS_IMAGEBUILDER_API Schedule() = default;
  AWS_IMAGEBUILDER_API Schedule(Aws::Utils::Json::JsonView jsonValue);
  AWS_IMAGEBUILDER_API Schedule& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IMAGEBUILDER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetScheduleExpression() const { return m_scheduleExpression; }
  inline bool ScheduleExpressionHasBeenSet() const { return m_scheduleExpressionHasBeenSet; }
  template <typename ScheduleExpressionT = Aws::String>
  void SetScheduleExpression(ScheduleExpressionT&& value) {
    m_scheduleExpressionHasBeenSet = true;
    m_scheduleExpression = std::forward<ScheduleExpressionT>(value);
  }
  template <typename ScheduleExpressionT = Aws::String>
  Schedule& WithScheduleExpression(ScheduleExpressionT&& value) {
    SetScheduleExpression(std::forward<ScheduleExpressionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTimezone() const { return m_timezone; }
  inline bool TimezoneHasBeenSet() const { return m_timezoneHasBeenSet; }
  template <typename TimezoneT = Aws::String>
  void SetTimezone(TimezoneT&& value) {
    m_timezoneHasBeenSet = true;
    m_timezone = std::forward<TimezoneT>(value);
  }
  template <typename TimezoneT = Aws::String>
  Schedule& WithTimezone(TimezoneT&& value) {
    SetTimezone(std::forward<TimezoneT>(value));
    return *this;
  }
 
 
  inline PipelineExecutionStartCondition GetPipelineExecutionStartCondition() const { return m_pipelineExecutionStartCondition; }
  inline bool PipelineExecutionStartConditionHasBeenSet() const { return m_pipelineExecutionStartConditionHasBeenSet; }
  inline void SetPipelineExecutionStartCondition(PipelineExecutionStartCondition value) {
    m_pipelineExecutionStartConditionHasBeenSet = true;
    m_pipelineExecutionStartCondition = value;
  }
  inline Schedule& WithPipelineExecutionStartCondition(PipelineExecutionStartCondition value) {
    SetPipelineExecutionStartCondition(value);
    return *this;
  }
 
 
  inline const AutoDisablePolicy& GetAutoDisablePolicy() const { return m_autoDisablePolicy; }
  inline bool AutoDisablePolicyHasBeenSet() const { return m_autoDisablePolicyHasBeenSet; }
  template <typename AutoDisablePolicyT = AutoDisablePolicy>
  void SetAutoDisablePolicy(AutoDisablePolicyT&& value) {
    m_autoDisablePolicyHasBeenSet = true;
    m_autoDisablePolicy = std::forward<AutoDisablePolicyT>(value);
  }
  template <typename AutoDisablePolicyT = AutoDisablePolicy>
  Schedule& WithAutoDisablePolicy(AutoDisablePolicyT&& value) {
    SetAutoDisablePolicy(std::forward<AutoDisablePolicyT>(value));
    return *this;
  }
 private:
  Aws::String m_scheduleExpression;
 
  Aws::String m_timezone;
 
  PipelineExecutionStartCondition m_pipelineExecutionStartCondition{PipelineExecutionStartCondition::NOT_SET};
 
  AutoDisablePolicy m_autoDisablePolicy;
  bool m_scheduleExpressionHasBeenSet = false;
  bool m_timezoneHasBeenSet = false;
  bool m_pipelineExecutionStartConditionHasBeenSet = false;
  bool m_autoDisablePolicyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace imagebuilder
}  // namespace Aws