diff options
Diffstat (limited to 'include/lib/ArduinoJson/JsonVariant.hpp')
| -rw-r--r-- | include/lib/ArduinoJson/JsonVariant.hpp | 355 |
1 files changed, 0 insertions, 355 deletions
diff --git a/include/lib/ArduinoJson/JsonVariant.hpp b/include/lib/ArduinoJson/JsonVariant.hpp deleted file mode 100644 index 8326cbe..0000000 --- a/include/lib/ArduinoJson/JsonVariant.hpp +++ /dev/null @@ -1,355 +0,0 @@ -// ArduinoJson - arduinojson.org -// Copyright Benoit Blanchon 2014-2018 -// MIT License - -#pragma once - -#include <stddef.h> -#include <stdint.h> // for uint8_t - -#include "Data/JsonVariantContent.hpp" -#include "Data/JsonVariantDefault.hpp" -#include "Data/JsonVariantType.hpp" -#include "JsonVariantBase.hpp" -#include "RawJson.hpp" -#include "Serialization/JsonPrintable.hpp" -#include "TypeTraits/EnableIf.hpp" -#include "TypeTraits/IsChar.hpp" -#include "TypeTraits/IsFloatingPoint.hpp" -#include "TypeTraits/IsIntegral.hpp" -#include "TypeTraits/IsSame.hpp" -#include "TypeTraits/IsSignedIntegral.hpp" -#include "TypeTraits/IsUnsignedIntegral.hpp" -#include "TypeTraits/RemoveConst.hpp" -#include "TypeTraits/RemoveReference.hpp" - -namespace ArduinoJson { - -// Forward declarations. -class JsonArray; -class JsonObject; - -// A variant that can be a any value serializable to a JSON value. -// -// It can be set to: -// - a boolean -// - a char, short, int or a long (signed or unsigned) -// - a string (const char*) -// - a reference to a JsonArray or JsonObject -class JsonVariant : public Internals::JsonVariantBase<JsonVariant> { - template <typename Print> - friend class Internals::JsonSerializer; - - public: - // Creates an uninitialized JsonVariant - JsonVariant() : _type(Internals::JSON_UNDEFINED) {} - - // Create a JsonVariant containing a boolean value. - // It will be serialized as "true" or "false" in JSON. - JsonVariant(bool value) { - using namespace Internals; - _type = JSON_BOOLEAN; - _content.asInteger = static_cast<JsonUInt>(value); - } - - // Create a JsonVariant containing a floating point value. - // JsonVariant(double value); - // JsonVariant(float value); - template <typename T> - JsonVariant(T value, typename Internals::EnableIf< - Internals::IsFloatingPoint<T>::value>::type * = 0) { - using namespace Internals; - _type = JSON_FLOAT; - _content.asFloat = static_cast<JsonFloat>(value); - } - template <typename T> - DEPRECATED("Second argument is not supported anymore") - JsonVariant(T value, uint8_t, - typename Internals::EnableIf< - Internals::IsFloatingPoint<T>::value>::type * = 0) { - using namespace Internals; - _type = JSON_FLOAT; - _content.asFloat = static_cast<JsonFloat>(value); - } - - // Create a JsonVariant containing an integer value. - // JsonVariant(char) - // JsonVariant(signed short) - // JsonVariant(signed int) - // JsonVariant(signed long) - // JsonVariant(signed char) - template <typename T> - JsonVariant( - T value, - typename Internals::EnableIf<Internals::IsSignedIntegral<T>::value || - Internals::IsSame<T, char>::value>::type * = - 0) { - using namespace Internals; - if (value >= 0) { - _type = JSON_POSITIVE_INTEGER; - _content.asInteger = static_cast<JsonUInt>(value); - } else { - _type = JSON_NEGATIVE_INTEGER; - _content.asInteger = static_cast<JsonUInt>(-value); - } - } - // JsonVariant(unsigned short) - // JsonVariant(unsigned int) - // JsonVariant(unsigned long) - template <typename T> - JsonVariant(T value, - typename Internals::EnableIf< - Internals::IsUnsignedIntegral<T>::value>::type * = 0) { - using namespace Internals; - _type = JSON_POSITIVE_INTEGER; - _content.asInteger = static_cast<JsonUInt>(value); - } - - // Create a JsonVariant containing a string. - // JsonVariant(const char*); - // JsonVariant(const signed char*); - // JsonVariant(const unsigned char*); - template <typename TChar> - JsonVariant( - const TChar *value, - typename Internals::EnableIf<Internals::IsChar<TChar>::value>::type * = - 0) { - _type = Internals::JSON_STRING; - _content.asString = reinterpret_cast<const char *>(value); - } - - // Create a JsonVariant containing an unparsed string - JsonVariant(Internals::RawJsonString<const char *> value) { - _type = Internals::JSON_UNPARSED; - _content.asString = value; - } - - // Create a JsonVariant containing a reference to an array. - // CAUTION: we are lying about constness, because the array can be modified if - // the variant is converted back to a JsonArray& - JsonVariant(const JsonArray &array); - - // Create a JsonVariant containing a reference to an object. - // CAUTION: we are lying about constness, because the object can be modified - // if the variant is converted back to a JsonObject& - JsonVariant(const JsonObject &object); - - // Get the variant as the specified type. - // - // char as<char>() const; - // signed char as<signed char>() const; - // signed short as<signed short>() const; - // signed int as<signed int>() const; - // signed long as<signed long>() const; - // unsigned char as<unsigned char>() const; - // unsigned short as<unsigned short>() const; - // unsigned int as<unsigned int>() const; - // unsigned long as<unsigned long>() const; - template <typename T> - const typename Internals::EnableIf<Internals::IsIntegral<T>::value, T>::type - as() const { - return variantAsInteger<T>(); - } - // bool as<bool>() const - template <typename T> - const typename Internals::EnableIf<Internals::IsSame<T, bool>::value, T>::type - as() const { - return variantAsInteger<int>() != 0; - } - // - // double as<double>() const; - // float as<float>() const; - template <typename T> - const typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value, - T>::type - as() const { - return variantAsFloat<T>(); - } - // - // const char* as<const char*>() const; - // const char* as<char*>() const; - template <typename T> - typename Internals::EnableIf<Internals::IsSame<T, const char *>::value || - Internals::IsSame<T, char *>::value, - const char *>::type - as() const { - return variantAsString(); - } - // - // std::string as<std::string>() const; - // String as<String>() const; - template <typename T> - typename Internals::EnableIf<Internals::StringTraits<T>::has_append, T>::type - as() const { - const char *cstr = variantAsString(); - if (cstr) return T(cstr); - T s; - printTo(s); - return s; - } - // - // JsonArray& as<JsonArray> const; - // JsonArray& as<JsonArray&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveReference<T>::type, - JsonArray>::value, - JsonArray &>::type - as() const { - return variantAsArray(); - } - // - // const JsonArray& as<const JsonArray&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveReference<T>::type, - const JsonArray>::value, - const JsonArray &>::type - as() const { - return variantAsArray(); - } - // - // JsonObject& as<JsonObject> const; - // JsonObject& as<JsonObject&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveReference<T>::type, - JsonObject>::value, - JsonObject &>::type - as() const { - return variantAsObject(); - } - // - // JsonObject& as<const JsonObject> const; - // JsonObject& as<const JsonObject&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveReference<T>::type, - const JsonObject>::value, - const JsonObject &>::type - as() const { - return variantAsObject(); - } - // - // JsonVariant as<JsonVariant> const; - template <typename T> - typename Internals::EnableIf<Internals::IsSame<T, JsonVariant>::value, - T>::type - as() const { - return *this; - } - - // Tells weither the variant has the specified type. - // Returns true if the variant has type type T, false otherwise. - // - // bool is<char>() const; - // bool is<signed char>() const; - // bool is<signed short>() const; - // bool is<signed int>() const; - // bool is<signed long>() const; - // bool is<unsigned char>() const; - // bool is<unsigned short>() const; - // bool is<unsigned int>() const; - // bool is<unsigned long>() const; - template <typename T> - typename Internals::EnableIf<Internals::IsIntegral<T>::value, bool>::type is() - const { - return variantIsInteger(); - } - // - // bool is<double>() const; - // bool is<float>() const; - template <typename T> - typename Internals::EnableIf<Internals::IsFloatingPoint<T>::value, bool>::type - is() const { - return variantIsFloat(); - } - // - // bool is<bool>() const - template <typename T> - typename Internals::EnableIf<Internals::IsSame<T, bool>::value, bool>::type - is() const { - return variantIsBoolean(); - } - // - // bool is<const char*>() const; - // bool is<char*>() const; - template <typename T> - typename Internals::EnableIf<Internals::IsSame<T, const char *>::value || - Internals::IsSame<T, char *>::value, - bool>::type - is() const { - return variantIsString(); - } - // - // bool is<JsonArray> const; - // bool is<JsonArray&> const; - // bool is<const JsonArray&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveConst< - typename Internals::RemoveReference<T>::type>::type, - JsonArray>::value, - bool>::type - is() const { - return variantIsArray(); - } - // - // bool is<JsonObject> const; - // bool is<JsonObject&> const; - // bool is<const JsonObject&> const; - template <typename T> - typename Internals::EnableIf< - Internals::IsSame<typename Internals::RemoveConst< - typename Internals::RemoveReference<T>::type>::type, - JsonObject>::value, - bool>::type - is() const { - return variantIsObject(); - } - - // Returns true if the variant has a value - bool success() const { - return _type != Internals::JSON_UNDEFINED; - } - - private: - JsonArray &variantAsArray() const; - JsonObject &variantAsObject() const; - const char *variantAsString() const; - template <typename T> - T variantAsFloat() const; - template <typename T> - T variantAsInteger() const; - bool variantIsBoolean() const; - bool variantIsFloat() const; - bool variantIsInteger() const; - bool variantIsArray() const { - return _type == Internals::JSON_ARRAY; - } - bool variantIsObject() const { - return _type == Internals::JSON_OBJECT; - } - bool variantIsString() const { - return _type == Internals::JSON_STRING || - (_type == Internals::JSON_UNPARSED && _content.asString && - !strcmp("null", _content.asString)); - } - - // The current type of the variant - Internals::JsonVariantType _type; - - // The various alternatives for the value of the variant. - Internals::JsonVariantContent _content; -}; - -DEPRECATED("Decimal places are ignored, use the float value instead") -inline JsonVariant float_with_n_digits(float value, uint8_t) { - return JsonVariant(value); -} - -DEPRECATED("Decimal places are ignored, use the double value instead") -inline JsonVariant double_with_n_digits(double value, uint8_t) { - return JsonVariant(value); -} -} |