ConsumedCapacity.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/dynamodb/DynamoDB_EXPORTS.h>
#include <aws/dynamodb/model/Capacity.h>
#include <aws/dynamodb/model/VectorCapacity.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DynamoDB {
namespace Model {
 
class ConsumedCapacity {
 public:
  AWS_DYNAMODB_API ConsumedCapacity() = default;
  AWS_DYNAMODB_API ConsumedCapacity(Aws::Utils::Json::JsonView jsonValue);
  AWS_DYNAMODB_API ConsumedCapacity& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DYNAMODB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  ConsumedCapacity& WithTableName(TableNameT&& value) {
    SetTableName(std::forward<TableNameT>(value));
    return *this;
  }
 
 
  inline double GetCapacityUnits() const { return m_capacityUnits; }
  inline bool CapacityUnitsHasBeenSet() const { return m_capacityUnitsHasBeenSet; }
  inline void SetCapacityUnits(double value) {
    m_capacityUnitsHasBeenSet = true;
    m_capacityUnits = value;
  }
  inline ConsumedCapacity& WithCapacityUnits(double value) {
    SetCapacityUnits(value);
    return *this;
  }
 
 
  inline double GetReadCapacityUnits() const { return m_readCapacityUnits; }
  inline bool ReadCapacityUnitsHasBeenSet() const { return m_readCapacityUnitsHasBeenSet; }
  inline void SetReadCapacityUnits(double value) {
    m_readCapacityUnitsHasBeenSet = true;
    m_readCapacityUnits = value;
  }
  inline ConsumedCapacity& WithReadCapacityUnits(double value) {
    SetReadCapacityUnits(value);
    return *this;
  }
 
 
  inline double GetWriteCapacityUnits() const { return m_writeCapacityUnits; }
  inline bool WriteCapacityUnitsHasBeenSet() const { return m_writeCapacityUnitsHasBeenSet; }
  inline void SetWriteCapacityUnits(double value) {
    m_writeCapacityUnitsHasBeenSet = true;
    m_writeCapacityUnits = value;
  }
  inline ConsumedCapacity& WithWriteCapacityUnits(double value) {
    SetWriteCapacityUnits(value);
    return *this;
  }
 
 
  inline const Capacity& GetTable() const { return m_table; }
  inline bool TableHasBeenSet() const { return m_tableHasBeenSet; }
  template <typename TableT = Capacity>
  void SetTable(TableT&& value) {
    m_tableHasBeenSet = true;
    m_table = std::forward<TableT>(value);
  }
  template <typename TableT = Capacity>
  ConsumedCapacity& WithTable(TableT&& value) {
    SetTable(std::forward<TableT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Capacity>& GetLocalSecondaryIndexes() const { return m_localSecondaryIndexes; }
  inline bool LocalSecondaryIndexesHasBeenSet() const { return m_localSecondaryIndexesHasBeenSet; }
  template <typename LocalSecondaryIndexesT = Aws::Map<Aws::String, Capacity>>
  void SetLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) {
    m_localSecondaryIndexesHasBeenSet = true;
    m_localSecondaryIndexes = std::forward<LocalSecondaryIndexesT>(value);
  }
  template <typename LocalSecondaryIndexesT = Aws::Map<Aws::String, Capacity>>
  ConsumedCapacity& WithLocalSecondaryIndexes(LocalSecondaryIndexesT&& value) {
    SetLocalSecondaryIndexes(std::forward<LocalSecondaryIndexesT>(value));
    return *this;
  }
  template <typename LocalSecondaryIndexesKeyT = Aws::String, typename LocalSecondaryIndexesValueT = Capacity>
  ConsumedCapacity& AddLocalSecondaryIndexes(LocalSecondaryIndexesKeyT&& key, LocalSecondaryIndexesValueT&& value) {
    m_localSecondaryIndexesHasBeenSet = true;
    m_localSecondaryIndexes.emplace(std::forward<LocalSecondaryIndexesKeyT>(key), std::forward<LocalSecondaryIndexesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Capacity>& GetGlobalSecondaryIndexes() const { return m_globalSecondaryIndexes; }
  inline bool GlobalSecondaryIndexesHasBeenSet() const { return m_globalSecondaryIndexesHasBeenSet; }
  template <typename GlobalSecondaryIndexesT = Aws::Map<Aws::String, Capacity>>
  void SetGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) {
    m_globalSecondaryIndexesHasBeenSet = true;
    m_globalSecondaryIndexes = std::forward<GlobalSecondaryIndexesT>(value);
  }
  template <typename GlobalSecondaryIndexesT = Aws::Map<Aws::String, Capacity>>
  ConsumedCapacity& WithGlobalSecondaryIndexes(GlobalSecondaryIndexesT&& value) {
    SetGlobalSecondaryIndexes(std::forward<GlobalSecondaryIndexesT>(value));
    return *this;
  }
  template <typename GlobalSecondaryIndexesKeyT = Aws::String, typename GlobalSecondaryIndexesValueT = Capacity>
  ConsumedCapacity& AddGlobalSecondaryIndexes(GlobalSecondaryIndexesKeyT&& key, GlobalSecondaryIndexesValueT&& value) {
    m_globalSecondaryIndexesHasBeenSet = true;
    m_globalSecondaryIndexes.emplace(std::forward<GlobalSecondaryIndexesKeyT>(key), std::forward<GlobalSecondaryIndexesValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, VectorCapacity>& GetVectorIndexes() const { return m_vectorIndexes; }
  inline bool VectorIndexesHasBeenSet() const { return m_vectorIndexesHasBeenSet; }
  template <typename VectorIndexesT = Aws::Map<Aws::String, VectorCapacity>>
  void SetVectorIndexes(VectorIndexesT&& value) {
    m_vectorIndexesHasBeenSet = true;
    m_vectorIndexes = std::forward<VectorIndexesT>(value);
  }
  template <typename VectorIndexesT = Aws::Map<Aws::String, VectorCapacity>>
  ConsumedCapacity& WithVectorIndexes(VectorIndexesT&& value) {
    SetVectorIndexes(std::forward<VectorIndexesT>(value));
    return *this;
  }
  template <typename VectorIndexesKeyT = Aws::String, typename VectorIndexesValueT = VectorCapacity>
  ConsumedCapacity& AddVectorIndexes(VectorIndexesKeyT&& key, VectorIndexesValueT&& value) {
    m_vectorIndexesHasBeenSet = true;
    m_vectorIndexes.emplace(std::forward<VectorIndexesKeyT>(key), std::forward<VectorIndexesValueT>(value));
    return *this;
  }
 private:
  Aws::String m_tableName;
 
  double m_capacityUnits{0.0};
 
  double m_readCapacityUnits{0.0};
 
  double m_writeCapacityUnits{0.0};
 
  Capacity m_table;
 
  Aws::Map<Aws::String, Capacity> m_localSecondaryIndexes;
 
  Aws::Map<Aws::String, Capacity> m_globalSecondaryIndexes;
 
  Aws::Map<Aws::String, VectorCapacity> m_vectorIndexes;
  bool m_tableNameHasBeenSet = false;
  bool m_capacityUnitsHasBeenSet = false;
  bool m_readCapacityUnitsHasBeenSet = false;
  bool m_writeCapacityUnitsHasBeenSet = false;
  bool m_tableHasBeenSet = false;
  bool m_localSecondaryIndexesHasBeenSet = false;
  bool m_globalSecondaryIndexesHasBeenSet = false;
  bool m_vectorIndexesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DynamoDB
}  // namespace Aws