DataSet.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#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/ColumnGroup.h>
#include <aws/quicksight/model/ColumnLevelPermissionRule.h>
#include <aws/quicksight/model/DataPrepConfiguration.h>
#include <aws/quicksight/model/DataSetImportMode.h>
#include <aws/quicksight/model/DataSetUsageConfiguration.h>
#include <aws/quicksight/model/DataSetUseAs.h>
#include <aws/quicksight/model/DatasetParameter.h>
#include <aws/quicksight/model/FieldFolder.h>
#include <aws/quicksight/model/LogicalTable.h>
#include <aws/quicksight/model/OutputColumn.h>
#include <aws/quicksight/model/PerformanceConfiguration.h>
#include <aws/quicksight/model/PhysicalTable.h>
#include <aws/quicksight/model/RowLevelPermissionDataSet.h>
#include <aws/quicksight/model/RowLevelPermissionTagConfiguration.h>
#include <aws/quicksight/model/SemanticModelConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class DataSet {
 public:
  AWS_QUICKSIGHT_API DataSet() = default;
  AWS_QUICKSIGHT_API DataSet(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API DataSet& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  DataSet& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDataSetId() const { return m_dataSetId; }
  inline bool DataSetIdHasBeenSet() const { return m_dataSetIdHasBeenSet; }
  template <typename DataSetIdT = Aws::String>
  void SetDataSetId(DataSetIdT&& value) {
    m_dataSetIdHasBeenSet = true;
    m_dataSetId = std::forward<DataSetIdT>(value);
  }
  template <typename DataSetIdT = Aws::String>
  DataSet& WithDataSetId(DataSetIdT&& value) {
    SetDataSetId(std::forward<DataSetIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  DataSet& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedTime() const { return m_createdTime; }
  inline bool CreatedTimeHasBeenSet() const { return m_createdTimeHasBeenSet; }
  template <typename CreatedTimeT = Aws::Utils::DateTime>
  void SetCreatedTime(CreatedTimeT&& value) {
    m_createdTimeHasBeenSet = true;
    m_createdTime = std::forward<CreatedTimeT>(value);
  }
  template <typename CreatedTimeT = Aws::Utils::DateTime>
  DataSet& WithCreatedTime(CreatedTimeT&& value) {
    SetCreatedTime(std::forward<CreatedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastUpdatedTime() const { return m_lastUpdatedTime; }
  inline bool LastUpdatedTimeHasBeenSet() const { return m_lastUpdatedTimeHasBeenSet; }
  template <typename LastUpdatedTimeT = Aws::Utils::DateTime>
  void SetLastUpdatedTime(LastUpdatedTimeT&& value) {
    m_lastUpdatedTimeHasBeenSet = true;
    m_lastUpdatedTime = std::forward<LastUpdatedTimeT>(value);
  }
  template <typename LastUpdatedTimeT = Aws::Utils::DateTime>
  DataSet& WithLastUpdatedTime(LastUpdatedTimeT&& value) {
    SetLastUpdatedTime(std::forward<LastUpdatedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, PhysicalTable>& GetPhysicalTableMap() const { return m_physicalTableMap; }
  inline bool PhysicalTableMapHasBeenSet() const { return m_physicalTableMapHasBeenSet; }
  template <typename PhysicalTableMapT = Aws::Map<Aws::String, PhysicalTable>>
  void SetPhysicalTableMap(PhysicalTableMapT&& value) {
    m_physicalTableMapHasBeenSet = true;
    m_physicalTableMap = std::forward<PhysicalTableMapT>(value);
  }
  template <typename PhysicalTableMapT = Aws::Map<Aws::String, PhysicalTable>>
  DataSet& WithPhysicalTableMap(PhysicalTableMapT&& value) {
    SetPhysicalTableMap(std::forward<PhysicalTableMapT>(value));
    return *this;
  }
  template <typename PhysicalTableMapKeyT = Aws::String, typename PhysicalTableMapValueT = PhysicalTable>
  DataSet& AddPhysicalTableMap(PhysicalTableMapKeyT&& key, PhysicalTableMapValueT&& value) {
    m_physicalTableMapHasBeenSet = true;
    m_physicalTableMap.emplace(std::forward<PhysicalTableMapKeyT>(key), std::forward<PhysicalTableMapValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, LogicalTable>& GetLogicalTableMap() const { return m_logicalTableMap; }
  inline bool LogicalTableMapHasBeenSet() const { return m_logicalTableMapHasBeenSet; }
  template <typename LogicalTableMapT = Aws::Map<Aws::String, LogicalTable>>
  void SetLogicalTableMap(LogicalTableMapT&& value) {
    m_logicalTableMapHasBeenSet = true;
    m_logicalTableMap = std::forward<LogicalTableMapT>(value);
  }
  template <typename LogicalTableMapT = Aws::Map<Aws::String, LogicalTable>>
  DataSet& WithLogicalTableMap(LogicalTableMapT&& value) {
    SetLogicalTableMap(std::forward<LogicalTableMapT>(value));
    return *this;
  }
  template <typename LogicalTableMapKeyT = Aws::String, typename LogicalTableMapValueT = LogicalTable>
  DataSet& AddLogicalTableMap(LogicalTableMapKeyT&& key, LogicalTableMapValueT&& value) {
    m_logicalTableMapHasBeenSet = true;
    m_logicalTableMap.emplace(std::forward<LogicalTableMapKeyT>(key), std::forward<LogicalTableMapValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<OutputColumn>& GetOutputColumns() const { return m_outputColumns; }
  inline bool OutputColumnsHasBeenSet() const { return m_outputColumnsHasBeenSet; }
  template <typename OutputColumnsT = Aws::Vector<OutputColumn>>
  void SetOutputColumns(OutputColumnsT&& value) {
    m_outputColumnsHasBeenSet = true;
    m_outputColumns = std::forward<OutputColumnsT>(value);
  }
  template <typename OutputColumnsT = Aws::Vector<OutputColumn>>
  DataSet& WithOutputColumns(OutputColumnsT&& value) {
    SetOutputColumns(std::forward<OutputColumnsT>(value));
    return *this;
  }
  template <typename OutputColumnsT = OutputColumn>
  DataSet& AddOutputColumns(OutputColumnsT&& value) {
    m_outputColumnsHasBeenSet = true;
    m_outputColumns.emplace_back(std::forward<OutputColumnsT>(value));
    return *this;
  }
 
 
  inline DataSetImportMode GetImportMode() const { return m_importMode; }
  inline bool ImportModeHasBeenSet() const { return m_importModeHasBeenSet; }
  inline void SetImportMode(DataSetImportMode value) {
    m_importModeHasBeenSet = true;
    m_importMode = value;
  }
  inline DataSet& WithImportMode(DataSetImportMode value) {
    SetImportMode(value);
    return *this;
  }
 
 
  inline long long GetConsumedSpiceCapacityInBytes() const { return m_consumedSpiceCapacityInBytes; }
  inline bool ConsumedSpiceCapacityInBytesHasBeenSet() const { return m_consumedSpiceCapacityInBytesHasBeenSet; }
  inline void SetConsumedSpiceCapacityInBytes(long long value) {
    m_consumedSpiceCapacityInBytesHasBeenSet = true;
    m_consumedSpiceCapacityInBytes = value;
  }
  inline DataSet& WithConsumedSpiceCapacityInBytes(long long value) {
    SetConsumedSpiceCapacityInBytes(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnGroup>& GetColumnGroups() const { return m_columnGroups; }
  inline bool ColumnGroupsHasBeenSet() const { return m_columnGroupsHasBeenSet; }
  template <typename ColumnGroupsT = Aws::Vector<ColumnGroup>>
  void SetColumnGroups(ColumnGroupsT&& value) {
    m_columnGroupsHasBeenSet = true;
    m_columnGroups = std::forward<ColumnGroupsT>(value);
  }
  template <typename ColumnGroupsT = Aws::Vector<ColumnGroup>>
  DataSet& WithColumnGroups(ColumnGroupsT&& value) {
    SetColumnGroups(std::forward<ColumnGroupsT>(value));
    return *this;
  }
  template <typename ColumnGroupsT = ColumnGroup>
  DataSet& AddColumnGroups(ColumnGroupsT&& value) {
    m_columnGroupsHasBeenSet = true;
    m_columnGroups.emplace_back(std::forward<ColumnGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, FieldFolder>& GetFieldFolders() const { return m_fieldFolders; }
  inline bool FieldFoldersHasBeenSet() const { return m_fieldFoldersHasBeenSet; }
  template <typename FieldFoldersT = Aws::Map<Aws::String, FieldFolder>>
  void SetFieldFolders(FieldFoldersT&& value) {
    m_fieldFoldersHasBeenSet = true;
    m_fieldFolders = std::forward<FieldFoldersT>(value);
  }
  template <typename FieldFoldersT = Aws::Map<Aws::String, FieldFolder>>
  DataSet& WithFieldFolders(FieldFoldersT&& value) {
    SetFieldFolders(std::forward<FieldFoldersT>(value));
    return *this;
  }
  template <typename FieldFoldersKeyT = Aws::String, typename FieldFoldersValueT = FieldFolder>
  DataSet& AddFieldFolders(FieldFoldersKeyT&& key, FieldFoldersValueT&& value) {
    m_fieldFoldersHasBeenSet = true;
    m_fieldFolders.emplace(std::forward<FieldFoldersKeyT>(key), std::forward<FieldFoldersValueT>(value));
    return *this;
  }
 
 
  inline const RowLevelPermissionDataSet& GetRowLevelPermissionDataSet() const { return m_rowLevelPermissionDataSet; }
  inline bool RowLevelPermissionDataSetHasBeenSet() const { return m_rowLevelPermissionDataSetHasBeenSet; }
  template <typename RowLevelPermissionDataSetT = RowLevelPermissionDataSet>
  void SetRowLevelPermissionDataSet(RowLevelPermissionDataSetT&& value) {
    m_rowLevelPermissionDataSetHasBeenSet = true;
    m_rowLevelPermissionDataSet = std::forward<RowLevelPermissionDataSetT>(value);
  }
  template <typename RowLevelPermissionDataSetT = RowLevelPermissionDataSet>
  DataSet& WithRowLevelPermissionDataSet(RowLevelPermissionDataSetT&& value) {
    SetRowLevelPermissionDataSet(std::forward<RowLevelPermissionDataSetT>(value));
    return *this;
  }
 
 
  inline const RowLevelPermissionTagConfiguration& GetRowLevelPermissionTagConfiguration() const {
    return m_rowLevelPermissionTagConfiguration;
  }
  inline bool RowLevelPermissionTagConfigurationHasBeenSet() const { return m_rowLevelPermissionTagConfigurationHasBeenSet; }
  template <typename RowLevelPermissionTagConfigurationT = RowLevelPermissionTagConfiguration>
  void SetRowLevelPermissionTagConfiguration(RowLevelPermissionTagConfigurationT&& value) {
    m_rowLevelPermissionTagConfigurationHasBeenSet = true;
    m_rowLevelPermissionTagConfiguration = std::forward<RowLevelPermissionTagConfigurationT>(value);
  }
  template <typename RowLevelPermissionTagConfigurationT = RowLevelPermissionTagConfiguration>
  DataSet& WithRowLevelPermissionTagConfiguration(RowLevelPermissionTagConfigurationT&& value) {
    SetRowLevelPermissionTagConfiguration(std::forward<RowLevelPermissionTagConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnLevelPermissionRule>& GetColumnLevelPermissionRules() const { return m_columnLevelPermissionRules; }
  inline bool ColumnLevelPermissionRulesHasBeenSet() const { return m_columnLevelPermissionRulesHasBeenSet; }
  template <typename ColumnLevelPermissionRulesT = Aws::Vector<ColumnLevelPermissionRule>>
  void SetColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    m_columnLevelPermissionRulesHasBeenSet = true;
    m_columnLevelPermissionRules = std::forward<ColumnLevelPermissionRulesT>(value);
  }
  template <typename ColumnLevelPermissionRulesT = Aws::Vector<ColumnLevelPermissionRule>>
  DataSet& WithColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    SetColumnLevelPermissionRules(std::forward<ColumnLevelPermissionRulesT>(value));
    return *this;
  }
  template <typename ColumnLevelPermissionRulesT = ColumnLevelPermissionRule>
  DataSet& AddColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    m_columnLevelPermissionRulesHasBeenSet = true;
    m_columnLevelPermissionRules.emplace_back(std::forward<ColumnLevelPermissionRulesT>(value));
    return *this;
  }
 
 
  inline const DataSetUsageConfiguration& GetDataSetUsageConfiguration() const { return m_dataSetUsageConfiguration; }
  inline bool DataSetUsageConfigurationHasBeenSet() const { return m_dataSetUsageConfigurationHasBeenSet; }
  template <typename DataSetUsageConfigurationT = DataSetUsageConfiguration>
  void SetDataSetUsageConfiguration(DataSetUsageConfigurationT&& value) {
    m_dataSetUsageConfigurationHasBeenSet = true;
    m_dataSetUsageConfiguration = std::forward<DataSetUsageConfigurationT>(value);
  }
  template <typename DataSetUsageConfigurationT = DataSetUsageConfiguration>
  DataSet& WithDataSetUsageConfiguration(DataSetUsageConfigurationT&& value) {
    SetDataSetUsageConfiguration(std::forward<DataSetUsageConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DatasetParameter>& GetDatasetParameters() const { return m_datasetParameters; }
  inline bool DatasetParametersHasBeenSet() const { return m_datasetParametersHasBeenSet; }
  template <typename DatasetParametersT = Aws::Vector<DatasetParameter>>
  void SetDatasetParameters(DatasetParametersT&& value) {
    m_datasetParametersHasBeenSet = true;
    m_datasetParameters = std::forward<DatasetParametersT>(value);
  }
  template <typename DatasetParametersT = Aws::Vector<DatasetParameter>>
  DataSet& WithDatasetParameters(DatasetParametersT&& value) {
    SetDatasetParameters(std::forward<DatasetParametersT>(value));
    return *this;
  }
  template <typename DatasetParametersT = DatasetParameter>
  DataSet& AddDatasetParameters(DatasetParametersT&& value) {
    m_datasetParametersHasBeenSet = true;
    m_datasetParameters.emplace_back(std::forward<DatasetParametersT>(value));
    return *this;
  }
 
 
  inline const PerformanceConfiguration& GetPerformanceConfiguration() const { return m_performanceConfiguration; }
  inline bool PerformanceConfigurationHasBeenSet() const { return m_performanceConfigurationHasBeenSet; }
  template <typename PerformanceConfigurationT = PerformanceConfiguration>
  void SetPerformanceConfiguration(PerformanceConfigurationT&& value) {
    m_performanceConfigurationHasBeenSet = true;
    m_performanceConfiguration = std::forward<PerformanceConfigurationT>(value);
  }
  template <typename PerformanceConfigurationT = PerformanceConfiguration>
  DataSet& WithPerformanceConfiguration(PerformanceConfigurationT&& value) {
    SetPerformanceConfiguration(std::forward<PerformanceConfigurationT>(value));
    return *this;
  }
 
 
  inline DataSetUseAs GetUseAs() const { return m_useAs; }
  inline bool UseAsHasBeenSet() const { return m_useAsHasBeenSet; }
  inline void SetUseAs(DataSetUseAs value) {
    m_useAsHasBeenSet = true;
    m_useAs = value;
  }
  inline DataSet& WithUseAs(DataSetUseAs value) {
    SetUseAs(value);
    return *this;
  }
 
 
  inline const DataPrepConfiguration& GetDataPrepConfiguration() const { return m_dataPrepConfiguration; }
  inline bool DataPrepConfigurationHasBeenSet() const { return m_dataPrepConfigurationHasBeenSet; }
  template <typename DataPrepConfigurationT = DataPrepConfiguration>
  void SetDataPrepConfiguration(DataPrepConfigurationT&& value) {
    m_dataPrepConfigurationHasBeenSet = true;
    m_dataPrepConfiguration = std::forward<DataPrepConfigurationT>(value);
  }
  template <typename DataPrepConfigurationT = DataPrepConfiguration>
  DataSet& WithDataPrepConfiguration(DataPrepConfigurationT&& value) {
    SetDataPrepConfiguration(std::forward<DataPrepConfigurationT>(value));
    return *this;
  }
 
 
  inline const SemanticModelConfiguration& GetSemanticModelConfiguration() const { return m_semanticModelConfiguration; }
  inline bool SemanticModelConfigurationHasBeenSet() const { return m_semanticModelConfigurationHasBeenSet; }
  template <typename SemanticModelConfigurationT = SemanticModelConfiguration>
  void SetSemanticModelConfiguration(SemanticModelConfigurationT&& value) {
    m_semanticModelConfigurationHasBeenSet = true;
    m_semanticModelConfiguration = std::forward<SemanticModelConfigurationT>(value);
  }
  template <typename SemanticModelConfigurationT = SemanticModelConfiguration>
  DataSet& WithSemanticModelConfiguration(SemanticModelConfigurationT&& value) {
    SetSemanticModelConfiguration(std::forward<SemanticModelConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_arn;
 
  Aws::String m_dataSetId;
 
  Aws::String m_name;
 
  Aws::Utils::DateTime m_createdTime{};
 
  Aws::Utils::DateTime m_lastUpdatedTime{};
 
  Aws::Map<Aws::String, PhysicalTable> m_physicalTableMap;
 
  Aws::Map<Aws::String, LogicalTable> m_logicalTableMap;
 
  Aws::Vector<OutputColumn> m_outputColumns;
 
  DataSetImportMode m_importMode{DataSetImportMode::NOT_SET};
 
  long long m_consumedSpiceCapacityInBytes{0};
 
  Aws::Vector<ColumnGroup> m_columnGroups;
 
  Aws::Map<Aws::String, FieldFolder> m_fieldFolders;
 
  RowLevelPermissionDataSet m_rowLevelPermissionDataSet;
 
  RowLevelPermissionTagConfiguration m_rowLevelPermissionTagConfiguration;
 
  Aws::Vector<ColumnLevelPermissionRule> m_columnLevelPermissionRules;
 
  DataSetUsageConfiguration m_dataSetUsageConfiguration;
 
  Aws::Vector<DatasetParameter> m_datasetParameters;
 
  PerformanceConfiguration m_performanceConfiguration;
 
  DataSetUseAs m_useAs{DataSetUseAs::NOT_SET};
 
  DataPrepConfiguration m_dataPrepConfiguration;
 
  SemanticModelConfiguration m_semanticModelConfiguration;
  bool m_arnHasBeenSet = false;
  bool m_dataSetIdHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_createdTimeHasBeenSet = false;
  bool m_lastUpdatedTimeHasBeenSet = false;
  bool m_physicalTableMapHasBeenSet = false;
  bool m_logicalTableMapHasBeenSet = false;
  bool m_outputColumnsHasBeenSet = false;
  bool m_importModeHasBeenSet = false;
  bool m_consumedSpiceCapacityInBytesHasBeenSet = false;
  bool m_columnGroupsHasBeenSet = false;
  bool m_fieldFoldersHasBeenSet = false;
  bool m_rowLevelPermissionDataSetHasBeenSet = false;
  bool m_rowLevelPermissionTagConfigurationHasBeenSet = false;
  bool m_columnLevelPermissionRulesHasBeenSet = false;
  bool m_dataSetUsageConfigurationHasBeenSet = false;
  bool m_datasetParametersHasBeenSet = false;
  bool m_performanceConfigurationHasBeenSet = false;
  bool m_useAsHasBeenSet = false;
  bool m_dataPrepConfigurationHasBeenSet = false;
  bool m_semanticModelConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws