TableDescription.h

 
#pragma once
#include <aws/dynamodb/DynamoDB_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/dynamodb/model/TableStatus.h>
#include <aws/core/utils/DateTime.h>
#include <aws/dynamodb/model/ProvisionedThroughputDescription.h>
#include <aws/dynamodb/model/BillingModeSummary.h>
#include <aws/dynamodb/model/StreamSpecification.h>
#include <aws/dynamodb/model/RestoreSummary.h>
#include <aws/dynamodb/model/SSEDescription.h>
#include <aws/dynamodb/model/ArchivalSummary.h>
#include <aws/dynamodb/model/TableClassSummary.h>
#include <aws/dynamodb/model/OnDemandThroughput.h>
#include <aws/dynamodb/model/TableWarmThroughputDescription.h>
#include <aws/dynamodb/model/MultiRegionConsistency.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/KeySchemaElement.h>
#include <aws/dynamodb/model/LocalSecondaryIndexDescription.h>
#include <aws/dynamodb/model/GlobalSecondaryIndexDescription.h>
#include <aws/dynamodb/model/ReplicaDescription.h>
#include <aws/dynamodb/model/GlobalTableWitnessDescription.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace DynamoDB
{
namespace Model
{
 
  class TableDescription
  {
  public:
    AWS_DYNAMODB_API TableDescription() = default;
    AWS_DYNAMODB_API TableDescription(Aws::Utils::Json::JsonView jsonValue);
    AWS_DYNAMODB_API TableDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_DYNAMODB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::Vector<AttributeDefinition>& GetAttributeDefinitions() const { return m_attributeDefinitions; }
    inline bool AttributeDefinitionsHasBeenSet() const { return m_attributeDefinitionsHasBeenSet; }
    template<typename AttributeDefinitionsT = Aws::Vector<AttributeDefinition>>
    void SetAttributeDefinitions(AttributeDefinitionsT&& value) { m_attributeDefinitionsHasBeenSet = true; m_attributeDefinitions = std::forward<AttributeDefinitionsT>(value); }
    template<typename AttributeDefinitionsT = Aws::Vector<AttributeDefinition>>
    TableDescription& WithAttributeDefinitions(AttributeDefinitionsT&& value) { SetAttributeDefinitions(std::forward<AttributeDefinitionsT>(value)); return *this;}
    template<typename AttributeDefinitionsT = AttributeDefinition>
    TableDescription& AddAttributeDefinitions(AttributeDefinitionsT&& value) { m_attributeDefinitionsHasBeenSet = true; m_attributeDefinitions.emplace_back(std::forward<AttributeDefinitionsT>(value)); return *this; }
 
 
    inline const Aws::String& GetTableName() const { return m_tableName; }
    inline bool TableNameHasBeenSet() const { return m_tableNameHasBeenSet; }
    template<typename TableNameT = Aws::String>
    void SetTableName(TableNameT&& value) { m_tableNameHasBeenSet = true; m_tableName = std::forward<TableNameT>(value); }
    template<typename TableNameT = Aws::String>
    TableDescription& WithTableName(TableNameT&& value) { SetTableName(std::forward<TableNameT>(value)); return *this;}
 
 
    inline const Aws::Vector<KeySchemaElement>& GetKeySchema() const { return m_keySchema; }
    inline bool KeySchemaHasBeenSet() const { return m_keySchemaHasBeenSet; }
    template<typename KeySchemaT = Aws::Vector<KeySchemaElement>>
    void SetKeySchema(KeySchemaT&& value) { m_keySchemaHasBeenSet = true; m_keySchema = std::forward<KeySchemaT>(value); }
    template<typename KeySchemaT = Aws::Vector<KeySchemaElement>>
    TableDescription& WithKeySchema(KeySchemaT&& value) { SetKeySchema(std::forward<KeySchemaT>(value)); return *this;}
    template<typename KeySchemaT = KeySchemaElement>
    TableDescription& AddKeySchema(KeySchemaT&& value) { m_keySchemaHasBeenSet = true; m_keySchema.emplace_back(std::forward<KeySchemaT>(value)); return *this; }
 
 
    inline TableStatus GetTableStatus() const { return m_tableStatus; }
    inline bool TableStatusHasBeenSet() const { return m_tableStatusHasBeenSet; }
    inline void SetTableStatus(TableStatus value) { m_tableStatusHasBeenSet = true; m_tableStatus = value; }
    inline TableDescription& WithTableStatus(TableStatus value) { SetTableStatus(value); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetCreationDateTime() const { return m_creationDateTime; }
    inline bool CreationDateTimeHasBeenSet() const { return m_creationDateTimeHasBeenSet; }
    template<typename CreationDateTimeT = Aws::Utils::DateTime>
    void SetCreationDateTime(CreationDateTimeT&& value) { m_creationDateTimeHasBeenSet = true; m_creationDateTime = std::forward<CreationDateTimeT>(value); }
    template<typename CreationDateTimeT = Aws::Utils::DateTime>
    TableDescription& WithCreationDateTime(CreationDateTimeT&& value) { SetCreationDateTime(std::forward<CreationDateTimeT>(value)); return *this;}
 
 
    inline const ProvisionedThroughputDescription& GetProvisionedThroughput() const { return m_provisionedThroughput; }
    inline bool ProvisionedThroughputHasBeenSet() const { return m_provisionedThroughputHasBeenSet; }
    template<typename ProvisionedThroughputT = ProvisionedThroughputDescription>
    void SetProvisionedThroughput(ProvisionedThroughputT&& value) { m_provisionedThroughputHasBeenSet = true; m_provisionedThroughput = std::forward<ProvisionedThroughputT>(value); }
    template<typename ProvisionedThroughputT = ProvisionedThroughputDescription>
    TableDescription& WithProvisionedThroughput(ProvisionedThroughputT&& value) { SetProvisionedThroughput(std::forward<ProvisionedThroughputT>(value)); return *this;}
 
 
    inline long long GetTableSizeBytes() const { return m_tableSizeBytes; }
    inline bool TableSizeBytesHasBeenSet() const { return m_tableSizeBytesHasBeenSet; }
    inline void SetTableSizeBytes(long long value) { m_tableSizeBytesHasBeenSet = true; m_tableSizeBytes = value; }
    inline TableDescription& WithTableSizeBytes(long long value) { SetTableSizeBytes(value); return *this;}
 
 
    inline long long GetItemCount() const { return m_itemCount; }
    inline bool ItemCountHasBeenSet() const { return m_itemCountHasBeenSet; }
    inline void SetItemCount(long long value) { m_itemCountHasBeenSet = true; m_itemCount = value; }
    inline TableDescription& WithItemCount(long long value) { SetItemCount(value); return *this;}
 
 
    inline const Aws::String& GetTableArn() const { return m_tableArn; }
    inline bool TableArnHasBeenSet() const { return m_tableArnHasBeenSet; }
    template<typename TableArnT = Aws::String>
    void SetTableArn(TableArnT&& value) { m_tableArnHasBeenSet = true; m_tableArn = std::forward<TableArnT>(value); }
    template<typename TableArnT = Aws::String>
    TableDescription& WithTableArn(TableArnT&& value) { SetTableArn(std::forward<TableArnT>(value)); return *this;}
 
 
    inline const Aws::String& GetTableId() const { return m_tableId; }
    inline bool TableIdHasBeenSet() const { return m_tableIdHasBeenSet; }
    template<typename TableIdT = Aws::String>
    void SetTableId(TableIdT&& value) { m_tableIdHasBeenSet = true; m_tableId = std::forward<TableIdT>(value); }
    template<typename TableIdT = Aws::String>
    TableDescription& WithTableId(TableIdT&& value) { SetTableId(std::forward<TableIdT>(value)); return *this;}
 
 
    inline const BillingModeSummary& GetBillingModeSummary() const { return m_billingModeSummary; }
    inline bool BillingModeSummaryHasBeenSet() const { return m_billingModeSummaryHasBeenSet; }
    template<typename BillingModeSummaryT = BillingModeSummary>
    void SetBillingModeSummary(BillingModeSummaryT&& value) { m_billingModeSummaryHasBeenSet = true; m_billingModeSummary = std::forward<BillingModeSummaryT>(value); }
    template<typename BillingModeSummaryT = BillingModeSummary>
    TableDescription& WithBillingModeSummary(BillingModeSummaryT&& value) { SetBillingModeSummary(std::forward<BillingModeSummaryT>(value)); return *this;}
 
 
    inline const Aws::Vector<LocalSecondaryIndexDescription>& GetLocalSecondaryIndexes() const { return m_localSecondaryIndexes; }
    inline bool LocalSecondaryIndexesHasBeenSet() const { return m_localSecondaryIndexesHasBeenSet; }
    template<typename LocalSecondaryIndexesT = Aws::Vector<LocalSecondaryIndexDescription>>
    void SetLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes = std::forward<LocalSecondaryIndexesT>(value); }
    template<typename LocalSecondaryIndexesT = Aws::Vector<LocalSecondaryIndexDescription>>
    TableDescription& WithLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) { SetLocalSecondaryIndexes(std::forward<LocalSecondaryIndexesT>(value)); return *this;}
    template<typename LocalSecondaryIndexesT = LocalSecondaryIndexDescription>
    TableDescription& AddLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) { m_localSecondaryIndexesHasBeenSet = true; m_localSecondaryIndexes.emplace_back(std::forward<LocalSecondaryIndexesT>(value)); return *this; }
 
 
    inline const Aws::Vector<GlobalSecondaryIndexDescription>& GetGlobalSecondaryIndexes() const { return m_globalSecondaryIndexes; }
    inline bool GlobalSecondaryIndexesHasBeenSet() const { return m_globalSecondaryIndexesHasBeenSet; }
    template<typename GlobalSecondaryIndexesT = Aws::Vector<GlobalSecondaryIndexDescription>>
    void SetGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes = std::forward<GlobalSecondaryIndexesT>(value); }
    template<typename GlobalSecondaryIndexesT = Aws::Vector<GlobalSecondaryIndexDescription>>
    TableDescription& WithGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) { SetGlobalSecondaryIndexes(std::forward<GlobalSecondaryIndexesT>(value)); return *this;}
    template<typename GlobalSecondaryIndexesT = GlobalSecondaryIndexDescription>
    TableDescription& AddGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) { m_globalSecondaryIndexesHasBeenSet = true; m_globalSecondaryIndexes.emplace_back(std::forward<GlobalSecondaryIndexesT>(value)); return *this; }
 
 
    inline const StreamSpecification& GetStreamSpecification() const { return m_streamSpecification; }
    inline bool StreamSpecificationHasBeenSet() const { return m_streamSpecificationHasBeenSet; }
    template<typename StreamSpecificationT = StreamSpecification>
    void SetStreamSpecification(StreamSpecificationT&& value) { m_streamSpecificationHasBeenSet = true; m_streamSpecification = std::forward<StreamSpecificationT>(value); }
    template<typename StreamSpecificationT = StreamSpecification>
    TableDescription& WithStreamSpecification(StreamSpecificationT&& value) { SetStreamSpecification(std::forward<StreamSpecificationT>(value)); return *this;}
 
 
    inline const Aws::String& GetLatestStreamLabel() const { return m_latestStreamLabel; }
    inline bool LatestStreamLabelHasBeenSet() const { return m_latestStreamLabelHasBeenSet; }
    template<typename LatestStreamLabelT = Aws::String>
    void SetLatestStreamLabel(LatestStreamLabelT&& value) { m_latestStreamLabelHasBeenSet = true; m_latestStreamLabel = std::forward<LatestStreamLabelT>(value); }
    template<typename LatestStreamLabelT = Aws::String>
    TableDescription& WithLatestStreamLabel(LatestStreamLabelT&& value) { SetLatestStreamLabel(std::forward<LatestStreamLabelT>(value)); return *this;}
 
 
    inline const Aws::String& GetLatestStreamArn() const { return m_latestStreamArn; }
    inline bool LatestStreamArnHasBeenSet() const { return m_latestStreamArnHasBeenSet; }
    template<typename LatestStreamArnT = Aws::String>
    void SetLatestStreamArn(LatestStreamArnT&& value) { m_latestStreamArnHasBeenSet = true; m_latestStreamArn = std::forward<LatestStreamArnT>(value); }
    template<typename LatestStreamArnT = Aws::String>
    TableDescription& WithLatestStreamArn(LatestStreamArnT&& value) { SetLatestStreamArn(std::forward<LatestStreamArnT>(value)); return *this;}
 
 
    inline const Aws::String& GetGlobalTableVersion() const { return m_globalTableVersion; }
    inline bool GlobalTableVersionHasBeenSet() const { return m_globalTableVersionHasBeenSet; }
    template<typename GlobalTableVersionT = Aws::String>
    void SetGlobalTableVersion(GlobalTableVersionT&& value) { m_globalTableVersionHasBeenSet = true; m_globalTableVersion = std::forward<GlobalTableVersionT>(value); }
    template<typename GlobalTableVersionT = Aws::String>
    TableDescription& WithGlobalTableVersion(GlobalTableVersionT&& value) { SetGlobalTableVersion(std::forward<GlobalTableVersionT>(value)); return *this;}
 
 
    inline const Aws::Vector<ReplicaDescription>& GetReplicas() const { return m_replicas; }
    inline bool ReplicasHasBeenSet() const { return m_replicasHasBeenSet; }
    template<typename ReplicasT = Aws::Vector<ReplicaDescription>>
    void SetReplicas(ReplicasT&& value) { m_replicasHasBeenSet = true; m_replicas = std::forward<ReplicasT>(value); }
    template<typename ReplicasT = Aws::Vector<ReplicaDescription>>
    TableDescription& WithReplicas(ReplicasT&& value) { SetReplicas(std::forward<ReplicasT>(value)); return *this;}
    template<typename ReplicasT = ReplicaDescription>
    TableDescription& AddReplicas(ReplicasT&& value) { m_replicasHasBeenSet = true; m_replicas.emplace_back(std::forward<ReplicasT>(value)); return *this; }
 
 
    inline const Aws::Vector<GlobalTableWitnessDescription>& GetGlobalTableWitnesses() const { return m_globalTableWitnesses; }
    inline bool GlobalTableWitnessesHasBeenSet() const { return m_globalTableWitnessesHasBeenSet; }
    template<typename GlobalTableWitnessesT = Aws::Vector<GlobalTableWitnessDescription>>
    void SetGlobalTableWitnesses(GlobalTableWitnessesT&& value) { m_globalTableWitnessesHasBeenSet = true; m_globalTableWitnesses = std::forward<GlobalTableWitnessesT>(value); }
    template<typename GlobalTableWitnessesT = Aws::Vector<GlobalTableWitnessDescription>>
    TableDescription& WithGlobalTableWitnesses(GlobalTableWitnessesT&& value) { SetGlobalTableWitnesses(std::forward<GlobalTableWitnessesT>(value)); return *this;}
    template<typename GlobalTableWitnessesT = GlobalTableWitnessDescription>
    TableDescription& AddGlobalTableWitnesses(GlobalTableWitnessesT&& value) { m_globalTableWitnessesHasBeenSet = true; m_globalTableWitnesses.emplace_back(std::forward<GlobalTableWitnessesT>(value)); return *this; }
 
 
    inline const RestoreSummary& GetRestoreSummary() const { return m_restoreSummary; }
    inline bool RestoreSummaryHasBeenSet() const { return m_restoreSummaryHasBeenSet; }
    template<typename RestoreSummaryT = RestoreSummary>
    void SetRestoreSummary(RestoreSummaryT&& value) { m_restoreSummaryHasBeenSet = true; m_restoreSummary = std::forward<RestoreSummaryT>(value); }
    template<typename RestoreSummaryT = RestoreSummary>
    TableDescription& WithRestoreSummary(RestoreSummaryT&& value) { SetRestoreSummary(std::forward<RestoreSummaryT>(value)); return *this;}
 
 
    inline const SSEDescription& GetSSEDescription() const { return m_sSEDescription; }
    inline bool SSEDescriptionHasBeenSet() const { return m_sSEDescriptionHasBeenSet; }
    template<typename SSEDescriptionT = SSEDescription>
    void SetSSEDescription(SSEDescriptionT&& value) { m_sSEDescriptionHasBeenSet = true; m_sSEDescription = std::forward<SSEDescriptionT>(value); }
    template<typename SSEDescriptionT = SSEDescription>
    TableDescription& WithSSEDescription(SSEDescriptionT&& value) { SetSSEDescription(std::forward<SSEDescriptionT>(value)); return *this;}
 
 
    inline const ArchivalSummary& GetArchivalSummary() const { return m_archivalSummary; }
    inline bool ArchivalSummaryHasBeenSet() const { return m_archivalSummaryHasBeenSet; }
    template<typename ArchivalSummaryT = ArchivalSummary>
    void SetArchivalSummary(ArchivalSummaryT&& value) { m_archivalSummaryHasBeenSet = true; m_archivalSummary = std::forward<ArchivalSummaryT>(value); }
    template<typename ArchivalSummaryT = ArchivalSummary>
    TableDescription& WithArchivalSummary(ArchivalSummaryT&& value) { SetArchivalSummary(std::forward<ArchivalSummaryT>(value)); return *this;}
 
 
    inline const TableClassSummary& GetTableClassSummary() const { return m_tableClassSummary; }
    inline bool TableClassSummaryHasBeenSet() const { return m_tableClassSummaryHasBeenSet; }
    template<typename TableClassSummaryT = TableClassSummary>
    void SetTableClassSummary(TableClassSummaryT&& value) { m_tableClassSummaryHasBeenSet = true; m_tableClassSummary = std::forward<TableClassSummaryT>(value); }
    template<typename TableClassSummaryT = TableClassSummary>
    TableDescription& WithTableClassSummary(TableClassSummaryT&& value) { SetTableClassSummary(std::forward<TableClassSummaryT>(value)); return *this;}
 
 
    inline bool GetDeletionProtectionEnabled() const { return m_deletionProtectionEnabled; }
    inline bool DeletionProtectionEnabledHasBeenSet() const { return m_deletionProtectionEnabledHasBeenSet; }
    inline void SetDeletionProtectionEnabled(bool value) { m_deletionProtectionEnabledHasBeenSet = true; m_deletionProtectionEnabled = value; }
    inline TableDescription& WithDeletionProtectionEnabled(bool value) { SetDeletionProtectionEnabled(value); return *this;}
 
 
    inline const OnDemandThroughput& GetOnDemandThroughput() const { return m_onDemandThroughput; }
    inline bool OnDemandThroughputHasBeenSet() const { return m_onDemandThroughputHasBeenSet; }
    template<typename OnDemandThroughputT = OnDemandThroughput>
    void SetOnDemandThroughput(OnDemandThroughputT&& value) { m_onDemandThroughputHasBeenSet = true; m_onDemandThroughput = std::forward<OnDemandThroughputT>(value); }
    template<typename OnDemandThroughputT = OnDemandThroughput>
    TableDescription& WithOnDemandThroughput(OnDemandThroughputT&& value) { SetOnDemandThroughput(std::forward<OnDemandThroughputT>(value)); return *this;}
 
 
    inline const TableWarmThroughputDescription& GetWarmThroughput() const { return m_warmThroughput; }
    inline bool WarmThroughputHasBeenSet() const { return m_warmThroughputHasBeenSet; }
    template<typename WarmThroughputT = TableWarmThroughputDescription>
    void SetWarmThroughput(WarmThroughputT&& value) { m_warmThroughputHasBeenSet = true; m_warmThroughput = std::forward<WarmThroughputT>(value); }
    template<typename WarmThroughputT = TableWarmThroughputDescription>
    TableDescription& WithWarmThroughput(WarmThroughputT&& value) { SetWarmThroughput(std::forward<WarmThroughputT>(value)); return *this;}
 
 
    inline MultiRegionConsistency GetMultiRegionConsistency() const { return m_multiRegionConsistency; }
    inline bool MultiRegionConsistencyHasBeenSet() const { return m_multiRegionConsistencyHasBeenSet; }
    inline void SetMultiRegionConsistency(MultiRegionConsistency value) { m_multiRegionConsistencyHasBeenSet = true; m_multiRegionConsistency = value; }
    inline TableDescription& WithMultiRegionConsistency(MultiRegionConsistency value) { SetMultiRegionConsistency(value); return *this;}
  private:
 
    Aws::Vector<AttributeDefinition> m_attributeDefinitions;
    bool m_attributeDefinitionsHasBeenSet = false;
 
    Aws::String m_tableName;
    bool m_tableNameHasBeenSet = false;
 
    Aws::Vector<KeySchemaElement> m_keySchema;
    bool m_keySchemaHasBeenSet = false;
 
    TableStatus m_tableStatus{TableStatus::NOT_SET};
    bool m_tableStatusHasBeenSet = false;
 
    Aws::Utils::DateTime m_creationDateTime{};
    bool m_creationDateTimeHasBeenSet = false;
 
    ProvisionedThroughputDescription m_provisionedThroughput;
    bool m_provisionedThroughputHasBeenSet = false;
 
    long long m_tableSizeBytes{0};
    bool m_tableSizeBytesHasBeenSet = false;
 
    long long m_itemCount{0};
    bool m_itemCountHasBeenSet = false;
 
    Aws::String m_tableArn;
    bool m_tableArnHasBeenSet = false;
 
    Aws::String m_tableId;
    bool m_tableIdHasBeenSet = false;
 
    BillingModeSummary m_billingModeSummary;
    bool m_billingModeSummaryHasBeenSet = false;
 
    Aws::Vector<LocalSecondaryIndexDescription> m_localSecondaryIndexes;
    bool m_localSecondaryIndexesHasBeenSet = false;
 
    Aws::Vector<GlobalSecondaryIndexDescription> m_globalSecondaryIndexes;
    bool m_globalSecondaryIndexesHasBeenSet = false;
 
    StreamSpecification m_streamSpecification;
    bool m_streamSpecificationHasBeenSet = false;
 
    Aws::String m_latestStreamLabel;
    bool m_latestStreamLabelHasBeenSet = false;
 
    Aws::String m_latestStreamArn;
    bool m_latestStreamArnHasBeenSet = false;
 
    Aws::String m_globalTableVersion;
    bool m_globalTableVersionHasBeenSet = false;
 
    Aws::Vector<ReplicaDescription> m_replicas;
    bool m_replicasHasBeenSet = false;
 
    Aws::Vector<GlobalTableWitnessDescription> m_globalTableWitnesses;
    bool m_globalTableWitnessesHasBeenSet = false;
 
    RestoreSummary m_restoreSummary;
    bool m_restoreSummaryHasBeenSet = false;
 
    SSEDescription m_sSEDescription;
    bool m_sSEDescriptionHasBeenSet = false;
 
    ArchivalSummary m_archivalSummary;
    bool m_archivalSummaryHasBeenSet = false;
 
    TableClassSummary m_tableClassSummary;
    bool m_tableClassSummaryHasBeenSet = false;
 
    bool m_deletionProtectionEnabled{false};
    bool m_deletionProtectionEnabledHasBeenSet = false;
 
    OnDemandThroughput m_onDemandThroughput;
    bool m_onDemandThroughputHasBeenSet = false;
 
    TableWarmThroughputDescription m_warmThroughput;
    bool m_warmThroughputHasBeenSet = false;
 
    MultiRegionConsistency m_multiRegionConsistency{MultiRegionConsistency::NOT_SET};
    bool m_multiRegionConsistencyHasBeenSet = false;
  };
 
} // namespace Model
} // namespace DynamoDB
} // namespace Aws