SparqlRecord.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/neptunedata/Neptunedata_EXPORTS.h>
#include <aws/neptunedata/model/SparqlData.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace neptunedata {
namespace Model {
 
class SparqlRecord {
 public:
  AWS_NEPTUNEDATA_API SparqlRecord() = default;
  AWS_NEPTUNEDATA_API SparqlRecord(Aws::Utils::Json::JsonView jsonValue);
  AWS_NEPTUNEDATA_API SparqlRecord& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_NEPTUNEDATA_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline long long GetCommitTimestampInMillis() const { return m_commitTimestampInMillis; }
  inline bool CommitTimestampInMillisHasBeenSet() const { return m_commitTimestampInMillisHasBeenSet; }
  inline void SetCommitTimestampInMillis(long long value) {
    m_commitTimestampInMillisHasBeenSet = true;
    m_commitTimestampInMillis = value;
  }
  inline SparqlRecord& WithCommitTimestampInMillis(long long value) {
    SetCommitTimestampInMillis(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetEventId() const { return m_eventId; }
  inline bool EventIdHasBeenSet() const { return m_eventIdHasBeenSet; }
  template <typename EventIdT = Aws::Map<Aws::String, Aws::String>>
  void SetEventId(EventIdT&& value) {
    m_eventIdHasBeenSet = true;
    m_eventId = std::forward<EventIdT>(value);
  }
  template <typename EventIdT = Aws::Map<Aws::String, Aws::String>>
  SparqlRecord& WithEventId(EventIdT&& value) {
    SetEventId(std::forward<EventIdT>(value));
    return *this;
  }
  template <typename EventIdKeyT = Aws::String, typename EventIdValueT = Aws::String>
  SparqlRecord& AddEventId(EventIdKeyT&& key, EventIdValueT&& value) {
    m_eventIdHasBeenSet = true;
    m_eventId.emplace(std::forward<EventIdKeyT>(key), std::forward<EventIdValueT>(value));
    return *this;
  }
 
 
  inline const SparqlData& GetData() const { return m_data; }
  inline bool DataHasBeenSet() const { return m_dataHasBeenSet; }
  template <typename DataT = SparqlData>
  void SetData(DataT&& value) {
    m_dataHasBeenSet = true;
    m_data = std::forward<DataT>(value);
  }
  template <typename DataT = SparqlData>
  SparqlRecord& WithData(DataT&& value) {
    SetData(std::forward<DataT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOp() const { return m_op; }
  inline bool OpHasBeenSet() const { return m_opHasBeenSet; }
  template <typename OpT = Aws::String>
  void SetOp(OpT&& value) {
    m_opHasBeenSet = true;
    m_op = std::forward<OpT>(value);
  }
  template <typename OpT = Aws::String>
  SparqlRecord& WithOp(OpT&& value) {
    SetOp(std::forward<OpT>(value));
    return *this;
  }
 
 
  inline bool GetIsLastOp() const { return m_isLastOp; }
  inline bool IsLastOpHasBeenSet() const { return m_isLastOpHasBeenSet; }
  inline void SetIsLastOp(bool value) {
    m_isLastOpHasBeenSet = true;
    m_isLastOp = value;
  }
  inline SparqlRecord& WithIsLastOp(bool value) {
    SetIsLastOp(value);
    return *this;
  }
 private:
  long long m_commitTimestampInMillis{0};
 
  Aws::Map<Aws::String, Aws::String> m_eventId;
 
  SparqlData m_data;
 
  Aws::String m_op;
 
  bool m_isLastOp{false};
  bool m_commitTimestampInMillisHasBeenSet = false;
  bool m_eventIdHasBeenSet = false;
  bool m_dataHasBeenSet = false;
  bool m_opHasBeenSet = false;
  bool m_isLastOpHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace neptunedata
}  // namespace Aws