Record.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/keyspacesstreams/KeyspacesStreams_EXPORTS.h>
#include <aws/keyspacesstreams/model/KeyspacesCellValue.h>
#include <aws/keyspacesstreams/model/KeyspacesRow.h>
#include <aws/keyspacesstreams/model/OriginType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace KeyspacesStreams {
namespace Model {
 
class Record {
 public:
  AWS_KEYSPACESSTREAMS_API Record() = default;
  AWS_KEYSPACESSTREAMS_API Record(Aws::Utils::Json::JsonView jsonValue);
  AWS_KEYSPACESSTREAMS_API Record& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KEYSPACESSTREAMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetEventVersion() const { return m_eventVersion; }
  inline bool EventVersionHasBeenSet() const { return m_eventVersionHasBeenSet; }
  template <typename EventVersionT = Aws::String>
  void SetEventVersion(EventVersionT&& value) {
    m_eventVersionHasBeenSet = true;
    m_eventVersion = std::forward<EventVersionT>(value);
  }
  template <typename EventVersionT = Aws::String>
  Record& WithEventVersion(EventVersionT&& value) {
    SetEventVersion(std::forward<EventVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  Record& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline OriginType GetOrigin() const { return m_origin; }
  inline bool OriginHasBeenSet() const { return m_originHasBeenSet; }
  inline void SetOrigin(OriginType value) {
    m_originHasBeenSet = true;
    m_origin = value;
  }
  inline Record& WithOrigin(OriginType value) {
    SetOrigin(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, KeyspacesCellValue>& GetPartitionKeys() const { return m_partitionKeys; }
  inline bool PartitionKeysHasBeenSet() const { return m_partitionKeysHasBeenSet; }
  template <typename PartitionKeysT = Aws::Map<Aws::String, KeyspacesCellValue>>
  void SetPartitionKeys(PartitionKeysT&& value) {
    m_partitionKeysHasBeenSet = true;
    m_partitionKeys = std::forward<PartitionKeysT>(value);
  }
  template <typename PartitionKeysT = Aws::Map<Aws::String, KeyspacesCellValue>>
  Record& WithPartitionKeys(PartitionKeysT&& value) {
    SetPartitionKeys(std::forward<PartitionKeysT>(value));
    return *this;
  }
  template <typename PartitionKeysKeyT = Aws::String, typename PartitionKeysValueT = KeyspacesCellValue>
  Record& AddPartitionKeys(PartitionKeysKeyT&& key, PartitionKeysValueT&& value) {
    m_partitionKeysHasBeenSet = true;
    m_partitionKeys.emplace(std::forward<PartitionKeysKeyT>(key), std::forward<PartitionKeysValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, KeyspacesCellValue>& GetClusteringKeys() const { return m_clusteringKeys; }
  inline bool ClusteringKeysHasBeenSet() const { return m_clusteringKeysHasBeenSet; }
  template <typename ClusteringKeysT = Aws::Map<Aws::String, KeyspacesCellValue>>
  void SetClusteringKeys(ClusteringKeysT&& value) {
    m_clusteringKeysHasBeenSet = true;
    m_clusteringKeys = std::forward<ClusteringKeysT>(value);
  }
  template <typename ClusteringKeysT = Aws::Map<Aws::String, KeyspacesCellValue>>
  Record& WithClusteringKeys(ClusteringKeysT&& value) {
    SetClusteringKeys(std::forward<ClusteringKeysT>(value));
    return *this;
  }
  template <typename ClusteringKeysKeyT = Aws::String, typename ClusteringKeysValueT = KeyspacesCellValue>
  Record& AddClusteringKeys(ClusteringKeysKeyT&& key, ClusteringKeysValueT&& value) {
    m_clusteringKeysHasBeenSet = true;
    m_clusteringKeys.emplace(std::forward<ClusteringKeysKeyT>(key), std::forward<ClusteringKeysValueT>(value));
    return *this;
  }
 
 
  inline const KeyspacesRow& GetNewImage() const { return m_newImage; }
  inline bool NewImageHasBeenSet() const { return m_newImageHasBeenSet; }
  template <typename NewImageT = KeyspacesRow>
  void SetNewImage(NewImageT&& value) {
    m_newImageHasBeenSet = true;
    m_newImage = std::forward<NewImageT>(value);
  }
  template <typename NewImageT = KeyspacesRow>
  Record& WithNewImage(NewImageT&& value) {
    SetNewImage(std::forward<NewImageT>(value));
    return *this;
  }
 
 
  inline const KeyspacesRow& GetOldImage() const { return m_oldImage; }
  inline bool OldImageHasBeenSet() const { return m_oldImageHasBeenSet; }
  template <typename OldImageT = KeyspacesRow>
  void SetOldImage(OldImageT&& value) {
    m_oldImageHasBeenSet = true;
    m_oldImage = std::forward<OldImageT>(value);
  }
  template <typename OldImageT = KeyspacesRow>
  Record& WithOldImage(OldImageT&& value) {
    SetOldImage(std::forward<OldImageT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSequenceNumber() const { return m_sequenceNumber; }
  inline bool SequenceNumberHasBeenSet() const { return m_sequenceNumberHasBeenSet; }
  template <typename SequenceNumberT = Aws::String>
  void SetSequenceNumber(SequenceNumberT&& value) {
    m_sequenceNumberHasBeenSet = true;
    m_sequenceNumber = std::forward<SequenceNumberT>(value);
  }
  template <typename SequenceNumberT = Aws::String>
  Record& WithSequenceNumber(SequenceNumberT&& value) {
    SetSequenceNumber(std::forward<SequenceNumberT>(value));
    return *this;
  }
 private:
  Aws::String m_eventVersion;
 
  Aws::Utils::DateTime m_createdAt{};
 
  OriginType m_origin{OriginType::NOT_SET};
 
  Aws::Map<Aws::String, KeyspacesCellValue> m_partitionKeys;
 
  Aws::Map<Aws::String, KeyspacesCellValue> m_clusteringKeys;
 
  KeyspacesRow m_newImage;
 
  KeyspacesRow m_oldImage;
 
  Aws::String m_sequenceNumber;
  bool m_eventVersionHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_originHasBeenSet = false;
  bool m_partitionKeysHasBeenSet = false;
  bool m_clusteringKeysHasBeenSet = false;
  bool m_newImageHasBeenSet = false;
  bool m_oldImageHasBeenSet = false;
  bool m_sequenceNumberHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace KeyspacesStreams
}  // namespace Aws