KeyspacesCellValue.h

 
#pragma once
#include <aws/core/utils/Array.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/keyspacesstreams/KeyspacesStreams_EXPORTS.h>
#include <aws/keyspacesstreams/model/KeyspacesCell.h>
#include <aws/keyspacesstreams/model/KeyspacesCellMapDefinition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace KeyspacesStreams {
namespace Model {
class KeyspacesCell;
class KeyspacesCellMapDefinition;
 
class KeyspacesCellValue {
 public:
  AWS_KEYSPACESSTREAMS_API KeyspacesCellValue() = default;
  AWS_KEYSPACESSTREAMS_API KeyspacesCellValue(Aws::Utils::Json::JsonView jsonValue);
  AWS_KEYSPACESSTREAMS_API KeyspacesCellValue& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_KEYSPACESSTREAMS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetAsciiT() const { return m_asciiT; }
  inline bool AsciiTHasBeenSet() const { return m_asciiTHasBeenSet; }
  template <typename AsciiTT = Aws::String>
  void SetAsciiT(AsciiTT&& value) {
    m_asciiTHasBeenSet = true;
    m_asciiT = std::forward<AsciiTT>(value);
  }
  template <typename AsciiTT = Aws::String>
  KeyspacesCellValue& WithAsciiT(AsciiTT&& value) {
    SetAsciiT(std::forward<AsciiTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBigintT() const { return m_bigintT; }
  inline bool BigintTHasBeenSet() const { return m_bigintTHasBeenSet; }
  template <typename BigintTT = Aws::String>
  void SetBigintT(BigintTT&& value) {
    m_bigintTHasBeenSet = true;
    m_bigintT = std::forward<BigintTT>(value);
  }
  template <typename BigintTT = Aws::String>
  KeyspacesCellValue& WithBigintT(BigintTT&& value) {
    SetBigintT(std::forward<BigintTT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::ByteBuffer& GetBlobT() const { return m_blobT; }
  inline bool BlobTHasBeenSet() const { return m_blobTHasBeenSet; }
  template <typename BlobTT = Aws::Utils::ByteBuffer>
  void SetBlobT(BlobTT&& value) {
    m_blobTHasBeenSet = true;
    m_blobT = std::forward<BlobTT>(value);
  }
  template <typename BlobTT = Aws::Utils::ByteBuffer>
  KeyspacesCellValue& WithBlobT(BlobTT&& value) {
    SetBlobT(std::forward<BlobTT>(value));
    return *this;
  }
 
 
  inline bool GetBoolT() const { return m_boolT; }
  inline bool BoolTHasBeenSet() const { return m_boolTHasBeenSet; }
  inline void SetBoolT(bool value) {
    m_boolTHasBeenSet = true;
    m_boolT = value;
  }
  inline KeyspacesCellValue& WithBoolT(bool value) {
    SetBoolT(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCounterT() const { return m_counterT; }
  inline bool CounterTHasBeenSet() const { return m_counterTHasBeenSet; }
  template <typename CounterTT = Aws::String>
  void SetCounterT(CounterTT&& value) {
    m_counterTHasBeenSet = true;
    m_counterT = std::forward<CounterTT>(value);
  }
  template <typename CounterTT = Aws::String>
  KeyspacesCellValue& WithCounterT(CounterTT&& value) {
    SetCounterT(std::forward<CounterTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDateT() const { return m_dateT; }
  inline bool DateTHasBeenSet() const { return m_dateTHasBeenSet; }
  template <typename DateTT = Aws::String>
  void SetDateT(DateTT&& value) {
    m_dateTHasBeenSet = true;
    m_dateT = std::forward<DateTT>(value);
  }
  template <typename DateTT = Aws::String>
  KeyspacesCellValue& WithDateT(DateTT&& value) {
    SetDateT(std::forward<DateTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDecimalT() const { return m_decimalT; }
  inline bool DecimalTHasBeenSet() const { return m_decimalTHasBeenSet; }
  template <typename DecimalTT = Aws::String>
  void SetDecimalT(DecimalTT&& value) {
    m_decimalTHasBeenSet = true;
    m_decimalT = std::forward<DecimalTT>(value);
  }
  template <typename DecimalTT = Aws::String>
  KeyspacesCellValue& WithDecimalT(DecimalTT&& value) {
    SetDecimalT(std::forward<DecimalTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDoubleT() const { return m_doubleT; }
  inline bool DoubleTHasBeenSet() const { return m_doubleTHasBeenSet; }
  template <typename DoubleTT = Aws::String>
  void SetDoubleT(DoubleTT&& value) {
    m_doubleTHasBeenSet = true;
    m_doubleT = std::forward<DoubleTT>(value);
  }
  template <typename DoubleTT = Aws::String>
  KeyspacesCellValue& WithDoubleT(DoubleTT&& value) {
    SetDoubleT(std::forward<DoubleTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDurationT() const { return m_durationT; }
  inline bool DurationTHasBeenSet() const { return m_durationTHasBeenSet; }
  template <typename DurationTT = Aws::String>
  void SetDurationT(DurationTT&& value) {
    m_durationTHasBeenSet = true;
    m_durationT = std::forward<DurationTT>(value);
  }
  template <typename DurationTT = Aws::String>
  KeyspacesCellValue& WithDurationT(DurationTT&& value) {
    SetDurationT(std::forward<DurationTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFloatT() const { return m_floatT; }
  inline bool FloatTHasBeenSet() const { return m_floatTHasBeenSet; }
  template <typename FloatTT = Aws::String>
  void SetFloatT(FloatTT&& value) {
    m_floatTHasBeenSet = true;
    m_floatT = std::forward<FloatTT>(value);
  }
  template <typename FloatTT = Aws::String>
  KeyspacesCellValue& WithFloatT(FloatTT&& value) {
    SetFloatT(std::forward<FloatTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInetT() const { return m_inetT; }
  inline bool InetTHasBeenSet() const { return m_inetTHasBeenSet; }
  template <typename InetTT = Aws::String>
  void SetInetT(InetTT&& value) {
    m_inetTHasBeenSet = true;
    m_inetT = std::forward<InetTT>(value);
  }
  template <typename InetTT = Aws::String>
  KeyspacesCellValue& WithInetT(InetTT&& value) {
    SetInetT(std::forward<InetTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIntT() const { return m_intT; }
  inline bool IntTHasBeenSet() const { return m_intTHasBeenSet; }
  template <typename IntTT = Aws::String>
  void SetIntT(IntTT&& value) {
    m_intTHasBeenSet = true;
    m_intT = std::forward<IntTT>(value);
  }
  template <typename IntTT = Aws::String>
  KeyspacesCellValue& WithIntT(IntTT&& value) {
    SetIntT(std::forward<IntTT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<KeyspacesCell>& GetListT() const { return m_listT; }
  inline bool ListTHasBeenSet() const { return m_listTHasBeenSet; }
  template <typename ListTT = Aws::Vector<KeyspacesCell>>
  void SetListT(ListTT&& value) {
    m_listTHasBeenSet = true;
    m_listT = std::forward<ListTT>(value);
  }
  template <typename ListTT = Aws::Vector<KeyspacesCell>>
  KeyspacesCellValue& WithListT(ListTT&& value) {
    SetListT(std::forward<ListTT>(value));
    return *this;
  }
  template <typename ListTT = KeyspacesCell>
  KeyspacesCellValue& AddListT(ListTT&& value) {
    m_listTHasBeenSet = true;
    m_listT.emplace_back(std::forward<ListTT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<KeyspacesCellMapDefinition>& GetMapT() const { return m_mapT; }
  inline bool MapTHasBeenSet() const { return m_mapTHasBeenSet; }
  template <typename MapTT = Aws::Vector<KeyspacesCellMapDefinition>>
  void SetMapT(MapTT&& value) {
    m_mapTHasBeenSet = true;
    m_mapT = std::forward<MapTT>(value);
  }
  template <typename MapTT = Aws::Vector<KeyspacesCellMapDefinition>>
  KeyspacesCellValue& WithMapT(MapTT&& value) {
    SetMapT(std::forward<MapTT>(value));
    return *this;
  }
  template <typename MapTT = KeyspacesCellMapDefinition>
  KeyspacesCellValue& AddMapT(MapTT&& value) {
    m_mapTHasBeenSet = true;
    m_mapT.emplace_back(std::forward<MapTT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<KeyspacesCell>& GetSetT() const { return m_setT; }
  inline bool SetTHasBeenSet() const { return m_setTHasBeenSet; }
  template <typename SetTT = Aws::Vector<KeyspacesCell>>
  void SetSetT(SetTT&& value) {
    m_setTHasBeenSet = true;
    m_setT = std::forward<SetTT>(value);
  }
  template <typename SetTT = Aws::Vector<KeyspacesCell>>
  KeyspacesCellValue& WithSetT(SetTT&& value) {
    SetSetT(std::forward<SetTT>(value));
    return *this;
  }
  template <typename SetTT = KeyspacesCell>
  KeyspacesCellValue& AddSetT(SetTT&& value) {
    m_setTHasBeenSet = true;
    m_setT.emplace_back(std::forward<SetTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSmallintT() const { return m_smallintT; }
  inline bool SmallintTHasBeenSet() const { return m_smallintTHasBeenSet; }
  template <typename SmallintTT = Aws::String>
  void SetSmallintT(SmallintTT&& value) {
    m_smallintTHasBeenSet = true;
    m_smallintT = std::forward<SmallintTT>(value);
  }
  template <typename SmallintTT = Aws::String>
  KeyspacesCellValue& WithSmallintT(SmallintTT&& value) {
    SetSmallintT(std::forward<SmallintTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTextT() const { return m_textT; }
  inline bool TextTHasBeenSet() const { return m_textTHasBeenSet; }
  template <typename TextTT = Aws::String>
  void SetTextT(TextTT&& value) {
    m_textTHasBeenSet = true;
    m_textT = std::forward<TextTT>(value);
  }
  template <typename TextTT = Aws::String>
  KeyspacesCellValue& WithTextT(TextTT&& value) {
    SetTextT(std::forward<TextTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTimeT() const { return m_timeT; }
  inline bool TimeTHasBeenSet() const { return m_timeTHasBeenSet; }
  template <typename TimeTT = Aws::String>
  void SetTimeT(TimeTT&& value) {
    m_timeTHasBeenSet = true;
    m_timeT = std::forward<TimeTT>(value);
  }
  template <typename TimeTT = Aws::String>
  KeyspacesCellValue& WithTimeT(TimeTT&& value) {
    SetTimeT(std::forward<TimeTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTimestampT() const { return m_timestampT; }
  inline bool TimestampTHasBeenSet() const { return m_timestampTHasBeenSet; }
  template <typename TimestampTT = Aws::String>
  void SetTimestampT(TimestampTT&& value) {
    m_timestampTHasBeenSet = true;
    m_timestampT = std::forward<TimestampTT>(value);
  }
  template <typename TimestampTT = Aws::String>
  KeyspacesCellValue& WithTimestampT(TimestampTT&& value) {
    SetTimestampT(std::forward<TimestampTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTimeuuidT() const { return m_timeuuidT; }
  inline bool TimeuuidTHasBeenSet() const { return m_timeuuidTHasBeenSet; }
  template <typename TimeuuidTT = Aws::String>
  void SetTimeuuidT(TimeuuidTT&& value) {
    m_timeuuidTHasBeenSet = true;
    m_timeuuidT = std::forward<TimeuuidTT>(value);
  }
  template <typename TimeuuidTT = Aws::String>
  KeyspacesCellValue& WithTimeuuidT(TimeuuidTT&& value) {
    SetTimeuuidT(std::forward<TimeuuidTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTinyintT() const { return m_tinyintT; }
  inline bool TinyintTHasBeenSet() const { return m_tinyintTHasBeenSet; }
  template <typename TinyintTT = Aws::String>
  void SetTinyintT(TinyintTT&& value) {
    m_tinyintTHasBeenSet = true;
    m_tinyintT = std::forward<TinyintTT>(value);
  }
  template <typename TinyintTT = Aws::String>
  KeyspacesCellValue& WithTinyintT(TinyintTT&& value) {
    SetTinyintT(std::forward<TinyintTT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<KeyspacesCell>& GetTupleT() const { return m_tupleT; }
  inline bool TupleTHasBeenSet() const { return m_tupleTHasBeenSet; }
  template <typename TupleTT = Aws::Vector<KeyspacesCell>>
  void SetTupleT(TupleTT&& value) {
    m_tupleTHasBeenSet = true;
    m_tupleT = std::forward<TupleTT>(value);
  }
  template <typename TupleTT = Aws::Vector<KeyspacesCell>>
  KeyspacesCellValue& WithTupleT(TupleTT&& value) {
    SetTupleT(std::forward<TupleTT>(value));
    return *this;
  }
  template <typename TupleTT = KeyspacesCell>
  KeyspacesCellValue& AddTupleT(TupleTT&& value) {
    m_tupleTHasBeenSet = true;
    m_tupleT.emplace_back(std::forward<TupleTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUuidT() const { return m_uuidT; }
  inline bool UuidTHasBeenSet() const { return m_uuidTHasBeenSet; }
  template <typename UuidTT = Aws::String>
  void SetUuidT(UuidTT&& value) {
    m_uuidTHasBeenSet = true;
    m_uuidT = std::forward<UuidTT>(value);
  }
  template <typename UuidTT = Aws::String>
  KeyspacesCellValue& WithUuidT(UuidTT&& value) {
    SetUuidT(std::forward<UuidTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVarcharT() const { return m_varcharT; }
  inline bool VarcharTHasBeenSet() const { return m_varcharTHasBeenSet; }
  template <typename VarcharTT = Aws::String>
  void SetVarcharT(VarcharTT&& value) {
    m_varcharTHasBeenSet = true;
    m_varcharT = std::forward<VarcharTT>(value);
  }
  template <typename VarcharTT = Aws::String>
  KeyspacesCellValue& WithVarcharT(VarcharTT&& value) {
    SetVarcharT(std::forward<VarcharTT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVarintT() const { return m_varintT; }
  inline bool VarintTHasBeenSet() const { return m_varintTHasBeenSet; }
  template <typename VarintTT = Aws::String>
  void SetVarintT(VarintTT&& value) {
    m_varintTHasBeenSet = true;
    m_varintT = std::forward<VarintTT>(value);
  }
  template <typename VarintTT = Aws::String>
  KeyspacesCellValue& WithVarintT(VarintTT&& value) {
    SetVarintT(std::forward<VarintTT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, KeyspacesCell>& GetUdtT() const { return m_udtT; }
  inline bool UdtTHasBeenSet() const { return m_udtTHasBeenSet; }
  template <typename UdtTT = Aws::Map<Aws::String, KeyspacesCell>>
  void SetUdtT(UdtTT&& value) {
    m_udtTHasBeenSet = true;
    m_udtT = std::forward<UdtTT>(value);
  }
  template <typename UdtTT = Aws::Map<Aws::String, KeyspacesCell>>
  KeyspacesCellValue& WithUdtT(UdtTT&& value) {
    SetUdtT(std::forward<UdtTT>(value));
    return *this;
  }
  template <typename UdtTKeyT = Aws::String, typename UdtTValueT = KeyspacesCell>
  KeyspacesCellValue& AddUdtT(UdtTKeyT&& key, UdtTValueT&& value) {
    m_udtTHasBeenSet = true;
    m_udtT.emplace(std::forward<UdtTKeyT>(key), std::forward<UdtTValueT>(value));
    return *this;
  }
 private:
  Aws::String m_asciiT;
 
  Aws::String m_bigintT;
 
  Aws::Utils::ByteBuffer m_blobT{};
 
  bool m_boolT{false};
 
  Aws::String m_counterT;
 
  Aws::String m_dateT;
 
  Aws::String m_decimalT;
 
  Aws::String m_doubleT;
 
  Aws::String m_durationT;
 
  Aws::String m_floatT;
 
  Aws::String m_inetT;
 
  Aws::String m_intT;
 
  Aws::Vector<KeyspacesCell> m_listT;
 
  Aws::Vector<KeyspacesCellMapDefinition> m_mapT;
 
  Aws::Vector<KeyspacesCell> m_setT;
 
  Aws::String m_smallintT;
 
  Aws::String m_textT;
 
  Aws::String m_timeT;
 
  Aws::String m_timestampT;
 
  Aws::String m_timeuuidT;
 
  Aws::String m_tinyintT;
 
  Aws::Vector<KeyspacesCell> m_tupleT;
 
  Aws::String m_uuidT;
 
  Aws::String m_varcharT;
 
  Aws::String m_varintT;
 
  Aws::Map<Aws::String, KeyspacesCell> m_udtT;
  bool m_asciiTHasBeenSet = false;
  bool m_bigintTHasBeenSet = false;
  bool m_blobTHasBeenSet = false;
  bool m_boolTHasBeenSet = false;
  bool m_counterTHasBeenSet = false;
  bool m_dateTHasBeenSet = false;
  bool m_decimalTHasBeenSet = false;
  bool m_doubleTHasBeenSet = false;
  bool m_durationTHasBeenSet = false;
  bool m_floatTHasBeenSet = false;
  bool m_inetTHasBeenSet = false;
  bool m_intTHasBeenSet = false;
  bool m_listTHasBeenSet = false;
  bool m_mapTHasBeenSet = false;
  bool m_setTHasBeenSet = false;
  bool m_smallintTHasBeenSet = false;
  bool m_textTHasBeenSet = false;
  bool m_timeTHasBeenSet = false;
  bool m_timestampTHasBeenSet = false;
  bool m_timeuuidTHasBeenSet = false;
  bool m_tinyintTHasBeenSet = false;
  bool m_tupleTHasBeenSet = false;
  bool m_uuidTHasBeenSet = false;
  bool m_varcharTHasBeenSet = false;
  bool m_varintTHasBeenSet = false;
  bool m_udtTHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace KeyspacesStreams
}  // namespace Aws