AnalysisDefinition.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/AnalysisDefaults.h>
#include <aws/quicksight/model/AssetOptions.h>
#include <aws/quicksight/model/CalculatedField.h>
#include <aws/quicksight/model/ColumnConfiguration.h>
#include <aws/quicksight/model/DataSetIdentifierDeclaration.h>
#include <aws/quicksight/model/FilterGroup.h>
#include <aws/quicksight/model/ParameterDeclaration.h>
#include <aws/quicksight/model/QueryExecutionOptions.h>
#include <aws/quicksight/model/SheetDefinition.h>
#include <aws/quicksight/model/StaticFile.h>
#include <aws/quicksight/model/TooltipSheetDefinition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class AnalysisDefinition {
 public:
  AWS_QUICKSIGHT_API AnalysisDefinition() = default;
  AWS_QUICKSIGHT_API AnalysisDefinition(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API AnalysisDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<DataSetIdentifierDeclaration>& GetDataSetIdentifierDeclarations() const {
    return m_dataSetIdentifierDeclarations;
  }
  inline bool DataSetIdentifierDeclarationsHasBeenSet() const { return m_dataSetIdentifierDeclarationsHasBeenSet; }
  template <typename DataSetIdentifierDeclarationsT = Aws::Vector<DataSetIdentifierDeclaration>>
  void SetDataSetIdentifierDeclarations(DataSetIdentifierDeclarationsT&& value) {
    m_dataSetIdentifierDeclarationsHasBeenSet = true;
    m_dataSetIdentifierDeclarations = std::forward<DataSetIdentifierDeclarationsT>(value);
  }
  template <typename DataSetIdentifierDeclarationsT = Aws::Vector<DataSetIdentifierDeclaration>>
  AnalysisDefinition& WithDataSetIdentifierDeclarations(DataSetIdentifierDeclarationsT&& value) {
    SetDataSetIdentifierDeclarations(std::forward<DataSetIdentifierDeclarationsT>(value));
    return *this;
  }
  template <typename DataSetIdentifierDeclarationsT = DataSetIdentifierDeclaration>
  AnalysisDefinition& AddDataSetIdentifierDeclarations(DataSetIdentifierDeclarationsT&& value) {
    m_dataSetIdentifierDeclarationsHasBeenSet = true;
    m_dataSetIdentifierDeclarations.emplace_back(std::forward<DataSetIdentifierDeclarationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SheetDefinition>& GetSheets() const { return m_sheets; }
  inline bool SheetsHasBeenSet() const { return m_sheetsHasBeenSet; }
  template <typename SheetsT = Aws::Vector<SheetDefinition>>
  void SetSheets(SheetsT&& value) {
    m_sheetsHasBeenSet = true;
    m_sheets = std::forward<SheetsT>(value);
  }
  template <typename SheetsT = Aws::Vector<SheetDefinition>>
  AnalysisDefinition& WithSheets(SheetsT&& value) {
    SetSheets(std::forward<SheetsT>(value));
    return *this;
  }
  template <typename SheetsT = SheetDefinition>
  AnalysisDefinition& AddSheets(SheetsT&& value) {
    m_sheetsHasBeenSet = true;
    m_sheets.emplace_back(std::forward<SheetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TooltipSheetDefinition>& GetTooltipSheets() const { return m_tooltipSheets; }
  inline bool TooltipSheetsHasBeenSet() const { return m_tooltipSheetsHasBeenSet; }
  template <typename TooltipSheetsT = Aws::Vector<TooltipSheetDefinition>>
  void SetTooltipSheets(TooltipSheetsT&& value) {
    m_tooltipSheetsHasBeenSet = true;
    m_tooltipSheets = std::forward<TooltipSheetsT>(value);
  }
  template <typename TooltipSheetsT = Aws::Vector<TooltipSheetDefinition>>
  AnalysisDefinition& WithTooltipSheets(TooltipSheetsT&& value) {
    SetTooltipSheets(std::forward<TooltipSheetsT>(value));
    return *this;
  }
  template <typename TooltipSheetsT = TooltipSheetDefinition>
  AnalysisDefinition& AddTooltipSheets(TooltipSheetsT&& value) {
    m_tooltipSheetsHasBeenSet = true;
    m_tooltipSheets.emplace_back(std::forward<TooltipSheetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CalculatedField>& GetCalculatedFields() const { return m_calculatedFields; }
  inline bool CalculatedFieldsHasBeenSet() const { return m_calculatedFieldsHasBeenSet; }
  template <typename CalculatedFieldsT = Aws::Vector<CalculatedField>>
  void SetCalculatedFields(CalculatedFieldsT&& value) {
    m_calculatedFieldsHasBeenSet = true;
    m_calculatedFields = std::forward<CalculatedFieldsT>(value);
  }
  template <typename CalculatedFieldsT = Aws::Vector<CalculatedField>>
  AnalysisDefinition& WithCalculatedFields(CalculatedFieldsT&& value) {
    SetCalculatedFields(std::forward<CalculatedFieldsT>(value));
    return *this;
  }
  template <typename CalculatedFieldsT = CalculatedField>
  AnalysisDefinition& AddCalculatedFields(CalculatedFieldsT&& value) {
    m_calculatedFieldsHasBeenSet = true;
    m_calculatedFields.emplace_back(std::forward<CalculatedFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ParameterDeclaration>& GetParameterDeclarations() const { return m_parameterDeclarations; }
  inline bool ParameterDeclarationsHasBeenSet() const { return m_parameterDeclarationsHasBeenSet; }
  template <typename ParameterDeclarationsT = Aws::Vector<ParameterDeclaration>>
  void SetParameterDeclarations(ParameterDeclarationsT&& value) {
    m_parameterDeclarationsHasBeenSet = true;
    m_parameterDeclarations = std::forward<ParameterDeclarationsT>(value);
  }
  template <typename ParameterDeclarationsT = Aws::Vector<ParameterDeclaration>>
  AnalysisDefinition& WithParameterDeclarations(ParameterDeclarationsT&& value) {
    SetParameterDeclarations(std::forward<ParameterDeclarationsT>(value));
    return *this;
  }
  template <typename ParameterDeclarationsT = ParameterDeclaration>
  AnalysisDefinition& AddParameterDeclarations(ParameterDeclarationsT&& value) {
    m_parameterDeclarationsHasBeenSet = true;
    m_parameterDeclarations.emplace_back(std::forward<ParameterDeclarationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<FilterGroup>& GetFilterGroups() const { return m_filterGroups; }
  inline bool FilterGroupsHasBeenSet() const { return m_filterGroupsHasBeenSet; }
  template <typename FilterGroupsT = Aws::Vector<FilterGroup>>
  void SetFilterGroups(FilterGroupsT&& value) {
    m_filterGroupsHasBeenSet = true;
    m_filterGroups = std::forward<FilterGroupsT>(value);
  }
  template <typename FilterGroupsT = Aws::Vector<FilterGroup>>
  AnalysisDefinition& WithFilterGroups(FilterGroupsT&& value) {
    SetFilterGroups(std::forward<FilterGroupsT>(value));
    return *this;
  }
  template <typename FilterGroupsT = FilterGroup>
  AnalysisDefinition& AddFilterGroups(FilterGroupsT&& value) {
    m_filterGroupsHasBeenSet = true;
    m_filterGroups.emplace_back(std::forward<FilterGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnConfiguration>& GetColumnConfigurations() const { return m_columnConfigurations; }
  inline bool ColumnConfigurationsHasBeenSet() const { return m_columnConfigurationsHasBeenSet; }
  template <typename ColumnConfigurationsT = Aws::Vector<ColumnConfiguration>>
  void SetColumnConfigurations(ColumnConfigurationsT&& value) {
    m_columnConfigurationsHasBeenSet = true;
    m_columnConfigurations = std::forward<ColumnConfigurationsT>(value);
  }
  template <typename ColumnConfigurationsT = Aws::Vector<ColumnConfiguration>>
  AnalysisDefinition& WithColumnConfigurations(ColumnConfigurationsT&& value) {
    SetColumnConfigurations(std::forward<ColumnConfigurationsT>(value));
    return *this;
  }
  template <typename ColumnConfigurationsT = ColumnConfiguration>
  AnalysisDefinition& AddColumnConfigurations(ColumnConfigurationsT&& value) {
    m_columnConfigurationsHasBeenSet = true;
    m_columnConfigurations.emplace_back(std::forward<ColumnConfigurationsT>(value));
    return *this;
  }
 
 
  inline const AnalysisDefaults& GetAnalysisDefaults() const { return m_analysisDefaults; }
  inline bool AnalysisDefaultsHasBeenSet() const { return m_analysisDefaultsHasBeenSet; }
  template <typename AnalysisDefaultsT = AnalysisDefaults>
  void SetAnalysisDefaults(AnalysisDefaultsT&& value) {
    m_analysisDefaultsHasBeenSet = true;
    m_analysisDefaults = std::forward<AnalysisDefaultsT>(value);
  }
  template <typename AnalysisDefaultsT = AnalysisDefaults>
  AnalysisDefinition& WithAnalysisDefaults(AnalysisDefaultsT&& value) {
    SetAnalysisDefaults(std::forward<AnalysisDefaultsT>(value));
    return *this;
  }
 
 
  inline const AssetOptions& GetOptions() const { return m_options; }
  inline bool OptionsHasBeenSet() const { return m_optionsHasBeenSet; }
  template <typename OptionsT = AssetOptions>
  void SetOptions(OptionsT&& value) {
    m_optionsHasBeenSet = true;
    m_options = std::forward<OptionsT>(value);
  }
  template <typename OptionsT = AssetOptions>
  AnalysisDefinition& WithOptions(OptionsT&& value) {
    SetOptions(std::forward<OptionsT>(value));
    return *this;
  }
 
 
  inline const QueryExecutionOptions& GetQueryExecutionOptions() const { return m_queryExecutionOptions; }
  inline bool QueryExecutionOptionsHasBeenSet() const { return m_queryExecutionOptionsHasBeenSet; }
  template <typename QueryExecutionOptionsT = QueryExecutionOptions>
  void SetQueryExecutionOptions(QueryExecutionOptionsT&& value) {
    m_queryExecutionOptionsHasBeenSet = true;
    m_queryExecutionOptions = std::forward<QueryExecutionOptionsT>(value);
  }
  template <typename QueryExecutionOptionsT = QueryExecutionOptions>
  AnalysisDefinition& WithQueryExecutionOptions(QueryExecutionOptionsT&& value) {
    SetQueryExecutionOptions(std::forward<QueryExecutionOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<StaticFile>& GetStaticFiles() const { return m_staticFiles; }
  inline bool StaticFilesHasBeenSet() const { return m_staticFilesHasBeenSet; }
  template <typename StaticFilesT = Aws::Vector<StaticFile>>
  void SetStaticFiles(StaticFilesT&& value) {
    m_staticFilesHasBeenSet = true;
    m_staticFiles = std::forward<StaticFilesT>(value);
  }
  template <typename StaticFilesT = Aws::Vector<StaticFile>>
  AnalysisDefinition& WithStaticFiles(StaticFilesT&& value) {
    SetStaticFiles(std::forward<StaticFilesT>(value));
    return *this;
  }
  template <typename StaticFilesT = StaticFile>
  AnalysisDefinition& AddStaticFiles(StaticFilesT&& value) {
    m_staticFilesHasBeenSet = true;
    m_staticFiles.emplace_back(std::forward<StaticFilesT>(value));
    return *this;
  }
 private:
  Aws::Vector<DataSetIdentifierDeclaration> m_dataSetIdentifierDeclarations;
 
  Aws::Vector<SheetDefinition> m_sheets;
 
  Aws::Vector<TooltipSheetDefinition> m_tooltipSheets;
 
  Aws::Vector<CalculatedField> m_calculatedFields;
 
  Aws::Vector<ParameterDeclaration> m_parameterDeclarations;
 
  Aws::Vector<FilterGroup> m_filterGroups;
 
  Aws::Vector<ColumnConfiguration> m_columnConfigurations;
 
  AnalysisDefaults m_analysisDefaults;
 
  AssetOptions m_options;
 
  QueryExecutionOptions m_queryExecutionOptions;
 
  Aws::Vector<StaticFile> m_staticFiles;
  bool m_dataSetIdentifierDeclarationsHasBeenSet = false;
  bool m_sheetsHasBeenSet = false;
  bool m_tooltipSheetsHasBeenSet = false;
  bool m_calculatedFieldsHasBeenSet = false;
  bool m_parameterDeclarationsHasBeenSet = false;
  bool m_filterGroupsHasBeenSet = false;
  bool m_columnConfigurationsHasBeenSet = false;
  bool m_analysisDefaultsHasBeenSet = false;
  bool m_optionsHasBeenSet = false;
  bool m_queryExecutionOptionsHasBeenSet = false;
  bool m_staticFilesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws