TopicCalculatedField.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/AuthorSpecifiedAggregation.h>
#include <aws/quicksight/model/CellValueSynonym.h>
#include <aws/quicksight/model/ColumnDataRole.h>
#include <aws/quicksight/model/ComparativeOrder.h>
#include <aws/quicksight/model/DefaultAggregation.h>
#include <aws/quicksight/model/DefaultFormatting.h>
#include <aws/quicksight/model/SemanticType.h>
#include <aws/quicksight/model/TopicTimeGranularity.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class TopicCalculatedField {
 public:
  AWS_QUICKSIGHT_API TopicCalculatedField() = default;
  AWS_QUICKSIGHT_API TopicCalculatedField(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API TopicCalculatedField& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetCalculatedFieldName() const { return m_calculatedFieldName; }
  inline bool CalculatedFieldNameHasBeenSet() const { return m_calculatedFieldNameHasBeenSet; }
  template <typename CalculatedFieldNameT = Aws::String>
  void SetCalculatedFieldName(CalculatedFieldNameT&& value) {
    m_calculatedFieldNameHasBeenSet = true;
    m_calculatedFieldName = std::forward<CalculatedFieldNameT>(value);
  }
  template <typename CalculatedFieldNameT = Aws::String>
  TopicCalculatedField& WithCalculatedFieldName(CalculatedFieldNameT&& value) {
    SetCalculatedFieldName(std::forward<CalculatedFieldNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCalculatedFieldDescription() const { return m_calculatedFieldDescription; }
  inline bool CalculatedFieldDescriptionHasBeenSet() const { return m_calculatedFieldDescriptionHasBeenSet; }
  template <typename CalculatedFieldDescriptionT = Aws::String>
  void SetCalculatedFieldDescription(CalculatedFieldDescriptionT&& value) {
    m_calculatedFieldDescriptionHasBeenSet = true;
    m_calculatedFieldDescription = std::forward<CalculatedFieldDescriptionT>(value);
  }
  template <typename CalculatedFieldDescriptionT = Aws::String>
  TopicCalculatedField& WithCalculatedFieldDescription(CalculatedFieldDescriptionT&& value) {
    SetCalculatedFieldDescription(std::forward<CalculatedFieldDescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExpression() const { return m_expression; }
  inline bool ExpressionHasBeenSet() const { return m_expressionHasBeenSet; }
  template <typename ExpressionT = Aws::String>
  void SetExpression(ExpressionT&& value) {
    m_expressionHasBeenSet = true;
    m_expression = std::forward<ExpressionT>(value);
  }
  template <typename ExpressionT = Aws::String>
  TopicCalculatedField& WithExpression(ExpressionT&& value) {
    SetExpression(std::forward<ExpressionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCalculatedFieldSynonyms() const { return m_calculatedFieldSynonyms; }
  inline bool CalculatedFieldSynonymsHasBeenSet() const { return m_calculatedFieldSynonymsHasBeenSet; }
  template <typename CalculatedFieldSynonymsT = Aws::Vector<Aws::String>>
  void SetCalculatedFieldSynonyms(CalculatedFieldSynonymsT&& value) {
    m_calculatedFieldSynonymsHasBeenSet = true;
    m_calculatedFieldSynonyms = std::forward<CalculatedFieldSynonymsT>(value);
  }
  template <typename CalculatedFieldSynonymsT = Aws::Vector<Aws::String>>
  TopicCalculatedField& WithCalculatedFieldSynonyms(CalculatedFieldSynonymsT&& value) {
    SetCalculatedFieldSynonyms(std::forward<CalculatedFieldSynonymsT>(value));
    return *this;
  }
  template <typename CalculatedFieldSynonymsT = Aws::String>
  TopicCalculatedField& AddCalculatedFieldSynonyms(CalculatedFieldSynonymsT&& value) {
    m_calculatedFieldSynonymsHasBeenSet = true;
    m_calculatedFieldSynonyms.emplace_back(std::forward<CalculatedFieldSynonymsT>(value));
    return *this;
  }
 
 
  inline bool GetIsIncludedInTopic() const { return m_isIncludedInTopic; }
  inline bool IsIncludedInTopicHasBeenSet() const { return m_isIncludedInTopicHasBeenSet; }
  inline void SetIsIncludedInTopic(bool value) {
    m_isIncludedInTopicHasBeenSet = true;
    m_isIncludedInTopic = value;
  }
  inline TopicCalculatedField& WithIsIncludedInTopic(bool value) {
    SetIsIncludedInTopic(value);
    return *this;
  }
 
 
  inline bool GetDisableIndexing() const { return m_disableIndexing; }
  inline bool DisableIndexingHasBeenSet() const { return m_disableIndexingHasBeenSet; }
  inline void SetDisableIndexing(bool value) {
    m_disableIndexingHasBeenSet = true;
    m_disableIndexing = value;
  }
  inline TopicCalculatedField& WithDisableIndexing(bool value) {
    SetDisableIndexing(value);
    return *this;
  }
 
 
  inline ColumnDataRole GetColumnDataRole() const { return m_columnDataRole; }
  inline bool ColumnDataRoleHasBeenSet() const { return m_columnDataRoleHasBeenSet; }
  inline void SetColumnDataRole(ColumnDataRole value) {
    m_columnDataRoleHasBeenSet = true;
    m_columnDataRole = value;
  }
  inline TopicCalculatedField& WithColumnDataRole(ColumnDataRole value) {
    SetColumnDataRole(value);
    return *this;
  }
 
 
  inline TopicTimeGranularity GetTimeGranularity() const { return m_timeGranularity; }
  inline bool TimeGranularityHasBeenSet() const { return m_timeGranularityHasBeenSet; }
  inline void SetTimeGranularity(TopicTimeGranularity value) {
    m_timeGranularityHasBeenSet = true;
    m_timeGranularity = value;
  }
  inline TopicCalculatedField& WithTimeGranularity(TopicTimeGranularity value) {
    SetTimeGranularity(value);
    return *this;
  }
 
 
  inline const DefaultFormatting& GetDefaultFormatting() const { return m_defaultFormatting; }
  inline bool DefaultFormattingHasBeenSet() const { return m_defaultFormattingHasBeenSet; }
  template <typename DefaultFormattingT = DefaultFormatting>
  void SetDefaultFormatting(DefaultFormattingT&& value) {
    m_defaultFormattingHasBeenSet = true;
    m_defaultFormatting = std::forward<DefaultFormattingT>(value);
  }
  template <typename DefaultFormattingT = DefaultFormatting>
  TopicCalculatedField& WithDefaultFormatting(DefaultFormattingT&& value) {
    SetDefaultFormatting(std::forward<DefaultFormattingT>(value));
    return *this;
  }
 
 
  inline DefaultAggregation GetAggregation() const { return m_aggregation; }
  inline bool AggregationHasBeenSet() const { return m_aggregationHasBeenSet; }
  inline void SetAggregation(DefaultAggregation value) {
    m_aggregationHasBeenSet = true;
    m_aggregation = value;
  }
  inline TopicCalculatedField& WithAggregation(DefaultAggregation value) {
    SetAggregation(value);
    return *this;
  }
 
 
  inline const ComparativeOrder& GetComparativeOrder() const { return m_comparativeOrder; }
  inline bool ComparativeOrderHasBeenSet() const { return m_comparativeOrderHasBeenSet; }
  template <typename ComparativeOrderT = ComparativeOrder>
  void SetComparativeOrder(ComparativeOrderT&& value) {
    m_comparativeOrderHasBeenSet = true;
    m_comparativeOrder = std::forward<ComparativeOrderT>(value);
  }
  template <typename ComparativeOrderT = ComparativeOrder>
  TopicCalculatedField& WithComparativeOrder(ComparativeOrderT&& value) {
    SetComparativeOrder(std::forward<ComparativeOrderT>(value));
    return *this;
  }
 
 
  inline const SemanticType& GetSemanticType() const { return m_semanticType; }
  inline bool SemanticTypeHasBeenSet() const { return m_semanticTypeHasBeenSet; }
  template <typename SemanticTypeT = SemanticType>
  void SetSemanticType(SemanticTypeT&& value) {
    m_semanticTypeHasBeenSet = true;
    m_semanticType = std::forward<SemanticTypeT>(value);
  }
  template <typename SemanticTypeT = SemanticType>
  TopicCalculatedField& WithSemanticType(SemanticTypeT&& value) {
    SetSemanticType(std::forward<SemanticTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AuthorSpecifiedAggregation>& GetAllowedAggregations() const { return m_allowedAggregations; }
  inline bool AllowedAggregationsHasBeenSet() const { return m_allowedAggregationsHasBeenSet; }
  template <typename AllowedAggregationsT = Aws::Vector<AuthorSpecifiedAggregation>>
  void SetAllowedAggregations(AllowedAggregationsT&& value) {
    m_allowedAggregationsHasBeenSet = true;
    m_allowedAggregations = std::forward<AllowedAggregationsT>(value);
  }
  template <typename AllowedAggregationsT = Aws::Vector<AuthorSpecifiedAggregation>>
  TopicCalculatedField& WithAllowedAggregations(AllowedAggregationsT&& value) {
    SetAllowedAggregations(std::forward<AllowedAggregationsT>(value));
    return *this;
  }
  inline TopicCalculatedField& AddAllowedAggregations(AuthorSpecifiedAggregation value) {
    m_allowedAggregationsHasBeenSet = true;
    m_allowedAggregations.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<AuthorSpecifiedAggregation>& GetNotAllowedAggregations() const { return m_notAllowedAggregations; }
  inline bool NotAllowedAggregationsHasBeenSet() const { return m_notAllowedAggregationsHasBeenSet; }
  template <typename NotAllowedAggregationsT = Aws::Vector<AuthorSpecifiedAggregation>>
  void SetNotAllowedAggregations(NotAllowedAggregationsT&& value) {
    m_notAllowedAggregationsHasBeenSet = true;
    m_notAllowedAggregations = std::forward<NotAllowedAggregationsT>(value);
  }
  template <typename NotAllowedAggregationsT = Aws::Vector<AuthorSpecifiedAggregation>>
  TopicCalculatedField& WithNotAllowedAggregations(NotAllowedAggregationsT&& value) {
    SetNotAllowedAggregations(std::forward<NotAllowedAggregationsT>(value));
    return *this;
  }
  inline TopicCalculatedField& AddNotAllowedAggregations(AuthorSpecifiedAggregation value) {
    m_notAllowedAggregationsHasBeenSet = true;
    m_notAllowedAggregations.push_back(value);
    return *this;
  }
 
 
  inline bool GetNeverAggregateInFilter() const { return m_neverAggregateInFilter; }
  inline bool NeverAggregateInFilterHasBeenSet() const { return m_neverAggregateInFilterHasBeenSet; }
  inline void SetNeverAggregateInFilter(bool value) {
    m_neverAggregateInFilterHasBeenSet = true;
    m_neverAggregateInFilter = value;
  }
  inline TopicCalculatedField& WithNeverAggregateInFilter(bool value) {
    SetNeverAggregateInFilter(value);
    return *this;
  }
 
 
  inline const Aws::Vector<CellValueSynonym>& GetCellValueSynonyms() const { return m_cellValueSynonyms; }
  inline bool CellValueSynonymsHasBeenSet() const { return m_cellValueSynonymsHasBeenSet; }
  template <typename CellValueSynonymsT = Aws::Vector<CellValueSynonym>>
  void SetCellValueSynonyms(CellValueSynonymsT&& value) {
    m_cellValueSynonymsHasBeenSet = true;
    m_cellValueSynonyms = std::forward<CellValueSynonymsT>(value);
  }
  template <typename CellValueSynonymsT = Aws::Vector<CellValueSynonym>>
  TopicCalculatedField& WithCellValueSynonyms(CellValueSynonymsT&& value) {
    SetCellValueSynonyms(std::forward<CellValueSynonymsT>(value));
    return *this;
  }
  template <typename CellValueSynonymsT = CellValueSynonym>
  TopicCalculatedField& AddCellValueSynonyms(CellValueSynonymsT&& value) {
    m_cellValueSynonymsHasBeenSet = true;
    m_cellValueSynonyms.emplace_back(std::forward<CellValueSynonymsT>(value));
    return *this;
  }
 
 
  inline bool GetNonAdditive() const { return m_nonAdditive; }
  inline bool NonAdditiveHasBeenSet() const { return m_nonAdditiveHasBeenSet; }
  inline void SetNonAdditive(bool value) {
    m_nonAdditiveHasBeenSet = true;
    m_nonAdditive = value;
  }
  inline TopicCalculatedField& WithNonAdditive(bool value) {
    SetNonAdditive(value);
    return *this;
  }
 private:
  Aws::String m_calculatedFieldName;
 
  Aws::String m_calculatedFieldDescription;
 
  Aws::String m_expression;
 
  Aws::Vector<Aws::String> m_calculatedFieldSynonyms;
 
  bool m_isIncludedInTopic{false};
 
  bool m_disableIndexing{false};
 
  ColumnDataRole m_columnDataRole{ColumnDataRole::NOT_SET};
 
  TopicTimeGranularity m_timeGranularity{TopicTimeGranularity::NOT_SET};
 
  DefaultFormatting m_defaultFormatting;
 
  DefaultAggregation m_aggregation{DefaultAggregation::NOT_SET};
 
  ComparativeOrder m_comparativeOrder;
 
  SemanticType m_semanticType;
 
  Aws::Vector<AuthorSpecifiedAggregation> m_allowedAggregations;
 
  Aws::Vector<AuthorSpecifiedAggregation> m_notAllowedAggregations;
 
  bool m_neverAggregateInFilter{false};
 
  Aws::Vector<CellValueSynonym> m_cellValueSynonyms;
 
  bool m_nonAdditive{false};
  bool m_calculatedFieldNameHasBeenSet = false;
  bool m_calculatedFieldDescriptionHasBeenSet = false;
  bool m_expressionHasBeenSet = false;
  bool m_calculatedFieldSynonymsHasBeenSet = false;
  bool m_isIncludedInTopicHasBeenSet = false;
  bool m_disableIndexingHasBeenSet = false;
  bool m_columnDataRoleHasBeenSet = false;
  bool m_timeGranularityHasBeenSet = false;
  bool m_defaultFormattingHasBeenSet = false;
  bool m_aggregationHasBeenSet = false;
  bool m_comparativeOrderHasBeenSet = false;
  bool m_semanticTypeHasBeenSet = false;
  bool m_allowedAggregationsHasBeenSet = false;
  bool m_notAllowedAggregationsHasBeenSet = false;
  bool m_neverAggregateInFilterHasBeenSet = false;
  bool m_cellValueSynonymsHasBeenSet = false;
  bool m_nonAdditiveHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws