Record.h

 
#pragma once
#include <aws/keyspacesstreams/KeyspacesStreams_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <aws/keyspacesstreams/model/OriginType.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/keyspacesstreams/model/KeyspacesRow.h>
#include <aws/keyspacesstreams/model/KeyspacesCellValue.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;
    bool m_eventVersionHasBeenSet = false;
 
    Aws::Utils::DateTime m_createdAt{};
    bool m_createdAtHasBeenSet = false;
 
    OriginType m_origin{OriginType::NOT_SET};
    bool m_originHasBeenSet = false;
 
    Aws::Map<Aws::String, KeyspacesCellValue> m_partitionKeys;
    bool m_partitionKeysHasBeenSet = false;
 
    Aws::Map<Aws::String, KeyspacesCellValue> m_clusteringKeys;
    bool m_clusteringKeysHasBeenSet = false;
 
    KeyspacesRow m_newImage;
    bool m_newImageHasBeenSet = false;
 
    KeyspacesRow m_oldImage;
    bool m_oldImageHasBeenSet = false;
 
    Aws::String m_sequenceNumber;
    bool m_sequenceNumberHasBeenSet = false;
  };
 
} // namespace Model
} // namespace KeyspacesStreams
} // namespace Aws