AlarmState.h

 
#pragma once
#include <aws/iotevents-data/IoTEventsData_EXPORTS.h>
#include <aws/iotevents-data/model/AlarmStateName.h>
#include <aws/iotevents-data/model/RuleEvaluation.h>
#include <aws/iotevents-data/model/CustomerAction.h>
#include <aws/iotevents-data/model/SystemEvent.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace IoTEventsData
{
namespace Model
{
 
  class AlarmState
  {
  public:
    AWS_IOTEVENTSDATA_API AlarmState() = default;
    AWS_IOTEVENTSDATA_API AlarmState(Aws::Utils::Json::JsonView jsonValue);
    AWS_IOTEVENTSDATA_API AlarmState& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_IOTEVENTSDATA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline AlarmStateName GetStateName() const { return m_stateName; }
    inline bool StateNameHasBeenSet() const { return m_stateNameHasBeenSet; }
    inline void SetStateName(AlarmStateName value) { m_stateNameHasBeenSet = true; m_stateName = value; }
    inline AlarmState& WithStateName(AlarmStateName value) { SetStateName(value); return *this;}
 
 
    inline const RuleEvaluation& GetRuleEvaluation() const { return m_ruleEvaluation; }
    inline bool RuleEvaluationHasBeenSet() const { return m_ruleEvaluationHasBeenSet; }
    template<typename RuleEvaluationT = RuleEvaluation>
    void SetRuleEvaluation(RuleEvaluationT&& value) { m_ruleEvaluationHasBeenSet = true; m_ruleEvaluation = std::forward<RuleEvaluationT>(value); }
    template<typename RuleEvaluationT = RuleEvaluation>
    AlarmState& WithRuleEvaluation(RuleEvaluationT&& value) { SetRuleEvaluation(std::forward<RuleEvaluationT>(value)); return *this;}
 
 
    inline const CustomerAction& GetCustomerAction() const { return m_customerAction; }
    inline bool CustomerActionHasBeenSet() const { return m_customerActionHasBeenSet; }
    template<typename CustomerActionT = CustomerAction>
    void SetCustomerAction(CustomerActionT&& value) { m_customerActionHasBeenSet = true; m_customerAction = std::forward<CustomerActionT>(value); }
    template<typename CustomerActionT = CustomerAction>
    AlarmState& WithCustomerAction(CustomerActionT&& value) { SetCustomerAction(std::forward<CustomerActionT>(value)); return *this;}
 
 
    inline const SystemEvent& GetSystemEvent() const { return m_systemEvent; }
    inline bool SystemEventHasBeenSet() const { return m_systemEventHasBeenSet; }
    template<typename SystemEventT = SystemEvent>
    void SetSystemEvent(SystemEventT&& value) { m_systemEventHasBeenSet = true; m_systemEvent = std::forward<SystemEventT>(value); }
    template<typename SystemEventT = SystemEvent>
    AlarmState& WithSystemEvent(SystemEventT&& value) { SetSystemEvent(std::forward<SystemEventT>(value)); return *this;}
  private:
 
    AlarmStateName m_stateName{AlarmStateName::NOT_SET};
    bool m_stateNameHasBeenSet = false;
 
    RuleEvaluation m_ruleEvaluation;
    bool m_ruleEvaluationHasBeenSet = false;
 
    CustomerAction m_customerAction;
    bool m_customerActionHasBeenSet = false;
 
    SystemEvent m_systemEvent;
    bool m_systemEventHasBeenSet = false;
  };
 
} // namespace Model
} // namespace IoTEventsData
} // namespace Aws