AnalysisRuleIdMappingTable.h

 
#pragma once
#include <aws/cleanrooms/CleanRooms_EXPORTS.h>
#include <aws/cleanrooms/model/QueryConstraint.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CleanRooms {
namespace Model {
 
class AnalysisRuleIdMappingTable {
 public:
  AWS_CLEANROOMS_API AnalysisRuleIdMappingTable() = default;
  AWS_CLEANROOMS_API AnalysisRuleIdMappingTable(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLEANROOMS_API AnalysisRuleIdMappingTable& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLEANROOMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetJoinColumns() const { return m_joinColumns; }
  inline bool JoinColumnsHasBeenSet() const { return m_joinColumnsHasBeenSet; }
  template <typename JoinColumnsT = Aws::Vector<Aws::String>>
  void SetJoinColumns(JoinColumnsT&& value) {
    m_joinColumnsHasBeenSet = true;
    m_joinColumns = std::forward<JoinColumnsT>(value);
  }
  template <typename JoinColumnsT = Aws::Vector<Aws::String>>
  AnalysisRuleIdMappingTable& WithJoinColumns(JoinColumnsT&& value) {
    SetJoinColumns(std::forward<JoinColumnsT>(value));
    return *this;
  }
  template <typename JoinColumnsT = Aws::String>
  AnalysisRuleIdMappingTable& AddJoinColumns(JoinColumnsT&& value) {
    m_joinColumnsHasBeenSet = true;
    m_joinColumns.emplace_back(std::forward<JoinColumnsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<QueryConstraint>& GetQueryConstraints() const { return m_queryConstraints; }
  inline bool QueryConstraintsHasBeenSet() const { return m_queryConstraintsHasBeenSet; }
  template <typename QueryConstraintsT = Aws::Vector<QueryConstraint>>
  void SetQueryConstraints(QueryConstraintsT&& value) {
    m_queryConstraintsHasBeenSet = true;
    m_queryConstraints = std::forward<QueryConstraintsT>(value);
  }
  template <typename QueryConstraintsT = Aws::Vector<QueryConstraint>>
  AnalysisRuleIdMappingTable& WithQueryConstraints(QueryConstraintsT&& value) {
    SetQueryConstraints(std::forward<QueryConstraintsT>(value));
    return *this;
  }
  template <typename QueryConstraintsT = QueryConstraint>
  AnalysisRuleIdMappingTable& AddQueryConstraints(QueryConstraintsT&& value) {
    m_queryConstraintsHasBeenSet = true;
    m_queryConstraints.emplace_back(std::forward<QueryConstraintsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetDimensionColumns() const { return m_dimensionColumns; }
  inline bool DimensionColumnsHasBeenSet() const { return m_dimensionColumnsHasBeenSet; }
  template <typename DimensionColumnsT = Aws::Vector<Aws::String>>
  void SetDimensionColumns(DimensionColumnsT&& value) {
    m_dimensionColumnsHasBeenSet = true;
    m_dimensionColumns = std::forward<DimensionColumnsT>(value);
  }
  template <typename DimensionColumnsT = Aws::Vector<Aws::String>>
  AnalysisRuleIdMappingTable& WithDimensionColumns(DimensionColumnsT&& value) {
    SetDimensionColumns(std::forward<DimensionColumnsT>(value));
    return *this;
  }
  template <typename DimensionColumnsT = Aws::String>
  AnalysisRuleIdMappingTable& AddDimensionColumns(DimensionColumnsT&& value) {
    m_dimensionColumnsHasBeenSet = true;
    m_dimensionColumns.emplace_back(std::forward<DimensionColumnsT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_joinColumns;
 
  Aws::Vector<QueryConstraint> m_queryConstraints;
 
  Aws::Vector<Aws::String> m_dimensionColumns;
  bool m_joinColumnsHasBeenSet = false;
  bool m_queryConstraintsHasBeenSet = false;
  bool m_dimensionColumnsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CleanRooms
}  // namespace Aws