Validation.h

 
#pragma once
#include <aws/connect/Connect_EXPORTS.h>
#include <aws/connect/model/ValidationEnum.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Connect {
namespace Model {
 
class Validation {
 public:
  AWS_CONNECT_API Validation() = default;
  AWS_CONNECT_API Validation(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONNECT_API Validation& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CONNECT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetMinLength() const { return m_minLength; }
  inline bool MinLengthHasBeenSet() const { return m_minLengthHasBeenSet; }
  inline void SetMinLength(int value) {
    m_minLengthHasBeenSet = true;
    m_minLength = value;
  }
  inline Validation& WithMinLength(int value) {
    SetMinLength(value);
    return *this;
  }
 
 
  inline int GetMaxLength() const { return m_maxLength; }
  inline bool MaxLengthHasBeenSet() const { return m_maxLengthHasBeenSet; }
  inline void SetMaxLength(int value) {
    m_maxLengthHasBeenSet = true;
    m_maxLength = value;
  }
  inline Validation& WithMaxLength(int value) {
    SetMaxLength(value);
    return *this;
  }
 
 
  inline int GetMinValues() const { return m_minValues; }
  inline bool MinValuesHasBeenSet() const { return m_minValuesHasBeenSet; }
  inline void SetMinValues(int value) {
    m_minValuesHasBeenSet = true;
    m_minValues = value;
  }
  inline Validation& WithMinValues(int value) {
    SetMinValues(value);
    return *this;
  }
 
 
  inline int GetMaxValues() const { return m_maxValues; }
  inline bool MaxValuesHasBeenSet() const { return m_maxValuesHasBeenSet; }
  inline void SetMaxValues(int value) {
    m_maxValuesHasBeenSet = true;
    m_maxValues = value;
  }
  inline Validation& WithMaxValues(int value) {
    SetMaxValues(value);
    return *this;
  }
 
 
  inline bool GetIgnoreCase() const { return m_ignoreCase; }
  inline bool IgnoreCaseHasBeenSet() const { return m_ignoreCaseHasBeenSet; }
  inline void SetIgnoreCase(bool value) {
    m_ignoreCaseHasBeenSet = true;
    m_ignoreCase = value;
  }
  inline Validation& WithIgnoreCase(bool value) {
    SetIgnoreCase(value);
    return *this;
  }
 
 
  inline double GetMinimum() const { return m_minimum; }
  inline bool MinimumHasBeenSet() const { return m_minimumHasBeenSet; }
  inline void SetMinimum(double value) {
    m_minimumHasBeenSet = true;
    m_minimum = value;
  }
  inline Validation& WithMinimum(double value) {
    SetMinimum(value);
    return *this;
  }
 
 
  inline double GetMaximum() const { return m_maximum; }
  inline bool MaximumHasBeenSet() const { return m_maximumHasBeenSet; }
  inline void SetMaximum(double value) {
    m_maximumHasBeenSet = true;
    m_maximum = value;
  }
  inline Validation& WithMaximum(double value) {
    SetMaximum(value);
    return *this;
  }
 
 
  inline double GetExclusiveMinimum() const { return m_exclusiveMinimum; }
  inline bool ExclusiveMinimumHasBeenSet() const { return m_exclusiveMinimumHasBeenSet; }
  inline void SetExclusiveMinimum(double value) {
    m_exclusiveMinimumHasBeenSet = true;
    m_exclusiveMinimum = value;
  }
  inline Validation& WithExclusiveMinimum(double value) {
    SetExclusiveMinimum(value);
    return *this;
  }
 
 
  inline double GetExclusiveMaximum() const { return m_exclusiveMaximum; }
  inline bool ExclusiveMaximumHasBeenSet() const { return m_exclusiveMaximumHasBeenSet; }
  inline void SetExclusiveMaximum(double value) {
    m_exclusiveMaximumHasBeenSet = true;
    m_exclusiveMaximum = value;
  }
  inline Validation& WithExclusiveMaximum(double value) {
    SetExclusiveMaximum(value);
    return *this;
  }
 
 
  inline double GetMultipleOf() const { return m_multipleOf; }
  inline bool MultipleOfHasBeenSet() const { return m_multipleOfHasBeenSet; }
  inline void SetMultipleOf(double value) {
    m_multipleOfHasBeenSet = true;
    m_multipleOf = value;
  }
  inline Validation& WithMultipleOf(double value) {
    SetMultipleOf(value);
    return *this;
  }
 
 
  inline const ValidationEnum& GetEnum() const { return m_enum; }
  inline bool EnumHasBeenSet() const { return m_enumHasBeenSet; }
  template <typename EnumT = ValidationEnum>
  void SetEnum(EnumT&& value) {
    m_enumHasBeenSet = true;
    m_enum = std::forward<EnumT>(value);
  }
  template <typename EnumT = ValidationEnum>
  Validation& WithEnum(EnumT&& value) {
    SetEnum(std::forward<EnumT>(value));
    return *this;
  }
 private:
  int m_minLength{0};
 
  int m_maxLength{0};
 
  int m_minValues{0};
 
  int m_maxValues{0};
 
  bool m_ignoreCase{false};
 
  double m_minimum{0.0};
 
  double m_maximum{0.0};
 
  double m_exclusiveMinimum{0.0};
 
  double m_exclusiveMaximum{0.0};
 
  double m_multipleOf{0.0};
 
  ValidationEnum m_enum;
  bool m_minLengthHasBeenSet = false;
  bool m_maxLengthHasBeenSet = false;
  bool m_minValuesHasBeenSet = false;
  bool m_maxValuesHasBeenSet = false;
  bool m_ignoreCaseHasBeenSet = false;
  bool m_minimumHasBeenSet = false;
  bool m_maximumHasBeenSet = false;
  bool m_exclusiveMinimumHasBeenSet = false;
  bool m_exclusiveMaximumHasBeenSet = false;
  bool m_multipleOfHasBeenSet = false;
  bool m_enumHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Connect
}  // namespace Aws