AttributeValue.h

 
#pragma once
#include <aws/verifiedpermissions/VerifiedPermissions_EXPORTS.h>
#include <aws/verifiedpermissions/model/EntityIdentifier.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace VerifiedPermissions
{
namespace Model
{
 
  class AttributeValue
  {
  public:
    AWS_VERIFIEDPERMISSIONS_API AttributeValue() = default;
    AWS_VERIFIEDPERMISSIONS_API AttributeValue(Aws::Utils::Json::JsonView jsonValue);
    AWS_VERIFIEDPERMISSIONS_API AttributeValue& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_VERIFIEDPERMISSIONS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline bool GetBoolean() const { return m_boolean; }
    inline bool BooleanHasBeenSet() const { return m_booleanHasBeenSet; }
    inline void SetBoolean(bool value) { m_booleanHasBeenSet = true; m_boolean = value; }
    inline AttributeValue& WithBoolean(bool value) { SetBoolean(value); return *this;}
 
 
    inline const EntityIdentifier& GetEntityIdentifier() const { return m_entityIdentifier; }
    inline bool EntityIdentifierHasBeenSet() const { return m_entityIdentifierHasBeenSet; }
    template<typename EntityIdentifierT = EntityIdentifier>
    void SetEntityIdentifier(EntityIdentifierT&& value) { m_entityIdentifierHasBeenSet = true; m_entityIdentifier = std::forward<EntityIdentifierT>(value); }
    template<typename EntityIdentifierT = EntityIdentifier>
    AttributeValue& WithEntityIdentifier(EntityIdentifierT&& value) { SetEntityIdentifier(std::forward<EntityIdentifierT>(value)); return *this;}
 
 
    inline long long GetLong() const { return m_long; }
    inline bool LongHasBeenSet() const { return m_longHasBeenSet; }
    inline void SetLong(long long value) { m_longHasBeenSet = true; m_long = value; }
    inline AttributeValue& WithLong(long long value) { SetLong(value); return *this;}
 
 
    inline const Aws::String& GetString() const { return m_string; }
    inline bool StringHasBeenSet() const { return m_stringHasBeenSet; }
    template<typename StringT = Aws::String>
    void SetString(StringT&& value) { m_stringHasBeenSet = true; m_string = std::forward<StringT>(value); }
    template<typename StringT = Aws::String>
    AttributeValue& WithString(StringT&& value) { SetString(std::forward<StringT>(value)); return *this;}
 
 
    inline const Aws::Vector<AttributeValue>& GetSet() const { return m_set; }
    inline bool SetHasBeenSet() const { return m_setHasBeenSet; }
    template<typename SetT = Aws::Vector<AttributeValue>>
    void SetSet(SetT&& value) { m_setHasBeenSet = true; m_set = std::forward<SetT>(value); }
    template<typename SetT = Aws::Vector<AttributeValue>>
    AttributeValue& WithSet(SetT&& value) { SetSet(std::forward<SetT>(value)); return *this;}
    template<typename SetT = AttributeValue>
    AttributeValue& AddSet(SetT&& value) { m_setHasBeenSet = true; m_set.emplace_back(std::forward<SetT>(value)); return *this; }
 
 
    inline const Aws::Map<Aws::String, AttributeValue>& GetRecord() const { return m_record; }
    inline bool RecordHasBeenSet() const { return m_recordHasBeenSet; }
    template<typename RecordT = Aws::Map<Aws::String, AttributeValue>>
    void SetRecord(RecordT&& value) { m_recordHasBeenSet = true; m_record = std::forward<RecordT>(value); }
    template<typename RecordT = Aws::Map<Aws::String, AttributeValue>>
    AttributeValue& WithRecord(RecordT&& value) { SetRecord(std::forward<RecordT>(value)); return *this;}
    template<typename RecordKeyT = Aws::String, typename RecordValueT = AttributeValue>
    AttributeValue& AddRecord(RecordKeyT&& key, RecordValueT&& value) {
      m_recordHasBeenSet = true; m_record.emplace(std::forward<RecordKeyT>(key), std::forward<RecordValueT>(value)); return *this;
    }
 
 
    inline const Aws::String& GetIpaddr() const { return m_ipaddr; }
    inline bool IpaddrHasBeenSet() const { return m_ipaddrHasBeenSet; }
    template<typename IpaddrT = Aws::String>
    void SetIpaddr(IpaddrT&& value) { m_ipaddrHasBeenSet = true; m_ipaddr = std::forward<IpaddrT>(value); }
    template<typename IpaddrT = Aws::String>
    AttributeValue& WithIpaddr(IpaddrT&& value) { SetIpaddr(std::forward<IpaddrT>(value)); return *this;}
 
 
    inline const Aws::String& GetDecimal() const { return m_decimal; }
    inline bool DecimalHasBeenSet() const { return m_decimalHasBeenSet; }
    template<typename DecimalT = Aws::String>
    void SetDecimal(DecimalT&& value) { m_decimalHasBeenSet = true; m_decimal = std::forward<DecimalT>(value); }
    template<typename DecimalT = Aws::String>
    AttributeValue& WithDecimal(DecimalT&& value) { SetDecimal(std::forward<DecimalT>(value)); return *this;}
  private:
 
    bool m_boolean{false};
    bool m_booleanHasBeenSet = false;
 
    EntityIdentifier m_entityIdentifier;
    bool m_entityIdentifierHasBeenSet = false;
 
    long long m_long{0};
    bool m_longHasBeenSet = false;
 
    Aws::String m_string;
    bool m_stringHasBeenSet = false;
 
    Aws::Vector<AttributeValue> m_set;
    bool m_setHasBeenSet = false;
 
    Aws::Map<Aws::String, AttributeValue> m_record;
    bool m_recordHasBeenSet = false;
 
    Aws::String m_ipaddr;
    bool m_ipaddrHasBeenSet = false;
 
    Aws::String m_decimal;
    bool m_decimalHasBeenSet = false;
  };
 
} // namespace Model
} // namespace VerifiedPermissions
} // namespace Aws