ParameterConstraints.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/crt/cbor/Cbor.h>
#include <aws/servicecatalog/ServiceCatalog_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Cbor {
class CborValue;
}  // namespace Cbor
}  // namespace Utils
namespace ServiceCatalog {
namespace Model {
 
class ParameterConstraints {
 public:
  AWS_SERVICECATALOG_API ParameterConstraints() = default;
  AWS_SERVICECATALOG_API ParameterConstraints(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_SERVICECATALOG_API ParameterConstraints& operator=(const std::shared_ptr<Aws::Crt::Cbor::CborDecoder>& decoder);
  AWS_SERVICECATALOG_API void CborEncode(Aws::Crt::Cbor::CborEncoder& encoder) const;
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedValues() const { return m_allowedValues; }
  inline bool AllowedValuesHasBeenSet() const { return m_allowedValuesHasBeenSet; }
  template <typename AllowedValuesT = Aws::Vector<Aws::String>>
  void SetAllowedValues(AllowedValuesT&& value) {
    m_allowedValuesHasBeenSet = true;
    m_allowedValues = std::forward<AllowedValuesT>(value);
  }
  template <typename AllowedValuesT = Aws::Vector<Aws::String>>
  ParameterConstraints& WithAllowedValues(AllowedValuesT&& value) {
    SetAllowedValues(std::forward<AllowedValuesT>(value));
    return *this;
  }
  template <typename AllowedValuesT = Aws::String>
  ParameterConstraints& AddAllowedValues(AllowedValuesT&& value) {
    m_allowedValuesHasBeenSet = true;
    m_allowedValues.emplace_back(std::forward<AllowedValuesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAllowedPattern() const { return m_allowedPattern; }
  inline bool AllowedPatternHasBeenSet() const { return m_allowedPatternHasBeenSet; }
  template <typename AllowedPatternT = Aws::String>
  void SetAllowedPattern(AllowedPatternT&& value) {
    m_allowedPatternHasBeenSet = true;
    m_allowedPattern = std::forward<AllowedPatternT>(value);
  }
  template <typename AllowedPatternT = Aws::String>
  ParameterConstraints& WithAllowedPattern(AllowedPatternT&& value) {
    SetAllowedPattern(std::forward<AllowedPatternT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConstraintDescription() const { return m_constraintDescription; }
  inline bool ConstraintDescriptionHasBeenSet() const { return m_constraintDescriptionHasBeenSet; }
  template <typename ConstraintDescriptionT = Aws::String>
  void SetConstraintDescription(ConstraintDescriptionT&& value) {
    m_constraintDescriptionHasBeenSet = true;
    m_constraintDescription = std::forward<ConstraintDescriptionT>(value);
  }
  template <typename ConstraintDescriptionT = Aws::String>
  ParameterConstraints& WithConstraintDescription(ConstraintDescriptionT&& value) {
    SetConstraintDescription(std::forward<ConstraintDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaxLength() const { return m_maxLength; }
  inline bool MaxLengthHasBeenSet() const { return m_maxLengthHasBeenSet; }
  template <typename MaxLengthT = Aws::String>
  void SetMaxLength(MaxLengthT&& value) {
    m_maxLengthHasBeenSet = true;
    m_maxLength = std::forward<MaxLengthT>(value);
  }
  template <typename MaxLengthT = Aws::String>
  ParameterConstraints& WithMaxLength(MaxLengthT&& value) {
    SetMaxLength(std::forward<MaxLengthT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMinLength() const { return m_minLength; }
  inline bool MinLengthHasBeenSet() const { return m_minLengthHasBeenSet; }
  template <typename MinLengthT = Aws::String>
  void SetMinLength(MinLengthT&& value) {
    m_minLengthHasBeenSet = true;
    m_minLength = std::forward<MinLengthT>(value);
  }
  template <typename MinLengthT = Aws::String>
  ParameterConstraints& WithMinLength(MinLengthT&& value) {
    SetMinLength(std::forward<MinLengthT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMaxValue() const { return m_maxValue; }
  inline bool MaxValueHasBeenSet() const { return m_maxValueHasBeenSet; }
  template <typename MaxValueT = Aws::String>
  void SetMaxValue(MaxValueT&& value) {
    m_maxValueHasBeenSet = true;
    m_maxValue = std::forward<MaxValueT>(value);
  }
  template <typename MaxValueT = Aws::String>
  ParameterConstraints& WithMaxValue(MaxValueT&& value) {
    SetMaxValue(std::forward<MaxValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMinValue() const { return m_minValue; }
  inline bool MinValueHasBeenSet() const { return m_minValueHasBeenSet; }
  template <typename MinValueT = Aws::String>
  void SetMinValue(MinValueT&& value) {
    m_minValueHasBeenSet = true;
    m_minValue = std::forward<MinValueT>(value);
  }
  template <typename MinValueT = Aws::String>
  ParameterConstraints& WithMinValue(MinValueT&& value) {
    SetMinValue(std::forward<MinValueT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_allowedValues;
 
  Aws::String m_allowedPattern;
 
  Aws::String m_constraintDescription;
 
  Aws::String m_maxLength;
 
  Aws::String m_minLength;
 
  Aws::String m_maxValue;
 
  Aws::String m_minValue;
  bool m_allowedValuesHasBeenSet = false;
  bool m_allowedPatternHasBeenSet = false;
  bool m_constraintDescriptionHasBeenSet = false;
  bool m_maxLengthHasBeenSet = false;
  bool m_minLengthHasBeenSet = false;
  bool m_maxValueHasBeenSet = false;
  bool m_minValueHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ServiceCatalog
}  // namespace Aws