SearchExpression.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/BooleanOperator.h>
#include <aws/sagemaker/model/Filter.h>
#include <aws/sagemaker/model/NestedFilters.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class SearchExpression {
 public:
  AWS_SAGEMAKER_API SearchExpression() = default;
  AWS_SAGEMAKER_API SearchExpression(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API SearchExpression& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Filter>& GetFilters() const { return m_filters; }
  inline bool FiltersHasBeenSet() const { return m_filtersHasBeenSet; }
  template <typename FiltersT = Aws::Vector<Filter>>
  void SetFilters(FiltersT&& value) {
    m_filtersHasBeenSet = true;
    m_filters = std::forward<FiltersT>(value);
  }
  template <typename FiltersT = Aws::Vector<Filter>>
  SearchExpression& WithFilters(FiltersT&& value) {
    SetFilters(std::forward<FiltersT>(value));
    return *this;
  }
  template <typename FiltersT = Filter>
  SearchExpression& AddFilters(FiltersT&& value) {
    m_filtersHasBeenSet = true;
    m_filters.emplace_back(std::forward<FiltersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<NestedFilters>& GetNestedFilters() const { return m_nestedFilters; }
  inline bool NestedFiltersHasBeenSet() const { return m_nestedFiltersHasBeenSet; }
  template <typename NestedFiltersT = Aws::Vector<NestedFilters>>
  void SetNestedFilters(NestedFiltersT&& value) {
    m_nestedFiltersHasBeenSet = true;
    m_nestedFilters = std::forward<NestedFiltersT>(value);
  }
  template <typename NestedFiltersT = Aws::Vector<NestedFilters>>
  SearchExpression& WithNestedFilters(NestedFiltersT&& value) {
    SetNestedFilters(std::forward<NestedFiltersT>(value));
    return *this;
  }
  template <typename NestedFiltersT = NestedFilters>
  SearchExpression& AddNestedFilters(NestedFiltersT&& value) {
    m_nestedFiltersHasBeenSet = true;
    m_nestedFilters.emplace_back(std::forward<NestedFiltersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SearchExpression>& GetSubExpressions() const { return m_subExpressions; }
  inline bool SubExpressionsHasBeenSet() const { return m_subExpressionsHasBeenSet; }
  template <typename SubExpressionsT = Aws::Vector<SearchExpression>>
  void SetSubExpressions(SubExpressionsT&& value) {
    m_subExpressionsHasBeenSet = true;
    m_subExpressions = std::forward<SubExpressionsT>(value);
  }
  template <typename SubExpressionsT = Aws::Vector<SearchExpression>>
  SearchExpression& WithSubExpressions(SubExpressionsT&& value) {
    SetSubExpressions(std::forward<SubExpressionsT>(value));
    return *this;
  }
  template <typename SubExpressionsT = SearchExpression>
  SearchExpression& AddSubExpressions(SubExpressionsT&& value) {
    m_subExpressionsHasBeenSet = true;
    m_subExpressions.emplace_back(std::forward<SubExpressionsT>(value));
    return *this;
  }
 
 
  inline BooleanOperator GetOperator() const { return m_operator; }
  inline bool OperatorHasBeenSet() const { return m_operatorHasBeenSet; }
  inline void SetOperator(BooleanOperator value) {
    m_operatorHasBeenSet = true;
    m_operator = value;
  }
  inline SearchExpression& WithOperator(BooleanOperator value) {
    SetOperator(value);
    return *this;
  }
 private:
  Aws::Vector<Filter> m_filters;
 
  Aws::Vector<NestedFilters> m_nestedFilters;
 
  Aws::Vector<SearchExpression> m_subExpressions;
 
  BooleanOperator m_operator{BooleanOperator::NOT_SET};
  bool m_filtersHasBeenSet = false;
  bool m_nestedFiltersHasBeenSet = false;
  bool m_subExpressionsHasBeenSet = false;
  bool m_operatorHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws