BehaviorCriteria.h

 
#pragma once
#include <aws/iot/IoT_EXPORTS.h>
#include <aws/iot/model/ComparisonOperator.h>
#include <aws/iot/model/MachineLearningDetectionConfig.h>
#include <aws/iot/model/MetricValue.h>
#include <aws/iot/model/StatisticalThreshold.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace IoT {
namespace Model {
 
class BehaviorCriteria {
 public:
  AWS_IOT_API BehaviorCriteria() = default;
  AWS_IOT_API BehaviorCriteria(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API BehaviorCriteria& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_IOT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline ComparisonOperator GetComparisonOperator() const { return m_comparisonOperator; }
  inline bool ComparisonOperatorHasBeenSet() const { return m_comparisonOperatorHasBeenSet; }
  inline void SetComparisonOperator(ComparisonOperator value) {
    m_comparisonOperatorHasBeenSet = true;
    m_comparisonOperator = value;
  }
  inline BehaviorCriteria& WithComparisonOperator(ComparisonOperator value) {
    SetComparisonOperator(value);
    return *this;
  }
 
 
  inline const MetricValue& GetValue() const { return m_value; }
  inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
  template <typename ValueT = MetricValue>
  void SetValue(ValueT&& value) {
    m_valueHasBeenSet = true;
    m_value = std::forward<ValueT>(value);
  }
  template <typename ValueT = MetricValue>
  BehaviorCriteria& WithValue(ValueT&& value) {
    SetValue(std::forward<ValueT>(value));
    return *this;
  }
 
 
  inline int GetDurationSeconds() const { return m_durationSeconds; }
  inline bool DurationSecondsHasBeenSet() const { return m_durationSecondsHasBeenSet; }
  inline void SetDurationSeconds(int value) {
    m_durationSecondsHasBeenSet = true;
    m_durationSeconds = value;
  }
  inline BehaviorCriteria& WithDurationSeconds(int value) {
    SetDurationSeconds(value);
    return *this;
  }
 
 
  inline int GetConsecutiveDatapointsToAlarm() const { return m_consecutiveDatapointsToAlarm; }
  inline bool ConsecutiveDatapointsToAlarmHasBeenSet() const { return m_consecutiveDatapointsToAlarmHasBeenSet; }
  inline void SetConsecutiveDatapointsToAlarm(int value) {
    m_consecutiveDatapointsToAlarmHasBeenSet = true;
    m_consecutiveDatapointsToAlarm = value;
  }
  inline BehaviorCriteria& WithConsecutiveDatapointsToAlarm(int value) {
    SetConsecutiveDatapointsToAlarm(value);
    return *this;
  }
 
 
  inline int GetConsecutiveDatapointsToClear() const { return m_consecutiveDatapointsToClear; }
  inline bool ConsecutiveDatapointsToClearHasBeenSet() const { return m_consecutiveDatapointsToClearHasBeenSet; }
  inline void SetConsecutiveDatapointsToClear(int value) {
    m_consecutiveDatapointsToClearHasBeenSet = true;
    m_consecutiveDatapointsToClear = value;
  }
  inline BehaviorCriteria& WithConsecutiveDatapointsToClear(int value) {
    SetConsecutiveDatapointsToClear(value);
    return *this;
  }
 
 
  inline const StatisticalThreshold& GetStatisticalThreshold() const { return m_statisticalThreshold; }
  inline bool StatisticalThresholdHasBeenSet() const { return m_statisticalThresholdHasBeenSet; }
  template <typename StatisticalThresholdT = StatisticalThreshold>
  void SetStatisticalThreshold(StatisticalThresholdT&& value) {
    m_statisticalThresholdHasBeenSet = true;
    m_statisticalThreshold = std::forward<StatisticalThresholdT>(value);
  }
  template <typename StatisticalThresholdT = StatisticalThreshold>
  BehaviorCriteria& WithStatisticalThreshold(StatisticalThresholdT&& value) {
    SetStatisticalThreshold(std::forward<StatisticalThresholdT>(value));
    return *this;
  }
 
 
  inline const MachineLearningDetectionConfig& GetMlDetectionConfig() const { return m_mlDetectionConfig; }
  inline bool MlDetectionConfigHasBeenSet() const { return m_mlDetectionConfigHasBeenSet; }
  template <typename MlDetectionConfigT = MachineLearningDetectionConfig>
  void SetMlDetectionConfig(MlDetectionConfigT&& value) {
    m_mlDetectionConfigHasBeenSet = true;
    m_mlDetectionConfig = std::forward<MlDetectionConfigT>(value);
  }
  template <typename MlDetectionConfigT = MachineLearningDetectionConfig>
  BehaviorCriteria& WithMlDetectionConfig(MlDetectionConfigT&& value) {
    SetMlDetectionConfig(std::forward<MlDetectionConfigT>(value));
    return *this;
  }
 private:
  ComparisonOperator m_comparisonOperator{ComparisonOperator::NOT_SET};
 
  MetricValue m_value;
 
  int m_durationSeconds{0};
 
  int m_consecutiveDatapointsToAlarm{0};
 
  int m_consecutiveDatapointsToClear{0};
 
  StatisticalThreshold m_statisticalThreshold;
 
  MachineLearningDetectionConfig m_mlDetectionConfig;
  bool m_comparisonOperatorHasBeenSet = false;
  bool m_valueHasBeenSet = false;
  bool m_durationSecondsHasBeenSet = false;
  bool m_consecutiveDatapointsToAlarmHasBeenSet = false;
  bool m_consecutiveDatapointsToClearHasBeenSet = false;
  bool m_statisticalThresholdHasBeenSet = false;
  bool m_mlDetectionConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace IoT
}  // namespace Aws