AnalysisRuleCustom.h

 
#pragma once
#include <aws/cleanrooms/CleanRooms_EXPORTS.h>
#include <aws/cleanrooms/model/AdditionalAnalyses.h>
#include <aws/cleanrooms/model/AggregationThreshold.h>
#include <aws/cleanrooms/model/ComparisonControls.h>
#include <aws/cleanrooms/model/DifferentialPrivacyConfiguration.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 AnalysisRuleCustom {
 public:
  AWS_CLEANROOMS_API AnalysisRuleCustom() = default;
  AWS_CLEANROOMS_API AnalysisRuleCustom(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLEANROOMS_API AnalysisRuleCustom& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_CLEANROOMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedAnalyses() const { return m_allowedAnalyses; }
  inline bool AllowedAnalysesHasBeenSet() const { return m_allowedAnalysesHasBeenSet; }
  template <typename AllowedAnalysesT = Aws::Vector<Aws::String>>
  void SetAllowedAnalyses(AllowedAnalysesT&& value) {
    m_allowedAnalysesHasBeenSet = true;
    m_allowedAnalyses = std::forward<AllowedAnalysesT>(value);
  }
  template <typename AllowedAnalysesT = Aws::Vector<Aws::String>>
  AnalysisRuleCustom& WithAllowedAnalyses(AllowedAnalysesT&& value) {
    SetAllowedAnalyses(std::forward<AllowedAnalysesT>(value));
    return *this;
  }
  template <typename AllowedAnalysesT = Aws::String>
  AnalysisRuleCustom& AddAllowedAnalyses(AllowedAnalysesT&& value) {
    m_allowedAnalysesHasBeenSet = true;
    m_allowedAnalyses.emplace_back(std::forward<AllowedAnalysesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedAnalysisProviders() const { return m_allowedAnalysisProviders; }
  inline bool AllowedAnalysisProvidersHasBeenSet() const { return m_allowedAnalysisProvidersHasBeenSet; }
  template <typename AllowedAnalysisProvidersT = Aws::Vector<Aws::String>>
  void SetAllowedAnalysisProviders(AllowedAnalysisProvidersT&& value) {
    m_allowedAnalysisProvidersHasBeenSet = true;
    m_allowedAnalysisProviders = std::forward<AllowedAnalysisProvidersT>(value);
  }
  template <typename AllowedAnalysisProvidersT = Aws::Vector<Aws::String>>
  AnalysisRuleCustom& WithAllowedAnalysisProviders(AllowedAnalysisProvidersT&& value) {
    SetAllowedAnalysisProviders(std::forward<AllowedAnalysisProvidersT>(value));
    return *this;
  }
  template <typename AllowedAnalysisProvidersT = Aws::String>
  AnalysisRuleCustom& AddAllowedAnalysisProviders(AllowedAnalysisProvidersT&& value) {
    m_allowedAnalysisProvidersHasBeenSet = true;
    m_allowedAnalysisProviders.emplace_back(std::forward<AllowedAnalysisProvidersT>(value));
    return *this;
  }
 
 
  inline AdditionalAnalyses GetAdditionalAnalyses() const { return m_additionalAnalyses; }
  inline bool AdditionalAnalysesHasBeenSet() const { return m_additionalAnalysesHasBeenSet; }
  inline void SetAdditionalAnalyses(AdditionalAnalyses value) {
    m_additionalAnalysesHasBeenSet = true;
    m_additionalAnalyses = value;
  }
  inline AnalysisRuleCustom& WithAdditionalAnalyses(AdditionalAnalyses value) {
    SetAdditionalAnalyses(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetDisallowedOutputColumns() const { return m_disallowedOutputColumns; }
  inline bool DisallowedOutputColumnsHasBeenSet() const { return m_disallowedOutputColumnsHasBeenSet; }
  template <typename DisallowedOutputColumnsT = Aws::Vector<Aws::String>>
  void SetDisallowedOutputColumns(DisallowedOutputColumnsT&& value) {
    m_disallowedOutputColumnsHasBeenSet = true;
    m_disallowedOutputColumns = std::forward<DisallowedOutputColumnsT>(value);
  }
  template <typename DisallowedOutputColumnsT = Aws::Vector<Aws::String>>
  AnalysisRuleCustom& WithDisallowedOutputColumns(DisallowedOutputColumnsT&& value) {
    SetDisallowedOutputColumns(std::forward<DisallowedOutputColumnsT>(value));
    return *this;
  }
  template <typename DisallowedOutputColumnsT = Aws::String>
  AnalysisRuleCustom& AddDisallowedOutputColumns(DisallowedOutputColumnsT&& value) {
    m_disallowedOutputColumnsHasBeenSet = true;
    m_disallowedOutputColumns.emplace_back(std::forward<DisallowedOutputColumnsT>(value));
    return *this;
  }
 
 
  inline const DifferentialPrivacyConfiguration& GetDifferentialPrivacy() const { return m_differentialPrivacy; }
  inline bool DifferentialPrivacyHasBeenSet() const { return m_differentialPrivacyHasBeenSet; }
  template <typename DifferentialPrivacyT = DifferentialPrivacyConfiguration>
  void SetDifferentialPrivacy(DifferentialPrivacyT&& value) {
    m_differentialPrivacyHasBeenSet = true;
    m_differentialPrivacy = std::forward<DifferentialPrivacyT>(value);
  }
  template <typename DifferentialPrivacyT = DifferentialPrivacyConfiguration>
  AnalysisRuleCustom& WithDifferentialPrivacy(DifferentialPrivacyT&& value) {
    SetDifferentialPrivacy(std::forward<DifferentialPrivacyT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AggregationThreshold>& GetAggregationThresholds() const { return m_aggregationThresholds; }
  inline bool AggregationThresholdsHasBeenSet() const { return m_aggregationThresholdsHasBeenSet; }
  template <typename AggregationThresholdsT = Aws::Vector<AggregationThreshold>>
  void SetAggregationThresholds(AggregationThresholdsT&& value) {
    m_aggregationThresholdsHasBeenSet = true;
    m_aggregationThresholds = std::forward<AggregationThresholdsT>(value);
  }
  template <typename AggregationThresholdsT = Aws::Vector<AggregationThreshold>>
  AnalysisRuleCustom& WithAggregationThresholds(AggregationThresholdsT&& value) {
    SetAggregationThresholds(std::forward<AggregationThresholdsT>(value));
    return *this;
  }
  template <typename AggregationThresholdsT = AggregationThreshold>
  AnalysisRuleCustom& AddAggregationThresholds(AggregationThresholdsT&& value) {
    m_aggregationThresholdsHasBeenSet = true;
    m_aggregationThresholds.emplace_back(std::forward<AggregationThresholdsT>(value));
    return *this;
  }
 
 
  inline const ComparisonControls& GetComparisonControls() const { return m_comparisonControls; }
  inline bool ComparisonControlsHasBeenSet() const { return m_comparisonControlsHasBeenSet; }
  template <typename ComparisonControlsT = ComparisonControls>
  void SetComparisonControls(ComparisonControlsT&& value) {
    m_comparisonControlsHasBeenSet = true;
    m_comparisonControls = std::forward<ComparisonControlsT>(value);
  }
  template <typename ComparisonControlsT = ComparisonControls>
  AnalysisRuleCustom& WithComparisonControls(ComparisonControlsT&& value) {
    SetComparisonControls(std::forward<ComparisonControlsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedResultReceivers() const { return m_allowedResultReceivers; }
  inline bool AllowedResultReceiversHasBeenSet() const { return m_allowedResultReceiversHasBeenSet; }
  template <typename AllowedResultReceiversT = Aws::Vector<Aws::String>>
  void SetAllowedResultReceivers(AllowedResultReceiversT&& value) {
    m_allowedResultReceiversHasBeenSet = true;
    m_allowedResultReceivers = std::forward<AllowedResultReceiversT>(value);
  }
  template <typename AllowedResultReceiversT = Aws::Vector<Aws::String>>
  AnalysisRuleCustom& WithAllowedResultReceivers(AllowedResultReceiversT&& value) {
    SetAllowedResultReceivers(std::forward<AllowedResultReceiversT>(value));
    return *this;
  }
  template <typename AllowedResultReceiversT = Aws::String>
  AnalysisRuleCustom& AddAllowedResultReceivers(AllowedResultReceiversT&& value) {
    m_allowedResultReceiversHasBeenSet = true;
    m_allowedResultReceivers.emplace_back(std::forward<AllowedResultReceiversT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedAdditionalAnalyses() const { return m_allowedAdditionalAnalyses; }
  inline bool AllowedAdditionalAnalysesHasBeenSet() const { return m_allowedAdditionalAnalysesHasBeenSet; }
  template <typename AllowedAdditionalAnalysesT = Aws::Vector<Aws::String>>
  void SetAllowedAdditionalAnalyses(AllowedAdditionalAnalysesT&& value) {
    m_allowedAdditionalAnalysesHasBeenSet = true;
    m_allowedAdditionalAnalyses = std::forward<AllowedAdditionalAnalysesT>(value);
  }
  template <typename AllowedAdditionalAnalysesT = Aws::Vector<Aws::String>>
  AnalysisRuleCustom& WithAllowedAdditionalAnalyses(AllowedAdditionalAnalysesT&& value) {
    SetAllowedAdditionalAnalyses(std::forward<AllowedAdditionalAnalysesT>(value));
    return *this;
  }
  template <typename AllowedAdditionalAnalysesT = Aws::String>
  AnalysisRuleCustom& AddAllowedAdditionalAnalyses(AllowedAdditionalAnalysesT&& value) {
    m_allowedAdditionalAnalysesHasBeenSet = true;
    m_allowedAdditionalAnalyses.emplace_back(std::forward<AllowedAdditionalAnalysesT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_allowedAnalyses;
 
  Aws::Vector<Aws::String> m_allowedAnalysisProviders;
 
  AdditionalAnalyses m_additionalAnalyses{AdditionalAnalyses::NOT_SET};
 
  Aws::Vector<Aws::String> m_disallowedOutputColumns;
 
  DifferentialPrivacyConfiguration m_differentialPrivacy;
 
  Aws::Vector<AggregationThreshold> m_aggregationThresholds;
 
  ComparisonControls m_comparisonControls;
 
  Aws::Vector<Aws::String> m_allowedResultReceivers;
 
  Aws::Vector<Aws::String> m_allowedAdditionalAnalyses;
  bool m_allowedAnalysesHasBeenSet = false;
  bool m_allowedAnalysisProvidersHasBeenSet = false;
  bool m_additionalAnalysesHasBeenSet = false;
  bool m_disallowedOutputColumnsHasBeenSet = false;
  bool m_differentialPrivacyHasBeenSet = false;
  bool m_aggregationThresholdsHasBeenSet = false;
  bool m_comparisonControlsHasBeenSet = false;
  bool m_allowedResultReceiversHasBeenSet = false;
  bool m_allowedAdditionalAnalysesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CleanRooms
}  // namespace Aws