ArduinoJson-v6.18.3.h

// ArduinoJson - https://arduinojson.org
// Copyright Benoit Blanchon 2014-2021
// MIT License

#pragma once

#ifdef __cplusplus

#if __cplusplus >= 201103L
#  define ARDUINOJSON_HAS_LONG_LONG 1
#  define ARDUINOJSON_HAS_RVALUE_REFERENCES 1
#else
                                                                                                                        #  define ARDUINOJSON_HAS_LONG_LONG 0
#  define ARDUINOJSON_HAS_RVALUE_REFERENCES 0
#endif
#ifndef ARDUINOJSON_HAS_NULLPTR
#  if __cplusplus >= 201103L
#    define ARDUINOJSON_HAS_NULLPTR 1
#  else
#    define ARDUINOJSON_HAS_NULLPTR 0
#  endif
#endif
#if defined(_MSC_VER) && !ARDUINOJSON_HAS_LONG_LONG
#  define ARDUINOJSON_HAS_INT64 1
#else
#  define ARDUINOJSON_HAS_INT64 0
#endif
#ifndef ARDUINOJSON_EMBEDDED_MODE
#  if defined(ARDUINO)                /* Arduino*/                 \
 || defined(__IAR_SYSTEMS_ICC__) /* IAR Embedded Workbench */ \
 || defined(__XC)                /* MPLAB XC compiler */      \
 || defined(__ARMCC_VERSION)     /* Keil ARM Compiler */      \
 || defined(__AVR)               /* Atmel AVR8/GNU C Compiler */
#    define ARDUINOJSON_EMBEDDED_MODE 1
#  else
#    define ARDUINOJSON_EMBEDDED_MODE 0
#  endif
#endif
#if !defined(ARDUINOJSON_ENABLE_STD_STREAM) && defined(__has_include)
#  if __has_include(<istream>) && \
    __has_include(<ostream>) && \
    !defined(min) && \
    !defined(max)
#    define ARDUINOJSON_ENABLE_STD_STREAM 1
#  else
#    define ARDUINOJSON_ENABLE_STD_STREAM 0
#  endif
#endif
#if !defined(ARDUINOJSON_ENABLE_STD_STRING) && defined(__has_include)
#  if __has_include(<string>) && !defined(min) && !defined(max)
#    define ARDUINOJSON_ENABLE_STD_STRING 1
#  else
#    define ARDUINOJSON_ENABLE_STD_STRING 0
#  endif
#endif
#ifndef ARDUINOJSON_ENABLE_STRING_VIEW
#  ifdef __has_include
#    if __has_include(<string_view>) && __cplusplus >= 201703L
#      define ARDUINOJSON_ENABLE_STRING_VIEW 1
#    endif
#  endif
#endif
#ifndef ARDUINOJSON_ENABLE_STRING_VIEW
#  define ARDUINOJSON_ENABLE_STRING_VIEW 0
#endif
#if ARDUINOJSON_EMBEDDED_MODE
#  ifndef ARDUINOJSON_USE_DOUBLE
#    define ARDUINOJSON_USE_DOUBLE 0
#  endif
#  ifndef ARDUINOJSON_USE_LONG_LONG
#    define ARDUINOJSON_USE_LONG_LONG 0
#  endif
#  ifndef ARDUINOJSON_ENABLE_STD_STRING
#    define ARDUINOJSON_ENABLE_STD_STRING 0
#  endif
#  ifndef ARDUINOJSON_ENABLE_STD_STREAM
#    define ARDUINOJSON_ENABLE_STD_STREAM 0
#  endif
#  ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
#    define ARDUINOJSON_DEFAULT_NESTING_LIMIT 10
#  endif
#  ifndef ARDUINOJSON_SLOT_OFFSET_SIZE
#    if defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 2
#      define ARDUINOJSON_SLOT_OFFSET_SIZE 1
#    else
#      define ARDUINOJSON_SLOT_OFFSET_SIZE 2
#    endif
#  endif
#else  // ARDUINOJSON_EMBEDDED_MODE
                                                                                                                        #  ifndef ARDUINOJSON_USE_DOUBLE
#    define ARDUINOJSON_USE_DOUBLE 1
#  endif
#  ifndef ARDUINOJSON_USE_LONG_LONG
#    if ARDUINOJSON_HAS_LONG_LONG || ARDUINOJSON_HAS_INT64
#      define ARDUINOJSON_USE_LONG_LONG 1
#    else
#      define ARDUINOJSON_USE_LONG_LONG 0
#    endif
#  endif
#  ifndef ARDUINOJSON_ENABLE_STD_STRING
#    define ARDUINOJSON_ENABLE_STD_STRING 1
#  endif
#  ifndef ARDUINOJSON_ENABLE_STD_STREAM
#    define ARDUINOJSON_ENABLE_STD_STREAM 1
#  endif
#  ifndef ARDUINOJSON_DEFAULT_NESTING_LIMIT
#    define ARDUINOJSON_DEFAULT_NESTING_LIMIT 50
#  endif
#  ifndef ARDUINOJSON_SLOT_OFFSET_SIZE
#    define ARDUINOJSON_SLOT_OFFSET_SIZE 4
#  endif
#endif  // ARDUINOJSON_EMBEDDED_MODE
#ifdef ARDUINO

#include <Arduino.h>

#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
#  endif
#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
#  endif
#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 1
#  endif
#else  // ARDUINO
                                                                                                                        #  ifndef ARDUINOJSON_ENABLE_ARDUINO_STRING
#    define ARDUINOJSON_ENABLE_ARDUINO_STRING 0
#  endif
#  ifndef ARDUINOJSON_ENABLE_ARDUINO_STREAM
#    define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0
#  endif
#  ifndef ARDUINOJSON_ENABLE_ARDUINO_PRINT
#    define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0
#  endif
#endif  // ARDUINO
#ifndef ARDUINOJSON_ENABLE_PROGMEM
#  if defined(PROGMEM) && defined(pgm_read_byte) && defined(pgm_read_dword) && \
      defined(pgm_read_ptr) && defined(pgm_read_float)
#    define ARDUINOJSON_ENABLE_PROGMEM 1
#  else
#    define ARDUINOJSON_ENABLE_PROGMEM 0
#  endif
#endif
#ifndef ARDUINOJSON_DECODE_UNICODE
#  define ARDUINOJSON_DECODE_UNICODE 1
#endif
#ifndef ARDUINOJSON_ENABLE_COMMENTS
#  define ARDUINOJSON_ENABLE_COMMENTS 0
#endif
#ifndef ARDUINOJSON_ENABLE_NAN
#  define ARDUINOJSON_ENABLE_NAN 0
#endif
#ifndef ARDUINOJSON_ENABLE_INFINITY
#  define ARDUINOJSON_ENABLE_INFINITY 0
#endif
#ifndef ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD
#  define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7
#endif
#ifndef ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD
#  define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5
#endif
#ifndef ARDUINOJSON_LITTLE_ENDIAN
#  if defined(_MSC_VER) || \
      (defined(__BYTE_ORDER__) && \
       __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || \
      defined(__LITTLE_ENDIAN__) || defined(__i386) || defined(__x86_64)
#    define ARDUINOJSON_LITTLE_ENDIAN 1
#  else
#    define ARDUINOJSON_LITTLE_ENDIAN 0
#  endif
#endif
#ifndef ARDUINOJSON_ENABLE_ALIGNMENT
#  if defined(__AVR)
#    define ARDUINOJSON_ENABLE_ALIGNMENT 0
#  else
#    define ARDUINOJSON_ENABLE_ALIGNMENT 1
#  endif
#endif
#ifndef ARDUINOJSON_TAB
#  define ARDUINOJSON_TAB "  "
#endif
#ifndef ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
#  define ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 1
#endif
#ifndef ARDUINOJSON_STRING_BUFFER_SIZE
#  define ARDUINOJSON_STRING_BUFFER_SIZE 32
#endif
#ifndef ARDUINOJSON_DEBUG
#  ifdef __PLATFORMIO_BUILD_DEBUG__
#    define ARDUINOJSON_DEBUG 1
#  else
#    define ARDUINOJSON_DEBUG 0
#  endif
#endif
#if ARDUINOJSON_HAS_NULLPTR && defined(nullptr)
#  error nullptr is defined as a macro. Remove the faulty #define or #undef nullptr
#endif
#if !ARDUINOJSON_DEBUG
#  ifdef __clang__
#    pragma clang system_header
#  elif defined __GNUC__
#    pragma GCC system_header
#  endif
#endif
#define ARDUINOJSON_EXPAND6(a, b, c, d, e, f) a, b, c, d, e, f
#define ARDUINOJSON_EXPAND9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i
#define ARDUINOJSON_EXPAND18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, \
                             q, r)                                           \
  a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r
#define ARDUINOJSON_CONCAT_(A, B) A##B
#define ARDUINOJSON_CONCAT2(A, B) ARDUINOJSON_CONCAT_(A, B)
#define ARDUINOJSON_CONCAT4(A, B, C, D) \
  ARDUINOJSON_CONCAT2(ARDUINOJSON_CONCAT2(A, B), ARDUINOJSON_CONCAT2(C, D))
#define ARDUINOJSON_HEX_DIGIT_0000() 0
#define ARDUINOJSON_HEX_DIGIT_0001() 1
#define ARDUINOJSON_HEX_DIGIT_0010() 2
#define ARDUINOJSON_HEX_DIGIT_0011() 3
#define ARDUINOJSON_HEX_DIGIT_0100() 4
#define ARDUINOJSON_HEX_DIGIT_0101() 5
#define ARDUINOJSON_HEX_DIGIT_0110() 6
#define ARDUINOJSON_HEX_DIGIT_0111() 7
#define ARDUINOJSON_HEX_DIGIT_1000() 8
#define ARDUINOJSON_HEX_DIGIT_1001() 9
#define ARDUINOJSON_HEX_DIGIT_1010() A
#define ARDUINOJSON_HEX_DIGIT_1011() B
#define ARDUINOJSON_HEX_DIGIT_1100() C
#define ARDUINOJSON_HEX_DIGIT_1101() D
#define ARDUINOJSON_HEX_DIGIT_1110() E
#define ARDUINOJSON_HEX_DIGIT_1111() F
#define ARDUINOJSON_HEX_DIGIT_(A, B, C, D) ARDUINOJSON_HEX_DIGIT_##A##B##C##D()
#define ARDUINOJSON_HEX_DIGIT(A, B, C, D) ARDUINOJSON_HEX_DIGIT_(A, B, C, D)
#define ARDUINOJSON_VERSION "6.18.3"
#define ARDUINOJSON_VERSION_MAJOR 6
#define ARDUINOJSON_VERSION_MINOR 18
#define ARDUINOJSON_VERSION_REVISION 3
#ifndef ARDUINOJSON_NAMESPACE
#  define ARDUINOJSON_NAMESPACE                                               \
    ARDUINOJSON_CONCAT4(                                                      \
        ARDUINOJSON_CONCAT4(ArduinoJson, ARDUINOJSON_VERSION_MAJOR,           \
                            ARDUINOJSON_VERSION_MINOR,                        \
                            ARDUINOJSON_VERSION_REVISION),                    \
        _,                                                                    \
        ARDUINOJSON_HEX_DIGIT(                                                \
            ARDUINOJSON_ENABLE_PROGMEM, ARDUINOJSON_USE_LONG_LONG,            \
            ARDUINOJSON_USE_DOUBLE, ARDUINOJSON_ENABLE_STRING_DEDUPLICATION), \
        ARDUINOJSON_HEX_DIGIT(                                                \
            ARDUINOJSON_ENABLE_NAN, ARDUINOJSON_ENABLE_INFINITY,              \
            ARDUINOJSON_ENABLE_COMMENTS, ARDUINOJSON_DECODE_UNICODE))
#endif
#if ARDUINOJSON_DEBUG
                                                                                                                        #include <assert.h>
#  define ARDUINOJSON_ASSERT(X) assert(X)
#else
#  define ARDUINOJSON_ASSERT(X) ((void)0)
#endif

#include <stddef.h>

namespace ARDUINOJSON_NAMESPACE {
    class MemoryPool;

    class VariantData;

    class VariantSlot;

    class CollectionData {
        VariantSlot *_head;
        VariantSlot *_tail;
    public:
        VariantData *addElement(MemoryPool *pool);

        VariantData *getElement(size_t index) const;

        VariantData *getOrAddElement(size_t index, MemoryPool *pool);

        void removeElement(size_t index);

        bool equalsArray(const CollectionData &other) const;

        template<typename TAdaptedString>
        VariantData *addMember(TAdaptedString key, MemoryPool *pool);

        template<typename TAdaptedString>
        VariantData *getMember(TAdaptedString key) const;

        template<typename TAdaptedString>
        VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool);

        template<typename TAdaptedString>
        void removeMember(TAdaptedString key) {
            removeSlot(getSlot(key));
        }

        template<typename TAdaptedString>
        bool containsKey(const TAdaptedString &key) const;

        bool equalsObject(const CollectionData &other) const;

        void clear();

        size_t memoryUsage() const;

        size_t nesting() const;

        size_t size() const;

        VariantSlot *addSlot(MemoryPool *);

        void removeSlot(VariantSlot *slot);

        bool copyFrom(const CollectionData &src, MemoryPool *pool);

        VariantSlot *head() const {
            return _head;
        }

        void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance);

    private:
        VariantSlot *getSlot(size_t index) const;

        template<typename TAdaptedString>
        VariantSlot *getSlot(TAdaptedString key) const;

        VariantSlot *getPreviousSlot(VariantSlot *) const;
    };

    inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) {
        return arr ? arr->addElement(pool) : 0;
    }

    template<typename TVisitor>
    inline typename TVisitor::result_type arrayAccept(const CollectionData *arr,
                                                      TVisitor &visitor) {
        if (arr)
            return visitor.visitArray(*arr);
        else
            return visitor.visitNull();
    }

    inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) {
        if (lhs == rhs)
            return true;
        if (!lhs || !rhs)
            return false;
        return lhs->equalsArray(*rhs);
    }

#if ARDUINOJSON_ENABLE_ALIGNMENT
                                                                                                                            inline bool isAligned(size_t value) {
  const size_t mask = sizeof(void *) - 1;
  size_t addr = value;
  return (addr & mask) == 0;
}
inline size_t addPadding(size_t bytes) {
  const size_t mask = sizeof(void *) - 1;
  return (bytes + mask) & ~mask;
}
template <size_t bytes>
struct AddPadding {
  static const size_t mask = sizeof(void *) - 1;
  static const size_t value = (bytes + mask) & ~mask;
};
#else

    inline bool isAligned(size_t) {
        return true;
    }

    inline size_t addPadding(size_t bytes) {
        return bytes;
    }

    template<size_t bytes>
    struct AddPadding {
        static const size_t value = bytes;
    };
#endif

    template<typename T>
    inline bool isAligned(T *ptr) {
        return isAligned(reinterpret_cast<size_t>(ptr));
    }

    template<typename T>
    inline T *addPadding(T *p) {
        size_t address = addPadding(reinterpret_cast<size_t>(p));
        return reinterpret_cast<T *>(address);
    }

    template<size_t X, size_t Y, bool MaxIsX = (X > Y)>
    struct Max {
    };
    template<size_t X, size_t Y>
    struct Max<X, Y, true> {
        static const size_t value = X;
    };
    template<size_t X, size_t Y>
    struct Max<X, Y, false> {
        static const size_t value = Y;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#include <string.h>
#include <stdint.h>

namespace ARDUINOJSON_NAMESPACE {
    inline int safe_strcmp(const char *a, const char *b) {
        if (a == b)
            return 0;
        if (!a)
            return -1;
        if (!b)
            return 1;
        return strcmp(a, b);
    }

    inline int safe_strncmp(const char *a, const char *b, size_t n) {
        if (a == b)
            return 0;
        if (!a)
            return -1;
        if (!b)
            return 1;
        return strncmp(a, b, n);
    }

    namespace storage_policies {
        struct store_by_address {
        };
        struct store_by_copy {
        };
        struct decide_at_runtime {
        };
    }  // namespace storage_policies
    template<bool Condition, class TrueType, class FalseType>
    struct conditional {
        typedef TrueType type;
    };
    template<class TrueType, class FalseType>
    struct conditional<false, TrueType, FalseType> {
        typedef FalseType type;
    };
    template<bool Condition, typename T = void>
    struct enable_if {
    };
    template<typename T>
    struct enable_if<true, T> {
        typedef T type;
    };
    template<typename T, T v>
    struct integral_constant {
        static const T value = v;
    };
    typedef integral_constant<bool, true> true_type;
    typedef integral_constant<bool, false> false_type;
    template<typename T>
    struct is_array : false_type {
    };
    template<typename T>
    struct is_array<T[]> : true_type {
    };
    template<typename T, size_t N>
    struct is_array<T[N]> : true_type {
    };

    template<typename TBase, typename TDerived>
    class is_base_of {
    protected:  // <- to avoid GCC's "all member functions in class are private"
        typedef char Yes[1];
        typedef char No[2];

        static Yes &probe(const TBase *);

        static No &probe(...);

    public:
        static const bool value =
                sizeof(probe(reinterpret_cast<TDerived *>(0))) == sizeof(Yes);
    };

    template<typename T>
    T declval();

    template<typename T>
    struct is_class {
    protected:  // <- to avoid GCC's "all member functions in class are private"
        typedef char Yes[1];
        typedef char No[2];

        template<typename U>
        static Yes &probe(void (U::*)(void));

        template<typename>
        static No &probe(...);

    public:
        static const bool value = sizeof(probe<T>(0)) == sizeof(Yes);
    };

    template<typename T>
    struct is_const : false_type {
    };
    template<typename T>
    struct is_const<const T> : true_type {
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
                                                                                                                        #  pragma warning(push)
#  pragma warning(disable : 4244)
#endif
#ifdef __ICCARM__
#pragma diag_suppress=Pa093
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename From, typename To>
    struct is_convertible {
    protected:  // <- to avoid GCC's "all member functions in class are private"
        typedef char Yes[1];
        typedef char No[2];

        static Yes &probe(To);

        static No &probe(...);

    public:
        static const bool value = sizeof(probe(declval<From>())) == sizeof(Yes);
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
#ifdef __ICCARM__
#pragma diag_default=Pa093
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename T, typename U>
    struct is_same : false_type {
    };
    template<typename T>
    struct is_same<T, T> : true_type {
    };
    template<typename T>
    struct remove_cv {
        typedef T type;
    };
    template<typename T>
    struct remove_cv<const T> {
        typedef T type;
    };
    template<typename T>
    struct remove_cv<volatile T> {
        typedef T type;
    };
    template<typename T>
    struct remove_cv<const volatile T> {
        typedef T type;
    };
    template<class T>
    struct is_floating_point
            : integral_constant<
                    bool,  //
                    is_same<float, typename remove_cv<T>::type>::value ||
                    is_same<double, typename remove_cv<T>::type>::value> {
    };
    template<typename T>
    struct is_integral : integral_constant<bool,
            is_same<typename remove_cv<T>::type, signed char>::value ||
            is_same<typename remove_cv<T>::type, unsigned char>::value ||
            is_same<typename remove_cv<T>::type, signed short>::value ||
            is_same<typename remove_cv<T>::type, unsigned short>::value ||
            is_same<typename remove_cv<T>::type, signed int>::value ||
            is_same<typename remove_cv<T>::type, unsigned int>::value ||
            is_same<typename remove_cv<T>::type, signed long>::value ||
            is_same<typename remove_cv<T>::type, unsigned long>::value ||
            #if ARDUINOJSON_HAS_LONG_LONG
            is_same<typename remove_cv<T>::type, signed long long>::value ||
            is_same<typename remove_cv<T>::type, unsigned long long>::value ||
            #endif
            #if ARDUINOJSON_HAS_INT64
            is_same<typename remove_cv<T>::type, signed __int64>::value ||
    is_same<typename remove_cv<T>::type, unsigned __int64>::value ||
            #endif
            is_same<typename remove_cv<T>::type, char>::value ||
            is_same<typename remove_cv<T>::type, bool>::value> {
    };
    template<typename T>
    struct is_enum {
        static const bool value = is_convertible<T, int>::value &&
                                  !is_class<T>::value && !is_integral<T>::value &&
                                  !is_floating_point<T>::value;
    };
    template<typename T>
    struct is_pointer : false_type {
    };
    template<typename T>
    struct is_pointer<T *> : true_type {
    };
    template<typename T>
    struct is_signed : integral_constant<bool,
            is_same<typename remove_cv<T>::type, char>::value ||
            is_same<typename remove_cv<T>::type, signed char>::value ||
            is_same<typename remove_cv<T>::type, signed short>::value ||
            is_same<typename remove_cv<T>::type, signed int>::value ||
            is_same<typename remove_cv<T>::type, signed long>::value ||
            #if ARDUINOJSON_HAS_LONG_LONG
            is_same<typename remove_cv<T>::type, signed long long>::value ||
            #endif
            #if ARDUINOJSON_HAS_INT64
            is_same<typename remove_cv<T>::type, signed __int64>::value ||
            #endif
            is_same<typename remove_cv<T>::type, float>::value ||
            is_same<typename remove_cv<T>::type, double>::value> {
    };
    template<typename T>
    struct is_unsigned : integral_constant<bool,
            is_same<typename remove_cv<T>::type, unsigned char>::value ||
            is_same<typename remove_cv<T>::type, unsigned short>::value ||
            is_same<typename remove_cv<T>::type, unsigned int>::value ||
            is_same<typename remove_cv<T>::type, unsigned long>::value ||
            #if ARDUINOJSON_HAS_INT64
            is_same<typename remove_cv<T>::type, unsigned __int64>::value ||
            #endif
            #if ARDUINOJSON_HAS_LONG_LONG
            is_same<typename remove_cv<T>::type, unsigned long long>::value ||
            #endif
            is_same<typename remove_cv<T>::type, bool>::value> {
    };
    template<typename T>
    struct type_identity {
        typedef T type;
    };
    template<typename T>
    struct make_unsigned;
    template<>
    struct make_unsigned<char> : type_identity<unsigned char> {
    };
    template<>
    struct make_unsigned<signed char> : type_identity<unsigned char> {
    };
    template<>
    struct make_unsigned<unsigned char> : type_identity<unsigned char> {
    };
    template<>
    struct make_unsigned<signed short> : type_identity<unsigned short> {
    };
    template<>
    struct make_unsigned<unsigned short> : type_identity<unsigned short> {
    };
    template<>
    struct make_unsigned<signed int> : type_identity<unsigned int> {
    };
    template<>
    struct make_unsigned<unsigned int> : type_identity<unsigned int> {
    };
    template<>
    struct make_unsigned<signed long> : type_identity<unsigned long> {
    };
    template<>
    struct make_unsigned<unsigned long> : type_identity<unsigned long> {
    };
#if ARDUINOJSON_HAS_LONG_LONG
    template<>
    struct make_unsigned<signed long long> : type_identity<unsigned long long> {
    };
    template<>
    struct make_unsigned<unsigned long long> : type_identity<unsigned long long> {
    };
#endif
#if ARDUINOJSON_HAS_INT64
                                                                                                                            template <>
struct make_unsigned<signed __int64> : type_identity<unsigned __int64> {};
template <>
struct make_unsigned<unsigned __int64> : type_identity<unsigned __int64> {};
#endif
    template<class = void>
    struct make_void {
        typedef void type;
    };
    template<typename T>
    struct remove_const {
        typedef T type;
    };
    template<typename T>
    struct remove_const<const T> {
        typedef T type;
    };
    template<typename T>
    struct remove_reference {
        typedef T type;
    };
    template<typename T>
    struct remove_reference<T &> {
        typedef T type;
    };

    template<typename T, bool bounded = false, typename Enable = void>
    class StringAdapter;

    template<typename T>
    inline StringAdapter<T, false> adaptString(const T &str) {
        return StringAdapter<T, false>(str);
    }

    template<typename T>
    inline StringAdapter<T, true> adaptString(const T &str, size_t sz) {
        return StringAdapter<T, true>(str, sz);
    }

    template<typename T, typename Enable = void>
    struct IsString : false_type {
    };
    template<typename T>
    struct IsString<
            T, typename make_void<typename StringAdapter<T>::storage_policy>::type>
            : true_type {
    };

    template<>
    class StringAdapter<const char *> {
    public:
        StringAdapter(const char *str = 0) : _str(str) {}

        int compare(const char *other) const {
            return safe_strcmp(_str, other);
        }

        bool isNull() const {
            return !_str;
        }

        size_t size() const {
            if (!_str)
                return 0;
            return strlen(_str);
        }

        const char *data() const {
            return _str;
        }

        typedef storage_policies::store_by_address storage_policy;
    protected:
        const char *_str;
    };

    template<int N>
    class StringAdapter<const char[N]> : public StringAdapter<const char *> {
    public:
        StringAdapter<const char[N]>(const char *s) : StringAdapter<const char *>(s) {}
    };

    template<typename TChar>
    class StringAdapter<TChar *, false,
            typename enable_if<sizeof(TChar) == 1 &&
                               !is_same<TChar, void>::value>::type>
            : public StringAdapter<const char *> {
    public:
        StringAdapter(const TChar *str)
                : StringAdapter<const char *>(reinterpret_cast<const char *>(str)) {}

        void copyTo(char *p, size_t n) const {
            memcpy(p, _str, n);
        }

        typedef ARDUINOJSON_NAMESPACE::storage_policies::store_by_copy storage_policy;
    };

    class String {
    public:
        String() : _data(0), _isStatic(true) {}

        String(const char *data, bool isStaticData = true)
                : _data(data), _isStatic(isStaticData) {}

        const char *c_str() const {
            return _data;
        }

        bool isNull() const {
            return !_data;
        }

        bool isStatic() const {
            return _isStatic;
        }

        friend bool operator==(String lhs, String rhs) {
            if (lhs._data == rhs._data)
                return true;
            if (!lhs._data)
                return false;
            if (!rhs._data)
                return false;
            return strcmp(lhs._data, rhs._data) == 0;
        }

        friend bool operator!=(String lhs, String rhs) {
            if (lhs._data == rhs._data)
                return false;
            if (!lhs._data)
                return true;
            if (!rhs._data)
                return true;
            return strcmp(lhs._data, rhs._data) != 0;
        }

    private:
        const char *_data;
        bool _isStatic;
    };

    template<>
    class StringAdapter<String> : public StringAdapter<char *> {
    public:
        StringAdapter(const String &str)
                : StringAdapter<char *>(str.c_str()), _isStatic(str.isStatic()) {}

        bool isStatic() const {
            return _isStatic;
        }

        typedef storage_policies::decide_at_runtime storage_policy;
    private:
        bool _isStatic;
    };

    template<typename TChar>
    class StringAdapter<TChar *, true> {
    public:
        StringAdapter(const char *str, size_t n) : _str(str), _size(n) {}

        int compare(const char *other) const {
            return safe_strncmp(_str, other, _size);
        }

        bool isNull() const {
            return !_str;
        }

        void copyTo(char *p, size_t n) const {
            memcpy(p, _str, n);
        }

        size_t size() const {
            return _size;
        }

        typedef storage_policies::store_by_copy storage_policy;
    private:
        const char *_str;
        size_t _size;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_STD_STRING
                                                                                                                        #include <string>
namespace ARDUINOJSON_NAMESPACE {
template <typename TCharTraits, typename TAllocator>
class StringAdapter<std::basic_string<char, TCharTraits, TAllocator> > {
 public:
  typedef std::basic_string<char, TCharTraits, TAllocator> string_type;
  StringAdapter(const string_type& str) : _str(&str) {}
  void copyTo(char* p, size_t n) const {
    memcpy(p, _str->c_str(), n);
  }
  bool isNull() const {
    return false;
  }
  int compare(const char* other) const {
    if (!other)
      return 1;
    return _str->compare(other);
  }
  size_t size() const {
    return _str->size();
  }
  typedef storage_policies::store_by_copy storage_policy;
 private:
  const string_type* _str;
};
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_STRING_VIEW
                                                                                                                        #include <string_view>
namespace ARDUINOJSON_NAMESPACE {
template <>
class StringAdapter<std::string_view> {
 public:
  StringAdapter(std::string_view str) : _str(str) {}
  void copyTo(char* p, size_t n) const {
    memcpy(p, _str.data(), n);
  }
  bool isNull() const {
    return false;
  }
  int compare(const char* other) const {
    if (!other)
      return 1;
    return _str.compare(other);
  }
  size_t size() const {
    return _str.size();
  }
  typedef storage_policies::store_by_copy storage_policy;
 private:
  std::string_view _str;
};
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
namespace ARDUINOJSON_NAMESPACE {
    template<>
    class StringAdapter<::String> {
    public:
        StringAdapter(const ::String &str) : _str(&str) {}

        void copyTo(char *p, size_t n) const {
            memcpy(p, _str->c_str(), n);
        }

        bool isNull() const {
            return !_str->c_str();
        }

        int compare(const char *other) const {
            const char *me = _str->c_str();
            return safe_strcmp(me, other);
        }

        size_t size() const {
            return _str->length();
        }

        typedef storage_policies::store_by_copy storage_policy;
    private:
        const ::String *_str;
    };

    template<>
    class StringAdapter<::StringSumHelper> : public StringAdapter<::String> {
    public:
        StringAdapter<::StringSumHelper>(const ::String &s)
                : StringAdapter<::String>(s) {}
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_PROGMEM
namespace ARDUINOJSON_NAMESPACE {
    struct pgm_p {
        pgm_p(const char *p) : address(p) {}

        const char *address;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifndef strlen_P

inline size_t strlen_P(ARDUINOJSON_NAMESPACE::pgm_p s) {
    const char *p = s.address;
    ARDUINOJSON_ASSERT(p != NULL);
    while (pgm_read_byte(p)) p++;
    return size_t(p - s.address);
}

#endif
#ifndef strncmp_P

inline int strncmp_P(const char *a, ARDUINOJSON_NAMESPACE::pgm_p b, size_t n) {
    const char *s1 = a;
    const char *s2 = b.address;
    ARDUINOJSON_ASSERT(s1 != NULL);
    ARDUINOJSON_ASSERT(s2 != NULL);
    while (n-- > 0) {
        char c1 = *s1++;
        char c2 = static_cast<char>(pgm_read_byte(s2++));
        if (c1 < c2)
            return -1;
        if (c1 > c2)
            return 1;
        if (c1 == 0 /* and c2 as well */)
            return 0;
    }
    return 0;
}

#endif
#ifndef strcmp_P

inline int strcmp_P(const char *a, ARDUINOJSON_NAMESPACE::pgm_p b) {
    const char *s1 = a;
    const char *s2 = b.address;
    ARDUINOJSON_ASSERT(s1 != NULL);
    ARDUINOJSON_ASSERT(s2 != NULL);
    for (;;) {
        char c1 = *s1++;
        char c2 = static_cast<char>(pgm_read_byte(s2++));
        if (c1 < c2)
            return -1;
        if (c1 > c2)
            return 1;
        if (c1 == 0 /* and c2 as well */)
            return 0;
    }
}

#endif
#ifndef memcpy_P

inline void *memcpy_P(void *dst, ARDUINOJSON_NAMESPACE::pgm_p src, size_t n) {
    uint8_t *d = reinterpret_cast<uint8_t *>(dst);
    const char *s = src.address;
    ARDUINOJSON_ASSERT(d != NULL);
    ARDUINOJSON_ASSERT(s != NULL);
    while (n-- > 0) {
        *d++ = pgm_read_byte(s++);
    }
    return dst;
}

#endif
namespace ARDUINOJSON_NAMESPACE {
    template<>
    class StringAdapter<const __FlashStringHelper *> {
    public:
        StringAdapter(const __FlashStringHelper *str) : _str(str) {}

        int compare(const char *other) const {
            if (!other && !_str)
                return 0;
            if (!_str)
                return -1;
            if (!other)
                return 1;
            return -strcmp_P(other, reinterpret_cast<const char *>(_str));
        }

        bool isNull() const {
            return !_str;
        }

        void copyTo(char *p, size_t n) const {
            memcpy_P(p, reinterpret_cast<const char *>(_str), n);
        }

        size_t size() const {
            if (!_str)
                return 0;
            return strlen_P(reinterpret_cast<const char *>(_str));
        }

        typedef storage_policies::store_by_copy storage_policy;
    private:
        const __FlashStringHelper *_str;
    };

    template<>
    class StringAdapter<const __FlashStringHelper *, true> {
    public:
        StringAdapter(const __FlashStringHelper *str, size_t sz)
                : _str(str), _size(sz) {}

        int compare(const char *other) const {
            if (!other && !_str)
                return 0;
            if (!_str)
                return -1;
            if (!other)
                return 1;
            return -strncmp_P(other, reinterpret_cast<const char *>(_str), _size);
        }

        bool isNull() const {
            return !_str;
        }

        void copyTo(char *p, size_t n) const {
            memcpy_P(p, reinterpret_cast<const char *>(_str), n);
        }

        size_t size() const {
            return _size;
        }

        typedef storage_policies::store_by_copy storage_policy;
    private:
        const __FlashStringHelper *_str;
        size_t _size;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<int Bits>
    struct int_t;
    template<>
    struct int_t<8> {
        typedef int8_t type;
    };
    template<>
    struct int_t<16> {
        typedef int16_t type;
    };
    template<>
    struct int_t<32> {
        typedef int32_t type;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
                                                                                                                        #  pragma warning(push)
#  pragma warning(disable : 4310)
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename T, typename Enable = void>
    struct numeric_limits;

    template<typename T>
    struct numeric_limits<T, typename enable_if<is_unsigned<T>::value>::type> {
        static T lowest() {
            return 0;
        }

        static T highest() {
            return T(-1);
        }
    };

    template<typename T>
    struct numeric_limits<
            T, typename enable_if<is_integral<T>::value && is_signed<T>::value>::type> {
        static T lowest() {
            return T(T(1) << (sizeof(T) * 8 - 1));
        }

        static T highest() {
            return T(~lowest());
        }
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
namespace ARDUINOJSON_NAMESPACE {
#if ARDUINOJSON_USE_DOUBLE
    typedef double Float;
#else
    typedef float Float;
#endif
#if ARDUINOJSON_USE_LONG_LONG
                                                                                                                            typedef int64_t Integer;
typedef uint64_t UInt;
#else
    typedef long Integer;
    typedef unsigned long UInt;
#endif
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG
#  define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)                  \
    static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::Integer),     \
                  "To use 64-bit integers with ArduinoJson, you must set " \
                  "ARDUINOJSON_USE_LONG_LONG to 1. See "                   \
                  "https://arduinojson.org/v6/api/config/use_long_long/");
#else
#  define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T)
#endif
namespace ARDUINOJSON_NAMESPACE {
    enum {
        VALUE_MASK = 0x7F,
        OWNED_VALUE_BIT = 0x01,
        VALUE_IS_NULL = 0,
        VALUE_IS_LINKED_RAW = 0x02,
        VALUE_IS_OWNED_RAW = 0x03,
        VALUE_IS_LINKED_STRING = 0x04,
        VALUE_IS_OWNED_STRING = 0x05,
        VALUE_IS_BOOLEAN = 0x06,
        NUMBER_BIT = 0x08,
        VALUE_IS_UNSIGNED_INTEGER = 0x08,
        VALUE_IS_SIGNED_INTEGER = 0x0A,
        VALUE_IS_FLOAT = 0x0C,
        COLLECTION_MASK = 0x60,
        VALUE_IS_OBJECT = 0x20,
        VALUE_IS_ARRAY = 0x40,
        OWNED_KEY_BIT = 0x80
    };
    struct RawData {
        const char *data;
        size_t size;
    };
    union VariantContent {
        Float asFloat;
        bool asBoolean;
        UInt asUnsignedInteger;
        Integer asSignedInteger;
        CollectionData asCollection;
        const char *asString;
        struct {
            const char *data;
            size_t size;
        } asRaw;
    };
    typedef int_t<ARDUINOJSON_SLOT_OFFSET_SIZE * 8>::type VariantSlotDiff;

    class VariantSlot {
        VariantContent _content;
        uint8_t _flags;
        VariantSlotDiff _next;
        const char *_key;
    public:
        VariantData *data() {
            return reinterpret_cast<VariantData *>(&_content);
        }

        const VariantData *data() const {
            return reinterpret_cast<const VariantData *>(&_content);
        }

        VariantSlot *next() {
            return _next ? this + _next : 0;
        }

        const VariantSlot *next() const {
            return const_cast<VariantSlot *>(this)->next();
        }

        VariantSlot *next(size_t distance) {
            VariantSlot *slot = this;
            while (distance--) {
                if (!slot->_next)
                    return 0;
                slot += slot->_next;
            }
            return slot;
        }

        const VariantSlot *next(size_t distance) const {
            return const_cast<VariantSlot *>(this)->next(distance);
        }

        void setNext(VariantSlot *slot) {
            ARDUINOJSON_ASSERT(!slot || slot - this >=
                                        numeric_limits<VariantSlotDiff>::lowest());
            ARDUINOJSON_ASSERT(!slot || slot - this <=
                                        numeric_limits<VariantSlotDiff>::highest());
            _next = VariantSlotDiff(slot ? slot - this : 0);
        }

        void setNextNotNull(VariantSlot *slot) {
            ARDUINOJSON_ASSERT(slot != 0);
            ARDUINOJSON_ASSERT(slot - this >=
                               numeric_limits<VariantSlotDiff>::lowest());
            ARDUINOJSON_ASSERT(slot - this <=
                               numeric_limits<VariantSlotDiff>::highest());
            _next = VariantSlotDiff(slot - this);
        }

        void setKey(const char *k, storage_policies::store_by_copy) {
            ARDUINOJSON_ASSERT(k != NULL);
            _flags |= OWNED_KEY_BIT;
            _key = k;
        }

        void setKey(const char *k, storage_policies::store_by_address) {
            ARDUINOJSON_ASSERT(k != NULL);
            _flags &= VALUE_MASK;
            _key = k;
        }

        const char *key() const {
            return _key;
        }

        bool ownsKey() const {
            return (_flags & OWNED_KEY_BIT) != 0;
        }

        void clear() {
            _next = 0;
            _flags = 0;
            _key = 0;
        }

        void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance) {
            if (_flags & OWNED_KEY_BIT)
                _key += stringDistance;
            if (_flags & OWNED_VALUE_BIT)
                _content.asString += stringDistance;
            if (_flags & COLLECTION_MASK)
                _content.asCollection.movePointers(stringDistance, variantDistance);
        }
    };
}  // namespace ARDUINOJSON_NAMESPACE
#define JSON_STRING_SIZE(SIZE) (SIZE + 1)
namespace ARDUINOJSON_NAMESPACE {
    class MemoryPool {
    public:
        MemoryPool(char *buf, size_t capa)
                : _begin(buf),
                  _left(buf),
                  _right(buf ? buf + capa : 0),
                  _end(buf ? buf + capa : 0),
                  _overflowed(false) {
            ARDUINOJSON_ASSERT(isAligned(_begin));
            ARDUINOJSON_ASSERT(isAligned(_right));
            ARDUINOJSON_ASSERT(isAligned(_end));
        }

        void *buffer() {
            return _begin;  // NOLINT(clang-analyzer-unix.Malloc)
        }

        size_t capacity() const {
            return size_t(_end - _begin);
        }

        size_t size() const {
            return size_t(_left - _begin + _end - _right);
        }

        bool overflowed() const {
            return _overflowed;
        }

        VariantSlot *allocVariant() {
            return allocRight<VariantSlot>();
        }

        template<typename TAdaptedString>
        const char *saveString(const TAdaptedString &str) {
            if (str.isNull())
                return 0;
#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
            const char *existingCopy = findString(str);
            if (existingCopy)
                return existingCopy;
#endif
            size_t n = str.size();
            char *newCopy = allocString(n + 1);
            if (newCopy) {
                str.copyTo(newCopy, n);
                newCopy[n] = 0;  // force null-terminator
            }
            return newCopy;
        }

        void getFreeZone(char **zoneStart, size_t *zoneSize) const {
            *zoneStart = _left;
            *zoneSize = size_t(_right - _left);
        }

        const char *saveStringFromFreeZone(size_t len) {
#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION
            const char *dup = findString(adaptString(_left));
            if (dup)
                return dup;
#endif
            const char *str = _left;
            _left += len;
            checkInvariants();
            return str;
        }

        void markAsOverflowed() {
            _overflowed = true;
        }

        void clear() {
            _left = _begin;
            _right = _end;
            _overflowed = false;
        }

        bool canAlloc(size_t bytes) const {
            return _left + bytes <= _right;
        }

        bool owns(void *p) const {
            return _begin <= p && p < _end;
        }

        void *operator new(size_t, void *p) {
            return p;
        }

        ptrdiff_t squash() {
            char *new_right = addPadding(_left);
            if (new_right >= _right)
                return 0;
            size_t right_size = static_cast<size_t>(_end - _right);
            memmove(new_right, _right, right_size);
            ptrdiff_t bytes_reclaimed = _right - new_right;
            _right = new_right;
            _end = new_right + right_size;
            return bytes_reclaimed;
        }

        void movePointers(ptrdiff_t offset) {
            _begin += offset;
            _left += offset;
            _right += offset;
            _end += offset;
        }

    private:
        void checkInvariants() {
            ARDUINOJSON_ASSERT(_begin <= _left);
            ARDUINOJSON_ASSERT(_left <= _right);
            ARDUINOJSON_ASSERT(_right <= _end);
            ARDUINOJSON_ASSERT(isAligned(_right));
        }

#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION

        template<typename TAdaptedString>
        const char *findString(const TAdaptedString &str) {
            for (char *next = _begin; next < _left; ++next) {
                if (str.compare(next) == 0)
                    return next;
                while (*next) ++next;
            }
            return 0;
        }

#endif

        char *allocString(size_t n) {
            if (!canAlloc(n)) {
                _overflowed = true;
                return 0;
            }
            char *s = _left;
            _left += n;
            checkInvariants();
            return s;
        }

        template<typename T>
        T *allocRight() {
            return reinterpret_cast<T *>(allocRight(sizeof(T)));
        }

        void *allocRight(size_t bytes) {
            if (!canAlloc(bytes)) {
                _overflowed = true;
                return 0;
            }
            _right -= bytes;
            return _right;
        }

        char *_begin, *_left, *_right, *_end;
        bool _overflowed;
    };

    template<typename T>
    class SerializedValue {
    public:
        explicit SerializedValue(T str) : _str(str) {}

        operator T() const {
            return _str;
        }

        const char *data() const {
            return _str.c_str();
        }

        size_t size() const {
            return _str.length();
        }

    private:
        T _str;
    };

    template<typename TChar>
    class SerializedValue<TChar *> {
    public:
        explicit SerializedValue(TChar *p, size_t n) : _data(p), _size(n) {}

        operator TChar *() const {
            return _data;
        }

        TChar *data() const {
            return _data;
        }

        size_t size() const {
            return _size;
        }

    private:
        TChar *_data;
        size_t _size;
    };

    template<typename T>
    inline SerializedValue<T> serialized(T str) {
        return SerializedValue<T>(str);
    }

    template<typename TChar>
    inline SerializedValue<TChar *> serialized(TChar *p) {
        return SerializedValue<TChar *>(p, adaptString(p).size());
    }

    template<typename TChar>
    inline SerializedValue<TChar *> serialized(TChar *p, size_t n) {
        return SerializedValue<TChar *>(p, n);
    }
}  // namespace ARDUINOJSON_NAMESPACE
#if defined(__clang__)
                                                                                                                        #  pragma clang diagnostic push
#  pragma clang diagnostic ignored "-Wconversion"
#elif defined(__GNUC__)
#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#    pragma GCC diagnostic push
#  endif
#  pragma GCC diagnostic ignored "-Wconversion"
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value &&
                       is_integral<TOut>::value && sizeof(TOut) <= sizeof(TIn),
            bool>::type
    canConvertNumber(TIn value) {
        return value <= TIn(numeric_limits<TOut>::highest());
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_unsigned<TIn>::value &&
                       is_integral<TOut>::value && sizeof(TIn) < sizeof(TOut),
            bool>::type
    canConvertNumber(TIn) {
        return true;
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_floating_point<TOut>::value,
            bool>::type
    canConvertNumber(TIn) {
        return true;
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
                       is_integral<TOut>::value && is_signed<TOut>::value &&
                       sizeof(TOut) < sizeof(TIn),
            bool>::type
    canConvertNumber(TIn value) {
        return value >= TIn(numeric_limits<TOut>::lowest()) &&
               value <= TIn(numeric_limits<TOut>::highest());
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
                       is_integral<TOut>::value && is_signed<TOut>::value &&
                       sizeof(TIn) <= sizeof(TOut),
            bool>::type
    canConvertNumber(TIn) {
        return true;
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
                       is_integral<TOut>::value && is_unsigned<TOut>::value &&
                       sizeof(TOut) >= sizeof(TIn),
            bool>::type
    canConvertNumber(TIn value) {
        if (value < 0)
            return false;
        return TOut(value) <= numeric_limits<TOut>::highest();
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_integral<TIn>::value && is_signed<TIn>::value &&
                       is_integral<TOut>::value && is_unsigned<TOut>::value &&
                       sizeof(TOut) < sizeof(TIn),
            bool>::type
    canConvertNumber(TIn value) {
        if (value < 0)
            return false;
        return value <= TIn(numeric_limits<TOut>::highest());
    }

    template<typename TOut, typename TIn>
    typename enable_if<is_floating_point<TIn>::value &&
                       !is_floating_point<TOut>::value,
            bool>::type
    canConvertNumber(TIn value) {
        return value >= numeric_limits<TOut>::lowest() &&
               value <= numeric_limits<TOut>::highest();
    }

    template<typename TOut, typename TIn>
    TOut convertNumber(TIn value) {
        return canConvertNumber<TOut>(value) ? TOut(value) : 0;
    }
}  // namespace ARDUINOJSON_NAMESPACE
#if defined(__clang__)
#  pragma clang diagnostic pop
#elif defined(__GNUC__)
#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#    pragma GCC diagnostic pop
#  endif
#endif
#if defined(__GNUC__)
#  if __GNUC__ >= 7
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#    pragma GCC diagnostic ignored "-Wuninitialized"
#  endif
#endif
namespace ARDUINOJSON_NAMESPACE {
    class VariantData {
        VariantContent _content;  // must be first to allow cast from array to variant
        uint8_t _flags;
    public:
        void init() {
            _flags = VALUE_IS_NULL;
        }

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            switch (type()) {
                case VALUE_IS_FLOAT:
                    return visitor.visitFloat(_content.asFloat);
                case VALUE_IS_ARRAY:
                    return visitor.visitArray(_content.asCollection);
                case VALUE_IS_OBJECT:
                    return visitor.visitObject(_content.asCollection);
                case VALUE_IS_LINKED_STRING:
                case VALUE_IS_OWNED_STRING:
                    return visitor.visitString(_content.asString);
                case VALUE_IS_OWNED_RAW:
                case VALUE_IS_LINKED_RAW:
                    return visitor.visitRawJson(_content.asRaw.data, _content.asRaw.size);
                case VALUE_IS_SIGNED_INTEGER:
                    return visitor.visitSignedInteger(_content.asSignedInteger);
                case VALUE_IS_UNSIGNED_INTEGER:
                    return visitor.visitUnsignedInteger(_content.asUnsignedInteger);
                case VALUE_IS_BOOLEAN:
                    return visitor.visitBoolean(_content.asBoolean != 0);
                default:
                    return visitor.visitNull();
            }
        }

        template<typename T>
        T asIntegral() const;

        template<typename T>
        T asFloat() const;

        const char *asString() const;

        bool asBoolean() const;

        CollectionData *asArray() {
            return isArray() ? &_content.asCollection : 0;
        }

        const CollectionData *asArray() const {
            return const_cast<VariantData *>(this)->asArray();
        }

        CollectionData *asObject() {
            return isObject() ? &_content.asCollection : 0;
        }

        const CollectionData *asObject() const {
            return const_cast<VariantData *>(this)->asObject();
        }

        bool copyFrom(const VariantData &src, MemoryPool *pool) {
            switch (src.type()) {
                case VALUE_IS_ARRAY:
                    return toArray().copyFrom(src._content.asCollection, pool);
                case VALUE_IS_OBJECT:
                    return toObject().copyFrom(src._content.asCollection, pool);
                case VALUE_IS_OWNED_STRING:
                    return setString(adaptString(const_cast<char *>(src._content.asString)),
                                     pool);
                case VALUE_IS_OWNED_RAW:
                    return setOwnedRaw(
                            serialized(src._content.asRaw.data, src._content.asRaw.size), pool);
                default:
                    setType(src.type());
                    _content = src._content;
                    return true;
            }
        }

        bool isArray() const {
            return (_flags & VALUE_IS_ARRAY) != 0;
        }

        bool isBoolean() const {
            return type() == VALUE_IS_BOOLEAN;
        }

        bool isCollection() const {
            return (_flags & COLLECTION_MASK) != 0;
        }

        template<typename T>
        bool isInteger() const {
            switch (type()) {
                case VALUE_IS_UNSIGNED_INTEGER:
                    return canConvertNumber<T>(_content.asUnsignedInteger);
                case VALUE_IS_SIGNED_INTEGER:
                    return canConvertNumber<T>(_content.asSignedInteger);
                default:
                    return false;
            }
        }

        bool isFloat() const {
            return (_flags & NUMBER_BIT) != 0;
        }

        bool isString() const {
            return type() == VALUE_IS_LINKED_STRING || type() == VALUE_IS_OWNED_STRING;
        }

        bool isObject() const {
            return (_flags & VALUE_IS_OBJECT) != 0;
        }

        bool isNull() const {
            return type() == VALUE_IS_NULL;
        }

        bool isEnclosed() const {
            return !isFloat();
        }

        void remove(size_t index) {
            if (isArray())
                _content.asCollection.removeElement(index);
        }

        template<typename TAdaptedString>
        void remove(TAdaptedString key) {
            if (isObject())
                _content.asCollection.removeMember(key);
        }

        void setBoolean(bool value) {
            setType(VALUE_IS_BOOLEAN);
            _content.asBoolean = value;
        }

        void setFloat(Float value) {
            setType(VALUE_IS_FLOAT);
            _content.asFloat = value;
        }

        void setLinkedRaw(SerializedValue<const char *> value) {
            if (value.data()) {
                setType(VALUE_IS_LINKED_RAW);
                _content.asRaw.data = value.data();
                _content.asRaw.size = value.size();
            } else {
                setType(VALUE_IS_NULL);
            }
        }

        template<typename T>
        bool setOwnedRaw(SerializedValue<T> value, MemoryPool *pool) {
            const char *dup = pool->saveString(adaptString(value.data(), value.size()));
            if (dup) {
                setType(VALUE_IS_OWNED_RAW);
                _content.asRaw.data = dup;
                _content.asRaw.size = value.size();
                return true;
            } else {
                setType(VALUE_IS_NULL);
                return false;
            }
        }

        template<typename T>
        typename enable_if<is_unsigned<T>::value>::type setInteger(T value) {
            setType(VALUE_IS_UNSIGNED_INTEGER);
            _content.asUnsignedInteger = static_cast<UInt>(value);
        }

        template<typename T>
        typename enable_if<is_signed<T>::value>::type setInteger(T value) {
            setType(VALUE_IS_SIGNED_INTEGER);
            _content.asSignedInteger = value;
        }

        void setNull() {
            setType(VALUE_IS_NULL);
        }

        void setStringPointer(const char *s, storage_policies::store_by_copy) {
            ARDUINOJSON_ASSERT(s != 0);
            setType(VALUE_IS_OWNED_STRING);
            _content.asString = s;
        }

        void setStringPointer(const char *s, storage_policies::store_by_address) {
            ARDUINOJSON_ASSERT(s != 0);
            setType(VALUE_IS_LINKED_STRING);
            _content.asString = s;
        }

        template<typename TAdaptedString>
        bool setString(TAdaptedString value, MemoryPool *pool) {
            return storeString(value, pool, typename TAdaptedString::storage_policy());
        }

        CollectionData &toArray() {
            setType(VALUE_IS_ARRAY);
            _content.asCollection.clear();
            return _content.asCollection;
        }

        CollectionData &toObject() {
            setType(VALUE_IS_OBJECT);
            _content.asCollection.clear();
            return _content.asCollection;
        }

        size_t memoryUsage() const {
            switch (type()) {
                case VALUE_IS_OWNED_STRING:
                    return strlen(_content.asString) + 1;
                case VALUE_IS_OWNED_RAW:
                    return _content.asRaw.size;
                case VALUE_IS_OBJECT:
                case VALUE_IS_ARRAY:
                    return _content.asCollection.memoryUsage();
                default:
                    return 0;
            }
        }

        size_t nesting() const {
            return isCollection() ? _content.asCollection.nesting() : 0;
        }

        size_t size() const {
            return isCollection() ? _content.asCollection.size() : 0;
        }

        VariantData *addElement(MemoryPool *pool) {
            if (isNull())
                toArray();
            if (!isArray())
                return 0;
            return _content.asCollection.addElement(pool);
        }

        VariantData *getElement(size_t index) const {
            return isArray() ? _content.asCollection.getElement(index) : 0;
        }

        VariantData *getOrAddElement(size_t index, MemoryPool *pool) {
            if (isNull())
                toArray();
            if (!isArray())
                return 0;
            return _content.asCollection.getOrAddElement(index, pool);
        }

        template<typename TAdaptedString>
        VariantData *getMember(TAdaptedString key) const {
            return isObject() ? _content.asCollection.getMember(key) : 0;
        }

        template<typename TAdaptedString>
        VariantData *getOrAddMember(TAdaptedString key, MemoryPool *pool) {
            if (isNull())
                toObject();
            if (!isObject())
                return 0;
            return _content.asCollection.getOrAddMember(key, pool);
        }

        void movePointers(ptrdiff_t stringDistance, ptrdiff_t variantDistance) {
            if (_flags & OWNED_VALUE_BIT)
                _content.asString += stringDistance;
            if (_flags & COLLECTION_MASK)
                _content.asCollection.movePointers(stringDistance, variantDistance);
        }

        uint8_t type() const {
            return _flags & VALUE_MASK;
        }

    private:
        void setType(uint8_t t) {
            _flags &= OWNED_KEY_BIT;
            _flags |= t;
        }

        template<typename TAdaptedString>
        inline bool storeString(TAdaptedString value, MemoryPool *pool,
                                storage_policies::decide_at_runtime) {
            if (value.isStatic())
                return storeString(value, pool, storage_policies::store_by_address());
            else
                return storeString(value, pool, storage_policies::store_by_copy());
        }

        template<typename TAdaptedString>
        inline bool storeString(TAdaptedString value, MemoryPool *,
                                storage_policies::store_by_address) {
            if (value.isNull())
                setNull();
            else
                setStringPointer(value.data(), storage_policies::store_by_address());
            return true;
        }

        template<typename TAdaptedString>
        inline bool storeString(TAdaptedString value, MemoryPool *pool,
                                storage_policies::store_by_copy) {
            if (value.isNull()) {
                setNull();
                return true;
            }
            const char *copy = pool->saveString(value);
            if (!copy) {
                setNull();
                return false;
            }
            setStringPointer(copy, storage_policies::store_by_copy());
            return true;
        }
    };
}  // namespace ARDUINOJSON_NAMESPACE
#if defined(__GNUC__)
#  if __GNUC__ >= 8
#    pragma GCC diagnostic pop
#  endif
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename TAdaptedString>
    inline bool slotSetKey(VariantSlot *var, TAdaptedString key, MemoryPool *pool) {
        if (!var)
            return false;
        return slotSetKey(var, key, pool, typename TAdaptedString::storage_policy());
    }

    template<typename TAdaptedString>
    inline bool slotSetKey(VariantSlot *var, TAdaptedString key, MemoryPool *pool,
                           storage_policies::decide_at_runtime) {
        if (key.isStatic()) {
            return slotSetKey(var, key, pool, storage_policies::store_by_address());
        } else {
            return slotSetKey(var, key, pool, storage_policies::store_by_copy());
        }
    }

    template<typename TAdaptedString>
    inline bool slotSetKey(VariantSlot *var, TAdaptedString key, MemoryPool *,
                           storage_policies::store_by_address) {
        ARDUINOJSON_ASSERT(var);
        var->setKey(key.data(), storage_policies::store_by_address());
        return true;
    }

    template<typename TAdaptedString>
    inline bool slotSetKey(VariantSlot *var, TAdaptedString key, MemoryPool *pool,
                           storage_policies::store_by_copy) {
        const char *dup = pool->saveString(key);
        if (!dup)
            return false;
        ARDUINOJSON_ASSERT(var);
        var->setKey(dup, storage_policies::store_by_copy());
        return true;
    }

    inline size_t slotSize(const VariantSlot *var) {
        size_t n = 0;
        while (var) {
            n++;
            var = var->next();
        }
        return n;
    }

    inline VariantData *slotData(VariantSlot *slot) {
        return reinterpret_cast<VariantData *>(slot);
    }

    struct Visitable {
    };
    template<typename T>
    struct IsVisitable : is_base_of<Visitable, T> {
    };
    template<typename T>
    struct IsVisitable<T &> : IsVisitable<T> {
    };
    template<typename T, typename Enable = void>
    struct Converter;

    template<typename T1, typename T2>
    class InvalidConversion;  // Error here? See https://arduinojson.org/v6/invalid-conversion/
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER  // Visual Studio
                                                                                                                        #  define FORCE_INLINE  // __forceinline causes C4714 when returning std::string
#  define NO_INLINE __declspec(noinline)
#  ifndef ARDUINOJSON_DEPRECATED
#    define ARDUINOJSON_DEPRECATED(msg) __declspec(deprecated(msg))
#  endif
#elif defined(__GNUC__)  // GCC or Clang
#  define FORCE_INLINE __attribute__((always_inline))
#  define NO_INLINE __attribute__((noinline))
#  ifndef ARDUINOJSON_DEPRECATED
#    if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
#      define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated(msg)))
#    else
#      define ARDUINOJSON_DEPRECATED(msg) __attribute__((deprecated))
#    endif
#  endif
#else  // Other compilers
                                                                                                                        #  define FORCE_INLINE
#  define NO_INLINE
#  ifndef ARDUINOJSON_DEPRECATED
#    define ARDUINOJSON_DEPRECATED(msg)
#  endif
#endif
#if __cplusplus >= 201103L
#  define NOEXCEPT noexcept
#else
#  define NOEXCEPT throw()
#endif
#if defined(__has_attribute)
                                                                                                                        #  if __has_attribute(no_sanitize)
#    define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check)))
#  else
#    define ARDUINOJSON_NO_SANITIZE(check)
#  endif
#else
#  define ARDUINOJSON_NO_SANITIZE(check)
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename TVisitor>
    inline typename TVisitor::result_type variantAccept(const VariantData *var,
                                                        TVisitor &visitor) {
        if (var != 0)
            return var->accept(visitor);
        else
            return visitor.visitNull();
    }

    inline const CollectionData *variantAsArray(const VariantData *var) {
        return var != 0 ? var->asArray() : 0;
    }

    inline const CollectionData *variantAsObject(const VariantData *var) {
        return var != 0 ? var->asObject() : 0;
    }

    inline CollectionData *variantAsObject(VariantData *var) {
        return var != 0 ? var->asObject() : 0;
    }

    inline bool variantCopyFrom(VariantData *dst, const VariantData *src,
                                MemoryPool *pool) {
        if (!dst)
            return false;
        if (!src) {
            dst->setNull();
            return true;
        }
        return dst->copyFrom(*src, pool);
    }

    inline int variantCompare(const VariantData *a, const VariantData *b);

    inline void variantSetNull(VariantData *var) {
        if (!var)
            return;
        var->setNull();
    }

    template<typename TAdaptedString>
    inline bool variantSetString(VariantData *var, TAdaptedString value,
                                 MemoryPool *pool) {
        if (!var)
            return false;
        return var->setString(value, pool);
    }

    inline size_t variantSize(const VariantData *var) {
        return var != 0 ? var->size() : 0;
    }

    inline CollectionData *variantToArray(VariantData *var) {
        if (!var)
            return 0;
        return &var->toArray();
    }

    inline CollectionData *variantToObject(VariantData *var) {
        if (!var)
            return 0;
        return &var->toObject();
    }

    inline NO_INLINE VariantData *variantAddElement(VariantData *var,
                                                    MemoryPool *pool) {
        return var != 0 ? var->addElement(pool) : 0;
    }

    inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var,
                                                         size_t index,
                                                         MemoryPool *pool) {
        return var != 0 ? var->getOrAddElement(index, pool) : 0;
    }

    template<typename TChar>
    NO_INLINE VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
                                                 MemoryPool *pool) {
        return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0;
    }

    template<typename TString>
    NO_INLINE VariantData *variantGetOrAddMember(VariantData *var,
                                                 const TString &key,
                                                 MemoryPool *pool) {
        return var != 0 ? var->getOrAddMember(adaptString(key), pool) : 0;
    }

    inline bool variantIsNull(const VariantData *var) {
        return var == 0 || var->isNull();
    }

    enum CompareResult {
        COMPARE_RESULT_DIFFER = 0,
        COMPARE_RESULT_EQUAL = 1,
        COMPARE_RESULT_GREATER = 2,
        COMPARE_RESULT_LESS = 4,
        COMPARE_RESULT_GREATER_OR_EQUAL = 3,
        COMPARE_RESULT_LESS_OR_EQUAL = 5
    };

    template<typename T>
    CompareResult arithmeticCompare(const T &lhs, const T &rhs) {
        if (lhs < rhs)
            return COMPARE_RESULT_LESS;
        else if (lhs > rhs)
            return COMPARE_RESULT_GREATER;
        else
            return COMPARE_RESULT_EQUAL;
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                               sizeof(T1) < sizeof(T2),
                    int  // Using int instead of void to avoid C2572 on
            >::type * = 0) {
        return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                               sizeof(T2) < sizeof(T1)>::type * = 0) {
        return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                               is_signed<T1>::value == is_signed<T2>::value &&
                               sizeof(T2) == sizeof(T1)>::type * = 0) {
        return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                               is_unsigned<T1>::value && is_signed<T2>::value &&
                               sizeof(T2) == sizeof(T1)>::type * = 0) {
        if (rhs < 0)
            return COMPARE_RESULT_GREATER;
        return arithmeticCompare<T1>(lhs, static_cast<T1>(rhs));
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_integral<T1>::value && is_integral<T2>::value &&
                               is_signed<T1>::value && is_unsigned<T2>::value &&
                               sizeof(T2) == sizeof(T1)>::type * = 0) {
        if (lhs < 0)
            return COMPARE_RESULT_LESS;
        return arithmeticCompare<T2>(static_cast<T2>(lhs), rhs);
    }

    template<typename T1, typename T2>
    CompareResult arithmeticCompare(
            const T1 &lhs, const T2 &rhs,
            typename enable_if<is_floating_point<T1>::value ||
                               is_floating_point<T2>::value>::type * = 0) {
        return arithmeticCompare<double>(static_cast<double>(lhs),
                                         static_cast<double>(rhs));
    }

    template<typename T2>
    CompareResult arithmeticCompareNegateLeft(
            UInt, const T2 &, typename enable_if<is_unsigned<T2>::value>::type * = 0) {
        return COMPARE_RESULT_LESS;
    }

    template<typename T2>
    CompareResult arithmeticCompareNegateLeft(
            UInt lhs, const T2 &rhs,
            typename enable_if<is_signed<T2>::value>::type * = 0) {
        if (rhs > 0)
            return COMPARE_RESULT_LESS;
        return arithmeticCompare(-rhs, static_cast<T2>(lhs));
    }

    template<typename T1>
    CompareResult arithmeticCompareNegateRight(
            const T1 &, UInt, typename enable_if<is_unsigned<T1>::value>::type * = 0) {
        return COMPARE_RESULT_GREATER;
    }

    template<typename T1>
    CompareResult arithmeticCompareNegateRight(
            const T1 &lhs, UInt rhs,
            typename enable_if<is_signed<T1>::value>::type * = 0) {
        if (lhs > 0)
            return COMPARE_RESULT_GREATER;
        return arithmeticCompare(static_cast<T1>(rhs), -lhs);
    }

    struct VariantTag {
    };
    template<typename T>
    struct IsVariant : is_base_of<VariantTag, T> {
    };

    template<typename T1, typename T2>
    CompareResult compare(const T1 &lhs, const T2 &rhs);  // VariantCompare.cpp
    template<typename TVariant>
    struct VariantOperators {
        template<typename T>
        friend
        typename enable_if<!IsVariant<T>::value && !is_array<T>::value, T>::type
        operator|(const TVariant &variant, const T &defaultValue) {
            if (variant.template is<T>())
                return variant.template as<T>();
            else
                return defaultValue;
        }

        friend const char *operator|(const TVariant &variant,
                                     const char *defaultValue) {
            if (variant.template is<const char *>())
                return variant.template as<const char *>();
            else
                return defaultValue;
        }

        template<typename T>
        friend typename enable_if<IsVariant<T>::value, typename T::variant_type>::type
        operator|(const TVariant &variant, T defaultValue) {
            if (variant)
                return variant;
            else
                return defaultValue;
        }

        template<typename T>
        friend bool operator==(T *lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator==(const T &lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator==(TVariant lhs, T *rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator==(
                TVariant lhs, const T &rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator!=(T *lhs, TVariant rhs) {
            return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator!=(const T &lhs, TVariant rhs) {
            return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator!=(TVariant lhs, T *rhs) {
            return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator!=(
                TVariant lhs, const T &rhs) {
            return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
        }

        template<typename T>
        friend bool operator<(T *lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
        }

        template<typename T>
        friend bool operator<(const T &lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
        }

        template<typename T>
        friend bool operator<(TVariant lhs, T *rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_LESS;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<(
                TVariant lhs, const T &rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_LESS;
        }

        template<typename T>
        friend bool operator<=(T *lhs, TVariant rhs) {
            return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
        }

        template<typename T>
        friend bool operator<=(const T &lhs, TVariant rhs) {
            return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
        }

        template<typename T>
        friend bool operator<=(TVariant lhs, T *rhs) {
            return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<=(
                TVariant lhs, const T &rhs) {
            return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
        }

        template<typename T>
        friend bool operator>(T *lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_LESS;
        }

        template<typename T>
        friend bool operator>(const T &lhs, TVariant rhs) {
            return compare(rhs, lhs) == COMPARE_RESULT_LESS;
        }

        template<typename T>
        friend bool operator>(TVariant lhs, T *rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>(
                TVariant lhs, const T &rhs) {
            return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
        }

        template<typename T>
        friend bool operator>=(T *lhs, TVariant rhs) {
            return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
        }

        template<typename T>
        friend bool operator>=(const T &lhs, TVariant rhs) {
            return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
        }

        template<typename T>
        friend bool operator>=(TVariant lhs, T *rhs) {
            return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
        }

        template<typename T>
        friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>=(
                TVariant lhs, const T &rhs) {
            return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
        }
    };

    class ArrayRef;

    class ObjectRef;

    template<typename>
    class ElementProxy;

    template<typename TArray>
    class ArrayShortcuts {
    public:
        FORCE_INLINE ElementProxy<TArray> operator[](size_t index) const;

        FORCE_INLINE ObjectRef createNestedObject() const;

        FORCE_INLINE ArrayRef createNestedArray() const;

        template<typename T>
        FORCE_INLINE bool add(const T &value) const {
            return impl()->addElement().set(value);
        }

        template<typename T>
        FORCE_INLINE bool add(T *value) const {
            return impl()->addElement().set(value);
        }

    private:
        const TArray *impl() const {
            return static_cast<const TArray *>(this);
        }
    };

    template<typename TParent, typename TStringRef>
    class MemberProxy;

    template<typename TObject>
    class ObjectShortcuts {
    public:
        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value, bool>::type
        containsKey(const TString &key) const;

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value, bool>::type
        containsKey(TChar *key) const;

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value,
                MemberProxy<TObject, TString> >::type
        operator[](const TString &key) const;

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value,
                MemberProxy<TObject, TChar *> >::type
        operator[](TChar *key) const;

        template<typename TString>
        FORCE_INLINE ArrayRef createNestedArray(const TString &key) const;

        template<typename TChar>
        FORCE_INLINE ArrayRef createNestedArray(TChar *key) const;

        template<typename TString>
        ObjectRef createNestedObject(const TString &key) const;

        template<typename TChar>
        ObjectRef createNestedObject(TChar *key) const;

    private:
        const TObject *impl() const {
            return static_cast<const TObject *>(this);
        }
    };

    template<typename TVariant>
    class VariantShortcuts : public ObjectShortcuts<TVariant>,
                             public ArrayShortcuts<TVariant> {
    public:
        using ArrayShortcuts<TVariant>::createNestedArray;
        using ArrayShortcuts<TVariant>::createNestedObject;
        using ArrayShortcuts<TVariant>::operator[];
        using ObjectShortcuts<TVariant>::createNestedArray;
        using ObjectShortcuts<TVariant>::createNestedObject;
        using ObjectShortcuts<TVariant>::operator[];
    };

    class ArrayRef;

    class ObjectRef;

    template<typename TData>
    class VariantRefBase : public VariantTag {
    public:
        FORCE_INLINE bool isNull() const {
            return variantIsNull(_data);
        }

        FORCE_INLINE bool isUndefined() const {
            return !_data;
        }

        FORCE_INLINE size_t memoryUsage() const {
            return _data ? _data->memoryUsage() : 0;
        }

        FORCE_INLINE size_t nesting() const {
            return _data ? _data->nesting() : 0;
        }

        size_t size() const {
            return variantSize(_data);
        }

    protected:
        VariantRefBase(TData *data) : _data(data) {}

        TData *_data;

        friend TData *getData(const VariantRefBase &variant) {
            return variant._data;
        }
    };

    class VariantRef : public VariantRefBase<VariantData>,
                       public VariantOperators<VariantRef>,
                       public VariantShortcuts<VariantRef>,
                       public Visitable {
        typedef VariantRefBase<VariantData> base_type;

        friend class VariantConstRef;

    public:
        FORCE_INLINE VariantRef(MemoryPool *pool, VariantData *data)
                : base_type(data), _pool(pool) {}

        FORCE_INLINE VariantRef() : base_type(0), _pool(0) {}

        FORCE_INLINE void clear() const {
            return variantSetNull(_data);
        }

        template<typename T>
        FORCE_INLINE bool set(const T &value) const {
            Converter<T>::toJson(value, *this);
            return _pool && !_pool->overflowed();
        }

        bool ARDUINOJSON_DEPRECATED(
                "Support for char is deprecated, use int8_t or uint8_t instead")
        set(char value) const;

        template<typename T>
        FORCE_INLINE bool set(T *value) const {
            Converter<T *>::toJson(value, *this);
            return _pool && !_pool->overflowed();
        }

        template<typename T>
        FORCE_INLINE
        typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
                T>::type
        as() const {
            return Converter<T>::fromJson(*this);
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
        ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
        as() const {
            return as<const char *>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
        ARDUINOJSON_DEPRECATED(
                "Support for char is deprecated, use int8_t or uint8_t instead")
        as() const {
            return as<signed char>();
        }

        template<typename T>
        FORCE_INLINE
        typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
                bool>::type
        is() const {
            return Converter<T>::checkJson(*this);
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
        ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
        is() const {
            return is<const char *>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
        ARDUINOJSON_DEPRECATED(
                "Support for char is deprecated, use int8_t or uint8_t instead")
        is() const {
            return is<signed char>();
        }

        template<typename T>
        FORCE_INLINE operator T() const {
            return as<T>();
        }

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return variantAccept(_data, visitor);
        }

        template<typename T>
        typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type to() const;

        template<typename T>
        typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type to() const;

        template<typename T>
        typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type to()
        const;

        VariantRef addElement() const;

        FORCE_INLINE VariantRef getElement(size_t) const;

        FORCE_INLINE VariantRef getOrAddElement(size_t) const;

        template<typename TChar>
        FORCE_INLINE VariantRef getMember(TChar *) const;

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type
        getMember(const TString &) const;

        template<typename TChar>
        FORCE_INLINE VariantRef getOrAddMember(TChar *) const;

        template<typename TString>
        FORCE_INLINE VariantRef getOrAddMember(const TString &) const;

        FORCE_INLINE void remove(size_t index) const {
            if (_data)
                _data->remove(index);
        }

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
                TChar *key) const {
            if (_data)
                _data->remove(adaptString(key));
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
                const TString &key) const {
            if (_data)
                _data->remove(adaptString(key));
        }

    private:
        MemoryPool *_pool;

        friend MemoryPool *getPool(const VariantRef &variant) {
            return variant._pool;
        }
    };

    class VariantConstRef : public VariantRefBase<const VariantData>,
                            public VariantOperators<VariantConstRef>,
                            public VariantShortcuts<VariantConstRef>,
                            public Visitable {
        typedef VariantRefBase<const VariantData> base_type;

        friend class VariantRef;

    public:
        VariantConstRef() : base_type(0) {}

        VariantConstRef(const VariantData *data) : base_type(data) {}

        VariantConstRef(VariantRef var) : base_type(var._data) {}

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return variantAccept(_data, visitor);
        }

        template<typename T>
        FORCE_INLINE
        typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
                T>::type
        as() const {
            return Converter<T>::fromJson(*this);
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
        ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
        as() const {
            return as<const char *>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char>::value, char>::type
        ARDUINOJSON_DEPRECATED(
                "Support for char is deprecated, use int8_t or uint8_t instead")
        as() const {
            return as<signed char>();
        }

        template<typename T>
        FORCE_INLINE
        typename enable_if<!is_same<T, char *>::value && !is_same<T, char>::value,
                bool>::type
        is() const {
            return Converter<T>::checkJson(*this);
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, bool>::type
        ARDUINOJSON_DEPRECATED("Replace is<char*>() with is<const char*>()")
        is() const {
            return is<const char *>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char>::value, bool>::type
        ARDUINOJSON_DEPRECATED(
                "Support for char is deprecated, use int8_t or uint8_t instead")
        is() const {
            return is<signed char>();
        }

        template<typename T>
        FORCE_INLINE operator T() const {
            return as<T>();
        }

        FORCE_INLINE VariantConstRef getElement(size_t) const;

        FORCE_INLINE VariantConstRef operator[](size_t index) const {
            return getElement(index);
        }

        template<typename TString>
        FORCE_INLINE VariantConstRef getMember(const TString &key) const {
            return VariantConstRef(
                    objectGetMember(variantAsObject(_data), adaptString(key)));
        }

        template<typename TChar>
        FORCE_INLINE VariantConstRef getMember(TChar *key) const {
            const CollectionData *obj = variantAsObject(_data);
            return VariantConstRef(obj ? obj->getMember(adaptString(key)) : 0);
        }

        template<typename TString>
        FORCE_INLINE
        typename enable_if<IsString<TString>::value, VariantConstRef>::type
        operator[](const TString &key) const {
            return getMember(key);
        }

        template<typename TChar>
        FORCE_INLINE
        typename enable_if<IsString<TChar *>::value, VariantConstRef>::type
        operator[](TChar *key) const {
            return getMember(key);
        }
    };

    template<>
    struct Converter<VariantRef> {
        static void toJson(VariantRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static VariantRef fromJson(VariantRef src) {
            return src;
        }

        static InvalidConversion<VariantConstRef, VariantRef> fromJson(
                VariantConstRef);

        static bool checkJson(VariantRef src) {
            VariantData *data = getData(src);
            return !!data;
        }

        static bool checkJson(VariantConstRef) {
            return false;
        }
    };

    template<>
    struct Converter<VariantConstRef> {
        static void toJson(VariantConstRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static VariantConstRef fromJson(VariantConstRef src) {
            return VariantConstRef(getData(src));
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return !!data;
        }
    };

    class VariantPtr {
    public:
        VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}

        VariantRef *operator->() {
            return &_variant;
        }

        VariantRef &operator*() {
            return _variant;
        }

    private:
        VariantRef _variant;
    };

    class ArrayIterator {
    public:
        ArrayIterator() : _slot(0) {}

        explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
                : _pool(pool), _slot(slot) {}

        VariantRef operator*() const {
            return VariantRef(_pool, _slot->data());
        }

        VariantPtr operator->() {
            return VariantPtr(_pool, _slot->data());
        }

        bool operator==(const ArrayIterator &other) const {
            return _slot == other._slot;
        }

        bool operator!=(const ArrayIterator &other) const {
            return _slot != other._slot;
        }

        ArrayIterator &operator++() {
            _slot = _slot->next();
            return *this;
        }

        ArrayIterator &operator+=(size_t distance) {
            _slot = _slot->next(distance);
            return *this;
        }

        VariantSlot *internal() {
            return _slot;
        }

    private:
        MemoryPool *_pool;
        VariantSlot *_slot;
    };

    class VariantConstPtr {
    public:
        VariantConstPtr(const VariantData *data) : _variant(data) {}

        VariantConstRef *operator->() {
            return &_variant;
        }

        VariantConstRef &operator*() {
            return _variant;
        }

    private:
        VariantConstRef _variant;
    };

    class ArrayConstRefIterator {
    public:
        ArrayConstRefIterator() : _slot(0) {}

        explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}

        VariantConstRef operator*() const {
            return VariantConstRef(_slot->data());
        }

        VariantConstPtr operator->() {
            return VariantConstPtr(_slot->data());
        }

        bool operator==(const ArrayConstRefIterator &other) const {
            return _slot == other._slot;
        }

        bool operator!=(const ArrayConstRefIterator &other) const {
            return _slot != other._slot;
        }

        ArrayConstRefIterator &operator++() {
            _slot = _slot->next();
            return *this;
        }

        ArrayConstRefIterator &operator+=(size_t distance) {
            _slot = _slot->next(distance);
            return *this;
        }

        const VariantSlot *internal() {
            return _slot;
        }

    private:
        const VariantSlot *_slot;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
  ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
namespace ARDUINOJSON_NAMESPACE {
    class ObjectRef;

    template<typename>
    class ElementProxy;

    template<typename TData>
    class ArrayRefBase {
    public:
        operator VariantConstRef() const {
            const void *data = _data;  // prevent warning cast-align
            return VariantConstRef(reinterpret_cast<const VariantData *>(data));
        }

        template<typename TVisitor>
        FORCE_INLINE typename TVisitor::result_type accept(TVisitor &visitor) const {
            return arrayAccept(_data, visitor);
        }

        FORCE_INLINE bool isNull() const {
            return _data == 0;
        }

        FORCE_INLINE operator bool() const {
            return _data != 0;
        }

        FORCE_INLINE size_t memoryUsage() const {
            return _data ? _data->memoryUsage() : 0;
        }

        FORCE_INLINE size_t nesting() const {
            return _data ? _data->nesting() : 0;
        }

        FORCE_INLINE size_t size() const {
            return _data ? _data->size() : 0;
        }

    protected:
        ArrayRefBase(TData *data) : _data(data) {}

        TData *_data;
    };

    class ArrayConstRef : public ArrayRefBase<const CollectionData>,
                          public Visitable {
        friend class ArrayRef;

        typedef ArrayRefBase<const CollectionData> base_type;
    public:
        typedef ArrayConstRefIterator iterator;

        FORCE_INLINE iterator begin() const {
            if (!_data)
                return iterator();
            return iterator(_data->head());
        }

        FORCE_INLINE iterator end() const {
            return iterator();
        }

        FORCE_INLINE ArrayConstRef() : base_type(0) {}

        FORCE_INLINE ArrayConstRef(const CollectionData *data) : base_type(data) {}

        FORCE_INLINE bool operator==(ArrayConstRef rhs) const {
            return arrayEquals(_data, rhs._data);
        }

        FORCE_INLINE VariantConstRef operator[](size_t index) const {
            return getElement(index);
        }

        FORCE_INLINE VariantConstRef getElement(size_t index) const {
            return VariantConstRef(_data ? _data->getElement(index) : 0);
        }
    };

    class ArrayRef : public ArrayRefBase<CollectionData>,
                     public ArrayShortcuts<ArrayRef>,
                     public Visitable {
        typedef ArrayRefBase<CollectionData> base_type;
    public:
        typedef ArrayIterator iterator;

        FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {}

        FORCE_INLINE ArrayRef(MemoryPool *pool, CollectionData *data)
                : base_type(data), _pool(pool) {}

        operator VariantRef() {
            void *data = _data;  // prevent warning cast-align
            return VariantRef(_pool, reinterpret_cast<VariantData *>(data));
        }

        operator ArrayConstRef() const {
            return ArrayConstRef(_data);
        }

        VariantRef addElement() const {
            return VariantRef(_pool, arrayAdd(_data, _pool));
        }

        FORCE_INLINE iterator begin() const {
            if (!_data)
                return iterator();
            return iterator(_pool, _data->head());
        }

        FORCE_INLINE iterator end() const {
            return iterator();
        }

        FORCE_INLINE bool set(ArrayConstRef src) const {
            if (!_data || !src._data)
                return false;
            return _data->copyFrom(*src._data, _pool);
        }

        FORCE_INLINE bool operator==(ArrayRef rhs) const {
            return arrayEquals(_data, rhs._data);
        }

        FORCE_INLINE VariantRef getOrAddElement(size_t index) const {
            return VariantRef(_pool, _data ? _data->getOrAddElement(index, _pool) : 0);
        }

        FORCE_INLINE VariantRef getElement(size_t index) const {
            return VariantRef(_pool, _data ? _data->getElement(index) : 0);
        }

        FORCE_INLINE void remove(iterator it) const {
            if (!_data)
                return;
            _data->removeSlot(it.internal());
        }

        FORCE_INLINE void remove(size_t index) const {
            if (!_data)
                return;
            _data->removeElement(index);
        }

        void clear() const {
            if (!_data)
                return;
            _data->clear();
        }

    private:
        MemoryPool *_pool;
    };

    template<>
    struct Converter<ArrayConstRef> {
        static void toJson(VariantConstRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static ArrayConstRef fromJson(VariantConstRef src) {
            return ArrayConstRef(variantAsArray(getData(src)));
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isArray();
        }
    };

    template<>
    struct Converter<ArrayRef> {
        static void toJson(VariantConstRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static ArrayRef fromJson(VariantRef src) {
            VariantData *data = getData(src);
            MemoryPool *pool = getPool(src);
            return ArrayRef(pool, data != 0 ? data->asArray() : 0);
        }

        static InvalidConversion<VariantConstRef, ArrayRef> fromJson(VariantConstRef);

        static bool checkJson(VariantConstRef) {
            return false;
        }

        static bool checkJson(VariantRef src) {
            VariantData *data = getData(src);
            return data && data->isArray();
        }
    };

    template<typename TVisitor>
    typename TVisitor::result_type objectAccept(const CollectionData *obj,
                                                TVisitor &visitor) {
        if (obj)
            return visitor.visitObject(*obj);
        else
            return visitor.visitNull();
    }

    inline bool objectEquals(const CollectionData *lhs, const CollectionData *rhs) {
        if (lhs == rhs)
            return true;
        if (!lhs || !rhs)
            return false;
        return lhs->equalsObject(*rhs);
    }

    template<typename TAdaptedString>
    inline VariantData *objectGetMember(const CollectionData *obj,
                                        TAdaptedString key) {
        if (!obj)
            return 0;
        return obj->getMember(key);
    }

    template<typename TAdaptedString>
    void objectRemove(CollectionData *obj, TAdaptedString key) {
        if (!obj)
            return;
        obj->removeMember(key);
    }

    template<typename TAdaptedString>
    inline VariantData *objectGetOrAddMember(CollectionData *obj,
                                             TAdaptedString key, MemoryPool *pool) {
        if (!obj)
            return 0;
        return obj->getOrAddMember(key, pool);
    }

    class Pair {
    public:
        Pair(MemoryPool *pool, VariantSlot *slot) {
            if (slot) {
                _key = String(slot->key(), !slot->ownsKey());
                _value = VariantRef(pool, slot->data());
            }
        }

        String key() const {
            return _key;
        }

        VariantRef value() const {
            return _value;
        }

    private:
        String _key;
        VariantRef _value;
    };

    class PairConst {
    public:
        PairConst(const VariantSlot *slot) {
            if (slot) {
                _key = String(slot->key(), !slot->ownsKey());
                _value = VariantConstRef(slot->data());
            }
        }

        String key() const {
            return _key;
        }

        VariantConstRef value() const {
            return _value;
        }

    private:
        String _key;
        VariantConstRef _value;
    };

    class PairPtr {
    public:
        PairPtr(MemoryPool *pool, VariantSlot *slot) : _pair(pool, slot) {}

        const Pair *operator->() const {
            return &_pair;
        }

        const Pair &operator*() const {
            return _pair;
        }

    private:
        Pair _pair;
    };

    class ObjectIterator {
    public:
        ObjectIterator() : _slot(0) {}

        explicit ObjectIterator(MemoryPool *pool, VariantSlot *slot)
                : _pool(pool), _slot(slot) {}

        Pair operator*() const {
            return Pair(_pool, _slot);
        }

        PairPtr operator->() {
            return PairPtr(_pool, _slot);
        }

        bool operator==(const ObjectIterator &other) const {
            return _slot == other._slot;
        }

        bool operator!=(const ObjectIterator &other) const {
            return _slot != other._slot;
        }

        ObjectIterator &operator++() {
            _slot = _slot->next();
            return *this;
        }

        ObjectIterator &operator+=(size_t distance) {
            _slot = _slot->next(distance);
            return *this;
        }

        VariantSlot *internal() {
            return _slot;
        }

    private:
        MemoryPool *_pool;
        VariantSlot *_slot;
    };

    class PairConstPtr {
    public:
        PairConstPtr(const VariantSlot *slot) : _pair(slot) {}

        const PairConst *operator->() const {
            return &_pair;
        }

        const PairConst &operator*() const {
            return _pair;
        }

    private:
        PairConst _pair;
    };

    class ObjectConstIterator {
    public:
        ObjectConstIterator() : _slot(0) {}

        explicit ObjectConstIterator(const VariantSlot *slot) : _slot(slot) {}

        PairConst operator*() const {
            return PairConst(_slot);
        }

        PairConstPtr operator->() {
            return PairConstPtr(_slot);
        }

        bool operator==(const ObjectConstIterator &other) const {
            return _slot == other._slot;
        }

        bool operator!=(const ObjectConstIterator &other) const {
            return _slot != other._slot;
        }

        ObjectConstIterator &operator++() {
            _slot = _slot->next();
            return *this;
        }

        ObjectConstIterator &operator+=(size_t distance) {
            _slot = _slot->next(distance);
            return *this;
        }

        const VariantSlot *internal() {
            return _slot;
        }

    private:
        const VariantSlot *_slot;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
  ((NUMBER_OF_ELEMENTS) * sizeof(ARDUINOJSON_NAMESPACE::VariantSlot))
namespace ARDUINOJSON_NAMESPACE {
    template<typename TData>
    class ObjectRefBase {
    public:
        operator VariantConstRef() const {
            const void *data = _data;  // prevent warning cast-align
            return VariantConstRef(reinterpret_cast<const VariantData *>(data));
        }

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return objectAccept(_data, visitor);
        }

        FORCE_INLINE bool isNull() const {
            return _data == 0;
        }

        FORCE_INLINE operator bool() const {
            return _data != 0;
        }

        FORCE_INLINE size_t memoryUsage() const {
            return _data ? _data->memoryUsage() : 0;
        }

        FORCE_INLINE size_t nesting() const {
            return _data ? _data->nesting() : 0;
        }

        FORCE_INLINE size_t size() const {
            return _data ? _data->size() : 0;
        }

    protected:
        ObjectRefBase(TData *data) : _data(data) {}

        TData *_data;
    };

    class ObjectConstRef : public ObjectRefBase<const CollectionData>,
                           public Visitable {
        friend class ObjectRef;

        typedef ObjectRefBase<const CollectionData> base_type;
    public:
        typedef ObjectConstIterator iterator;

        ObjectConstRef() : base_type(0) {}

        ObjectConstRef(const CollectionData *data) : base_type(data) {}

        FORCE_INLINE iterator begin() const {
            if (!_data)
                return iterator();
            return iterator(_data->head());
        }

        FORCE_INLINE iterator end() const {
            return iterator();
        }

        template<typename TString>
        FORCE_INLINE bool containsKey(const TString &key) const {
            return !getMember(key).isUndefined();
        }

        template<typename TChar>
        FORCE_INLINE bool containsKey(TChar *key) const {
            return !getMember(key).isUndefined();
        }

        template<typename TString>
        FORCE_INLINE VariantConstRef getMember(const TString &key) const {
            return get_impl(adaptString(key));
        }

        template<typename TChar>
        FORCE_INLINE VariantConstRef getMember(TChar *key) const {
            return get_impl(adaptString(key));
        }

        template<typename TString>
        FORCE_INLINE
        typename enable_if<IsString<TString>::value, VariantConstRef>::type
        operator[](const TString &key) const {
            return get_impl(adaptString(key));
        }

        template<typename TChar>
        FORCE_INLINE
        typename enable_if<IsString<TChar *>::value, VariantConstRef>::type
        operator[](TChar *key) const {
            return get_impl(adaptString(key));
        }

        FORCE_INLINE bool operator==(ObjectConstRef rhs) const {
            return objectEquals(_data, rhs._data);
        }

    private:
        template<typename TAdaptedString>
        FORCE_INLINE VariantConstRef get_impl(TAdaptedString key) const {
            return VariantConstRef(objectGetMember(_data, key));
        }
    };

    class ObjectRef : public ObjectRefBase<CollectionData>,
                      public ObjectShortcuts<ObjectRef>,
                      public Visitable {
        typedef ObjectRefBase<CollectionData> base_type;
    public:
        typedef ObjectIterator iterator;

        FORCE_INLINE ObjectRef() : base_type(0), _pool(0) {}

        FORCE_INLINE ObjectRef(MemoryPool *buf, CollectionData *data)
                : base_type(data), _pool(buf) {}

        operator VariantRef() const {
            void *data = _data;  // prevent warning cast-align
            return VariantRef(_pool, reinterpret_cast<VariantData *>(data));
        }

        operator ObjectConstRef() const {
            return ObjectConstRef(_data);
        }

        FORCE_INLINE iterator begin() const {
            if (!_data)
                return iterator();
            return iterator(_pool, _data->head());
        }

        FORCE_INLINE iterator end() const {
            return iterator();
        }

        void clear() const {
            if (!_data)
                return;
            _data->clear();
        }

        FORCE_INLINE bool set(ObjectConstRef src) {
            if (!_data || !src._data)
                return false;
            return _data->copyFrom(*src._data, _pool);
        }

        template<typename TString>
        FORCE_INLINE VariantRef getMember(const TString &key) const {
            return VariantRef(_pool, objectGetMember(_data, adaptString(key)));
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getMember(TChar *key) const {
            return VariantRef(_pool, objectGetMember(_data, adaptString(key)));
        }

        template<typename TString>
        FORCE_INLINE VariantRef getOrAddMember(const TString &key) const {
            return VariantRef(_pool,
                              objectGetOrAddMember(_data, adaptString(key), _pool));
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getOrAddMember(TChar *key) const {
            return VariantRef(_pool,
                              objectGetOrAddMember(_data, adaptString(key), _pool));
        }

        FORCE_INLINE bool operator==(ObjectRef rhs) const {
            return objectEquals(_data, rhs._data);
        }

        FORCE_INLINE void remove(iterator it) const {
            if (!_data)
                return;
            _data->removeSlot(it.internal());
        }

        template<typename TString>
        FORCE_INLINE void remove(const TString &key) const {
            objectRemove(_data, adaptString(key));
        }

        template<typename TChar>
        FORCE_INLINE void remove(TChar *key) const {
            objectRemove(_data, adaptString(key));
        }

    private:
        MemoryPool *_pool;
    };

    template<>
    struct Converter<ObjectConstRef> {
        static void toJson(VariantConstRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static ObjectConstRef fromJson(VariantConstRef src) {
            return ObjectConstRef(variantAsObject(getData(src)));
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isObject();
        }
    };

    template<>
    struct Converter<ObjectRef> {
        static void toJson(VariantConstRef src, VariantRef dst) {
            variantCopyFrom(getData(dst), getData(src), getPool(dst));
        }

        static ObjectRef fromJson(VariantRef src) {
            VariantData *data = getData(src);
            MemoryPool *pool = getPool(src);
            return ObjectRef(pool, data != 0 ? data->asObject() : 0);
        }

        static InvalidConversion<VariantConstRef, ObjectRef> fromJson(
                VariantConstRef);

        static bool checkJson(VariantConstRef) {
            return false;
        }

        static bool checkJson(VariantRef src) {
            VariantData *data = getData(src);
            return data && data->isObject();
        }
    };

    class ArrayRef;

    class ObjectRef;

    class VariantRef;

    template<typename T>
    struct VariantTo {
    };
    template<>
    struct VariantTo<ArrayRef> {
        typedef ArrayRef type;
    };
    template<>
    struct VariantTo<ObjectRef> {
        typedef ObjectRef type;
    };
    template<>
    struct VariantTo<VariantRef> {
        typedef VariantRef type;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
                                                                                                                        #  pragma warning(push)
#  pragma warning(disable : 4522)
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename TArray>
    class ElementProxy : public VariantOperators<ElementProxy<TArray> >,
                         public VariantShortcuts<ElementProxy<TArray> >,
                         public Visitable,
                         public VariantTag {
        typedef ElementProxy<TArray> this_type;
    public:
        typedef VariantRef variant_type;

        FORCE_INLINE ElementProxy(TArray array, size_t index)
                : _array(array), _index(index) {}

        FORCE_INLINE ElementProxy(const ElementProxy &src)
                : _array(src._array), _index(src._index) {}

        FORCE_INLINE this_type &operator=(const this_type &src) {
            getOrAddUpstreamElement().set(src.as<VariantConstRef>());
            return *this;
        }

        template<typename T>
        FORCE_INLINE this_type &operator=(const T &src) {
            getOrAddUpstreamElement().set(src);
            return *this;
        }

        template<typename T>
        FORCE_INLINE this_type &operator=(T *src) {
            getOrAddUpstreamElement().set(src);
            return *this;
        }

        FORCE_INLINE void clear() const {
            getUpstreamElement().clear();
        }

        FORCE_INLINE bool isNull() const {
            return getUpstreamElement().isNull();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<!is_same<T, char *>::value, T>::type as()
        const {
            return getUpstreamElement().template as<T>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
        ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
        as() const {
            return as<const char *>();
        }

        template<typename T>
        FORCE_INLINE operator T() const {
            return getUpstreamElement();
        }

        template<typename T>
        FORCE_INLINE bool is() const {
            return getUpstreamElement().template is<T>();
        }

        template<typename T>
        FORCE_INLINE typename VariantTo<T>::type to() const {
            return getOrAddUpstreamElement().template to<T>();
        }

        template<typename TValue>
        FORCE_INLINE bool set(const TValue &value) const {
            return getOrAddUpstreamElement().set(value);
        }

        template<typename TValue>
        FORCE_INLINE bool set(TValue *value) const {
            return getOrAddUpstreamElement().set(value);
        }

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return getUpstreamElement().accept(visitor);
        }

        FORCE_INLINE size_t size() const {
            return getUpstreamElement().size();
        }

        template<typename TNestedKey>
        VariantRef getMember(TNestedKey *key) const {
            return getUpstreamElement().getMember(key);
        }

        template<typename TNestedKey>
        VariantRef getMember(const TNestedKey &key) const {
            return getUpstreamElement().getMember(key);
        }

        template<typename TNestedKey>
        VariantRef getOrAddMember(TNestedKey *key) const {
            return getOrAddUpstreamElement().getOrAddMember(key);
        }

        template<typename TNestedKey>
        VariantRef getOrAddMember(const TNestedKey &key) const {
            return getOrAddUpstreamElement().getOrAddMember(key);
        }

        VariantRef addElement() const {
            return getOrAddUpstreamElement().addElement();
        }

        VariantRef getElement(size_t index) const {
            return getOrAddUpstreamElement().getElement(index);
        }

        VariantRef getOrAddElement(size_t index) const {
            return getOrAddUpstreamElement().getOrAddElement(index);
        }

        FORCE_INLINE void remove(size_t index) const {
            getUpstreamElement().remove(index);
        }

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
                TChar *key) const {
            getUpstreamElement().remove(key);
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
                const TString &key) const {
            getUpstreamElement().remove(key);
        }

    private:
        FORCE_INLINE VariantRef getUpstreamElement() const {
            return _array.getElement(_index);
        }

        FORCE_INLINE VariantRef getOrAddUpstreamElement() const {
            return _array.getOrAddElement(_index);
        }

        friend void convertToJson(const this_type &src, VariantRef dst) {
            dst.set(src.getUpstreamElement());
        }

        TArray _array;
        const size_t _index;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
#ifdef _MSC_VER
                                                                                                                        #  pragma warning(push)
#  pragma warning(disable : 4522)
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename TObject, typename TStringRef>
    class MemberProxy : public VariantOperators<MemberProxy<TObject, TStringRef> >,
                        public VariantShortcuts<MemberProxy<TObject, TStringRef> >,
                        public Visitable,
                        public VariantTag {
        typedef MemberProxy<TObject, TStringRef> this_type;
    public:
        typedef VariantRef variant_type;

        FORCE_INLINE MemberProxy(TObject variant, TStringRef key)
                : _object(variant), _key(key) {}

        FORCE_INLINE MemberProxy(const MemberProxy &src)
                : _object(src._object), _key(src._key) {}

        FORCE_INLINE operator VariantConstRef() const {
            return getUpstreamMember();
        }

        FORCE_INLINE this_type &operator=(const this_type &src) {
            getOrAddUpstreamMember().set(src);
            return *this;
        }

        template<typename TValue>
        FORCE_INLINE typename enable_if<!is_array<TValue>::value, this_type &>::type
        operator=(const TValue &src) {
            getOrAddUpstreamMember().set(src);
            return *this;
        }

        template<typename TChar>
        FORCE_INLINE this_type &operator=(TChar *src) {
            getOrAddUpstreamMember().set(src);
            return *this;
        }

        FORCE_INLINE void clear() const {
            getUpstreamMember().clear();
        }

        FORCE_INLINE bool isNull() const {
            return getUpstreamMember().isNull();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<!is_same<T, char *>::value, T>::type as()
        const {
            return getUpstreamMember().template as<T>();
        }

        template<typename T>
        FORCE_INLINE typename enable_if<is_same<T, char *>::value, const char *>::type
        ARDUINOJSON_DEPRECATED("Replace as<char*>() with as<const char*>()")
        as() const {
            return as<const char *>();
        }

        template<typename T>
        FORCE_INLINE operator T() const {
            return getUpstreamMember();
        }

        template<typename TValue>
        FORCE_INLINE bool is() const {
            return getUpstreamMember().template is<TValue>();
        }

        FORCE_INLINE size_t size() const {
            return getUpstreamMember().size();
        }

        FORCE_INLINE void remove(size_t index) const {
            getUpstreamMember().remove(index);
        }

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
                TChar *key) const {
            getUpstreamMember().remove(key);
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
                const TString &key) const {
            getUpstreamMember().remove(key);
        }

        template<typename TValue>
        FORCE_INLINE typename VariantTo<TValue>::type to() {
            return getOrAddUpstreamMember().template to<TValue>();
        }

        template<typename TValue>
        FORCE_INLINE bool set(const TValue &value) {
            return getOrAddUpstreamMember().set(value);
        }

        template<typename TChar>
        FORCE_INLINE bool set(TChar *value) {
            return getOrAddUpstreamMember().set(value);
        }

        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return getUpstreamMember().accept(visitor);
        }

        FORCE_INLINE VariantRef addElement() const {
            return getOrAddUpstreamMember().addElement();
        }

        FORCE_INLINE VariantRef getElement(size_t index) const {
            return getUpstreamMember().getElement(index);
        }

        FORCE_INLINE VariantRef getOrAddElement(size_t index) const {
            return getOrAddUpstreamMember().getOrAddElement(index);
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getMember(TChar *key) const {
            return getUpstreamMember().getMember(key);
        }

        template<typename TString>
        FORCE_INLINE VariantRef getMember(const TString &key) const {
            return getUpstreamMember().getMember(key);
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getOrAddMember(TChar *key) const {
            return getOrAddUpstreamMember().getOrAddMember(key);
        }

        template<typename TString>
        FORCE_INLINE VariantRef getOrAddMember(const TString &key) const {
            return getOrAddUpstreamMember().getOrAddMember(key);
        }

    private:
        FORCE_INLINE VariantRef getUpstreamMember() const {
            return _object.getMember(_key);
        }

        FORCE_INLINE VariantRef getOrAddUpstreamMember() const {
            return _object.getOrAddMember(_key);
        }

        friend void convertToJson(const this_type &src, VariantRef dst) {
            dst.set(src.getUpstreamMember());
        }

        TObject _object;
        TStringRef _key;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef _MSC_VER
#  pragma warning(pop)
#endif
namespace ARDUINOJSON_NAMESPACE {
    class JsonDocument : public Visitable {
    public:
        template<typename TVisitor>
        typename TVisitor::result_type accept(TVisitor &visitor) const {
            return getVariant().accept(visitor);
        }

        template<typename T>
        T as() {
            return getVariant().template as<T>();
        }

        template<typename T>
        T as() const {
            return getVariant().template as<T>();
        }

        void clear() {
            _pool.clear();
            _data.init();
        }

        template<typename T>
        bool is() {
            return getVariant().template is<T>();
        }

        template<typename T>
        bool is() const {
            return getVariant().template is<T>();
        }

        bool isNull() const {
            return getVariant().isNull();
        }

        size_t memoryUsage() const {
            return _pool.size();
        }

        bool overflowed() const {
            return _pool.overflowed();
        }

        size_t nesting() const {
            return _data.nesting();
        }

        size_t capacity() const {
            return _pool.capacity();
        }

        size_t size() const {
            return _data.size();
        }

        bool set(const JsonDocument &src) {
            return to<VariantRef>().set(src.as<VariantConstRef>());
        }

        template<typename T>
        typename enable_if<!is_base_of<JsonDocument, T>::value, bool>::type set(
                const T &src) {
            return to<VariantRef>().set(src);
        }

        template<typename T>
        typename VariantTo<T>::type to() {
            clear();
            return getVariant().template to<T>();
        }

        MemoryPool &memoryPool() {
            return _pool;
        }

        VariantData &data() {
            return _data;
        }

        ArrayRef createNestedArray() {
            return addElement().to<ArrayRef>();
        }

        template<typename TChar>
        ArrayRef createNestedArray(TChar *key) {
            return getOrAddMember(key).template to<ArrayRef>();
        }

        template<typename TString>
        ArrayRef createNestedArray(const TString &key) {
            return getOrAddMember(key).template to<ArrayRef>();
        }

        ObjectRef createNestedObject() {
            return addElement().to<ObjectRef>();
        }

        template<typename TChar>
        ObjectRef createNestedObject(TChar *key) {
            return getOrAddMember(key).template to<ObjectRef>();
        }

        template<typename TString>
        ObjectRef createNestedObject(const TString &key) {
            return getOrAddMember(key).template to<ObjectRef>();
        }

        template<typename TChar>
        bool containsKey(TChar *key) const {
            return !getMember(key).isUndefined();
        }

        template<typename TString>
        bool containsKey(const TString &key) const {
            return !getMember(key).isUndefined();
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value,
                MemberProxy<JsonDocument &, TString> >::type
        operator[](const TString &key) {
            return MemberProxy<JsonDocument &, TString>(*this, key);
        }

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value,
                MemberProxy<JsonDocument &, TChar *> >::type
        operator[](TChar *key) {
            return MemberProxy<JsonDocument &, TChar *>(*this, key);
        }

        template<typename TString>
        FORCE_INLINE
        typename enable_if<IsString<TString>::value, VariantConstRef>::type
        operator[](const TString &key) const {
            return getMember(key);
        }

        template<typename TChar>
        FORCE_INLINE
        typename enable_if<IsString<TChar *>::value, VariantConstRef>::type
        operator[](TChar *key) const {
            return getMember(key);
        }

        FORCE_INLINE ElementProxy<JsonDocument &> operator[](size_t index) {
            return ElementProxy<JsonDocument &>(*this, index);
        }

        FORCE_INLINE VariantConstRef operator[](size_t index) const {
            return getElement(index);
        }

        FORCE_INLINE VariantRef getElement(size_t index) {
            return VariantRef(&_pool, _data.getElement(index));
        }

        FORCE_INLINE VariantConstRef getElement(size_t index) const {
            return VariantConstRef(_data.getElement(index));
        }

        FORCE_INLINE VariantRef getOrAddElement(size_t index) {
            return VariantRef(&_pool, _data.getOrAddElement(index, &_pool));
        }

        template<typename TChar>
        FORCE_INLINE VariantConstRef getMember(TChar *key) const {
            return VariantConstRef(_data.getMember(adaptString(key)));
        }

        template<typename TString>
        FORCE_INLINE
        typename enable_if<IsString<TString>::value, VariantConstRef>::type
        getMember(const TString &key) const {
            return VariantConstRef(_data.getMember(adaptString(key)));
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getMember(TChar *key) {
            return VariantRef(&_pool, _data.getMember(adaptString(key)));
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value, VariantRef>::type
        getMember(const TString &key) {
            return VariantRef(&_pool, _data.getMember(adaptString(key)));
        }

        template<typename TChar>
        FORCE_INLINE VariantRef getOrAddMember(TChar *key) {
            return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
        }

        template<typename TString>
        FORCE_INLINE VariantRef getOrAddMember(const TString &key) {
            return VariantRef(&_pool, _data.getOrAddMember(adaptString(key), &_pool));
        }

        FORCE_INLINE VariantRef addElement() {
            return VariantRef(&_pool, _data.addElement(&_pool));
        }

        template<typename TValue>
        FORCE_INLINE bool add(const TValue &value) {
            return addElement().set(value);
        }

        template<typename TChar>
        FORCE_INLINE bool add(TChar *value) {
            return addElement().set(value);
        }

        FORCE_INLINE void remove(size_t index) {
            _data.remove(index);
        }

        template<typename TChar>
        FORCE_INLINE typename enable_if<IsString<TChar *>::value>::type remove(
                TChar *key) {
            _data.remove(adaptString(key));
        }

        template<typename TString>
        FORCE_INLINE typename enable_if<IsString<TString>::value>::type remove(
                const TString &key) {
            _data.remove(adaptString(key));
        }

        FORCE_INLINE operator VariantConstRef() const {
            return VariantConstRef(&_data);
        }

        bool operator==(VariantConstRef rhs) const {
            return getVariant() == rhs;
        }

        bool operator!=(VariantConstRef rhs) const {
            return getVariant() != rhs;
        }

    protected:
        JsonDocument() : _pool(0, 0) {
            _data.init();
        }

        JsonDocument(MemoryPool pool) : _pool(pool) {
            _data.init();
        }

        JsonDocument(char *buf, size_t capa) : _pool(buf, capa) {
            _data.init();
        }

        ~JsonDocument() {}

        void replacePool(MemoryPool pool) {
            _pool = pool;
        }

        VariantRef getVariant() {
            return VariantRef(&_pool, &_data);
        }

        VariantConstRef getVariant() const {
            return VariantConstRef(&_data);
        }

        MemoryPool _pool;
        VariantData _data;
    private:
        JsonDocument(const JsonDocument &);

        JsonDocument &operator=(const JsonDocument &);
    };

    inline void convertToJson(const JsonDocument &src, VariantRef dst) {
        dst.set(src.as<VariantConstRef>());
    }

    template<typename TAllocator>
    class AllocatorOwner {
    public:
        AllocatorOwner() {}

        AllocatorOwner(const AllocatorOwner &src) : _allocator(src._allocator) {}

        AllocatorOwner(TAllocator a) : _allocator(a) {}

        void *allocate(size_t size) {
            return _allocator.allocate(size);
        }

        void deallocate(void *ptr) {
            if (ptr)
                _allocator.deallocate(ptr);
        }

        void *reallocate(void *ptr, size_t new_size) {
            return _allocator.reallocate(ptr, new_size);
        }

        TAllocator &allocator() {
            return _allocator;
        }

    private:
        TAllocator _allocator;
    };

    template<typename TAllocator>
    class BasicJsonDocument : AllocatorOwner<TAllocator>, public JsonDocument {
    public:
        explicit BasicJsonDocument(size_t capa, TAllocator alloc = TAllocator())
                : AllocatorOwner<TAllocator>(alloc), JsonDocument(allocPool(capa)) {}

        BasicJsonDocument(const BasicJsonDocument &src)
                : AllocatorOwner<TAllocator>(src), JsonDocument() {
            copyAssignFrom(src);
        }

#if ARDUINOJSON_HAS_RVALUE_REFERENCES

        BasicJsonDocument(BasicJsonDocument &&src) : AllocatorOwner<TAllocator>(src) {
            moveAssignFrom(src);
        }

#endif

        BasicJsonDocument(const JsonDocument &src) {
            copyAssignFrom(src);
        }

        template<typename T>
        BasicJsonDocument(
                const T &src,
                typename enable_if<
                        is_same<T, VariantRef>::value || is_same<T, VariantConstRef>::value ||
                        is_same<T, ArrayRef>::value || is_same<T, ArrayConstRef>::value ||
                        is_same<T, ObjectRef>::value ||
                        is_same<T, ObjectConstRef>::value>::type * = 0)
                : JsonDocument(allocPool(src.memoryUsage())) {
            set(src);
        }

        BasicJsonDocument(VariantRef src)
                : JsonDocument(allocPool(src.memoryUsage())) {
            set(src);
        }

        ~BasicJsonDocument() {
            freePool();
        }

        BasicJsonDocument &operator=(const BasicJsonDocument &src) {
            copyAssignFrom(src);
            return *this;
        }

#if ARDUINOJSON_HAS_RVALUE_REFERENCES

        BasicJsonDocument &operator=(BasicJsonDocument &&src) {
            moveAssignFrom(src);
            return *this;
        }

#endif

        template<typename T>
        BasicJsonDocument &operator=(const T &src) {
            reallocPoolIfTooSmall(src.memoryUsage());
            set(src);
            return *this;
        }

        void shrinkToFit() {
            ptrdiff_t bytes_reclaimed = _pool.squash();
            if (bytes_reclaimed == 0)
                return;
            void *old_ptr = _pool.buffer();
            void *new_ptr = this->reallocate(old_ptr, _pool.capacity());
            ptrdiff_t ptr_offset =
                    static_cast<char *>(new_ptr) - static_cast<char *>(old_ptr);
            _pool.movePointers(ptr_offset);
            _data.movePointers(ptr_offset, ptr_offset - bytes_reclaimed);
        }

        bool garbageCollect() {
            BasicJsonDocument tmp(*this);
            if (!tmp.capacity())
                return false;
            tmp.set(*this);
            moveAssignFrom(tmp);
            return true;
        }

        using AllocatorOwner<TAllocator>::allocator;
    private:
        MemoryPool allocPool(size_t requiredSize) {
            size_t capa = addPadding(requiredSize);
            return MemoryPool(reinterpret_cast<char *>(this->allocate(capa)), capa);
        }

        void reallocPoolIfTooSmall(size_t requiredSize) {
            if (requiredSize <= capacity())
                return;
            freePool();
            replacePool(allocPool(addPadding(requiredSize)));
        }

        void freePool() {
            this->deallocate(memoryPool().buffer());
        }

        void copyAssignFrom(const JsonDocument &src) {
            reallocPoolIfTooSmall(src.capacity());
            set(src);
        }

        void moveAssignFrom(BasicJsonDocument &src) {
            freePool();
            _data = src._data;
            _pool = src._pool;
            src._data.setNull();
            src._pool = MemoryPool(0, 0);
        }
    };
}  // namespace ARDUINOJSON_NAMESPACE
#include <stdlib.h>

namespace ARDUINOJSON_NAMESPACE {
    struct DefaultAllocator {
        void *allocate(size_t size) {
            return malloc(size);
        }

        void deallocate(void *ptr) {
            free(ptr);
        }

        void *reallocate(void *ptr, size_t new_size) {
            return realloc(ptr, new_size);
        }
    };

    typedef BasicJsonDocument<DefaultAllocator> DynamicJsonDocument;

    template<size_t desiredCapacity>
    class StaticJsonDocument : public JsonDocument {
        static const size_t _capacity =
                AddPadding<Max<1, desiredCapacity>::value>::value;
    public:
        StaticJsonDocument() : JsonDocument(_buffer, _capacity) {}

        StaticJsonDocument(const StaticJsonDocument &src)
                : JsonDocument(_buffer, _capacity) {
            set(src);
        }

        template<typename T>
        StaticJsonDocument(const T &src,
                           typename enable_if<IsVisitable<T>::value>::type * = 0)
                : JsonDocument(_buffer, _capacity) {
            set(src);
        }

        StaticJsonDocument(VariantRef src) : JsonDocument(_buffer, _capacity) {
            set(src);
        }

        StaticJsonDocument operator=(const StaticJsonDocument &src) {
            set(src);
            return *this;
        }

        template<typename T>
        StaticJsonDocument operator=(const T &src) {
            set(src);
            return *this;
        }

        void garbageCollect() {
            StaticJsonDocument tmp(*this);
            set(tmp);
        }

    private:
        char _buffer[_capacity];
    };

    template<typename TArray>
    inline ArrayRef ArrayShortcuts<TArray>::createNestedArray() const {
        return impl()->addElement().template to<ArrayRef>();
    }

    template<typename TArray>
    inline ObjectRef ArrayShortcuts<TArray>::createNestedObject() const {
        return impl()->addElement().template to<ObjectRef>();
    }

    template<typename TArray>
    inline ElementProxy<TArray> ArrayShortcuts<TArray>::operator[](
            size_t index) const {
        return ElementProxy<TArray>(*impl(), index);
    }

    template<typename TResult>
    struct Visitor {
        typedef TResult result_type;

        TResult visitArray(const CollectionData &) {
            return TResult();
        }

        TResult visitBoolean(bool) {
            return TResult();
        }

        TResult visitFloat(Float) {
            return TResult();
        }

        TResult visitSignedInteger(Integer) {
            return TResult();
        }

        TResult visitNull() {
            return TResult();
        }

        TResult visitObject(const CollectionData &) {
            return TResult();
        }

        TResult visitUnsignedInteger(UInt) {
            return TResult();
        }

        TResult visitRawJson(const char *, size_t) {
            return TResult();
        }

        TResult visitString(const char *) {
            return TResult();
        }
    };

    template<typename T, size_t N, typename TDestination>
    inline typename enable_if<!is_array<T>::value &&
                              !is_base_of<JsonDocument, TDestination>::value,
            bool>::type
    copyArray(T (&src)[N], const TDestination &dst) {
        return copyArray(src, N, dst);
    }

    template<typename T, size_t N>
    inline bool copyArray(T (&src)[N], JsonDocument &dst) {
        return copyArray(src, dst.to<ArrayRef>());
    }

    template<typename T, typename TDestination>
    inline typename enable_if<!is_array<T>::value &&
                              !is_base_of<JsonDocument, TDestination>::value,
            bool>::type
    copyArray(T *src, size_t len, const TDestination &dst) {
        bool ok = true;
        for (size_t i = 0; i < len; i++) {
            ok &= dst.add(src[i]);
        }
        return ok;
    }

    template<typename T>
    inline bool copyArray(T *src, size_t len, JsonDocument &dst) {
        return copyArray(src, len, dst.to<ArrayRef>());
    }

    template<typename T, size_t N1, size_t N2, typename TDestination>
    inline typename enable_if<!is_base_of<JsonDocument, TDestination>::value,
            bool>::type
    copyArray(T (&src)[N1][N2], const TDestination &dst) {
        bool ok = true;
        for (size_t i = 0; i < N1; i++) {
            ArrayRef nestedArray = dst.createNestedArray();
            for (size_t j = 0; j < N2; j++) {
                ok &= nestedArray.add(src[i][j]);
            }
        }
        return ok;
    }

    template<typename T, size_t N1, size_t N2>
    inline bool copyArray(T (&src)[N1][N2], JsonDocument &dst) {
        return copyArray(src, dst.to<ArrayRef>());
    }

    template<typename T>
    class ArrayCopier1D : public Visitor<size_t> {
    public:
        ArrayCopier1D(T *destination, size_t capacity)
                : _destination(destination), _capacity(capacity) {}

        size_t visitArray(const CollectionData &array) {
            size_t size = 0;
            VariantSlot *slot = array.head();
            while (slot != 0 && size < _capacity) {
                _destination[size++] =
                        Converter<T>::fromJson(VariantConstRef(slot->data()));
                slot = slot->next();
            }
            return size;
        }

    private:
        T *_destination;
        size_t _capacity;
    };

    template<typename T, size_t N1, size_t N2>
    class ArrayCopier2D : public Visitor<void> {
    public:
        ArrayCopier2D(T (*destination)[N1][N2]) : _destination(destination) {}

        void visitArray(const CollectionData &array) {
            VariantSlot *slot = array.head();
            size_t n = 0;
            while (slot != 0 && n < N1) {
                ArrayCopier1D<T> copier((*_destination)[n++], N2);
                variantAccept(slot->data(), copier);
                slot = slot->next();
            }
        }

    private:
        T (*_destination)[N1][N2];
        size_t _capacity1, _capacity2;
    };

    template<typename TSource, typename T, size_t N>
    inline typename enable_if<!is_array<T>::value, size_t>::type copyArray(
            const TSource &src, T (&dst)[N]) {
        return copyArray(src, dst, N);
    }

    template<typename TSource, typename T>
    inline size_t copyArray(const TSource &src, T *dst, size_t len) {
        ArrayCopier1D<T> copier(dst, len);
        return src.accept(copier);
    }

    template<typename TSource, typename T, size_t N1, size_t N2>
    inline void copyArray(const TSource &src, T (&dst)[N1][N2]) {
        ArrayCopier2D<T, N1, N2> copier(&dst);
        src.accept(copier);
    }

    inline bool variantEquals(const VariantData *a, const VariantData *b) {
        return variantCompare(a, b) == COMPARE_RESULT_EQUAL;
    }

    inline VariantSlot *CollectionData::addSlot(MemoryPool *pool) {
        VariantSlot *slot = pool->allocVariant();
        if (!slot)
            return 0;
        if (_tail) {
            _tail->setNextNotNull(slot);
            _tail = slot;
        } else {
            _head = slot;
            _tail = slot;
        }
        slot->clear();
        return slot;
    }

    inline VariantData *CollectionData::addElement(MemoryPool *pool) {
        return slotData(addSlot(pool));
    }

    template<typename TAdaptedString>
    inline VariantData *CollectionData::addMember(TAdaptedString key,
                                                  MemoryPool *pool) {
        VariantSlot *slot = addSlot(pool);
        if (!slotSetKey(slot, key, pool)) {
            removeSlot(slot);
            return 0;
        }
        return slot->data();
    }

    inline void CollectionData::clear() {
        _head = 0;
        _tail = 0;
    }

    template<typename TAdaptedString>
    inline bool CollectionData::containsKey(const TAdaptedString &key) const {
        return getSlot(key) != 0;
    }

    inline bool CollectionData::copyFrom(const CollectionData &src,
                                         MemoryPool *pool) {
        clear();
        for (VariantSlot *s = src._head; s; s = s->next()) {
            VariantData *var;
            if (s->key() != 0) {
                if (s->ownsKey())
                    var = addMember(adaptString(const_cast<char *>(s->key())), pool);
                else
                    var = addMember(adaptString(s->key()), pool);
            } else {
                var = addElement(pool);
            }
            if (!var)
                return false;
            if (!var->copyFrom(*s->data(), pool))
                return false;
        }
        return true;
    }

    inline bool CollectionData::equalsObject(const CollectionData &other) const {
        size_t count = 0;
        for (VariantSlot *slot = _head; slot; slot = slot->next()) {
            VariantData *v1 = slot->data();
            VariantData *v2 = other.getMember(adaptString(slot->key()));
            if (!variantEquals(v1, v2))
                return false;
            count++;
        }
        return count == other.size();
    }

    inline bool CollectionData::equalsArray(const CollectionData &other) const {
        VariantSlot *s1 = _head;
        VariantSlot *s2 = other._head;
        for (;;) {
            if (s1 == s2)
                return true;
            if (!s1 || !s2)
                return false;
            if (!variantEquals(s1->data(), s2->data()))
                return false;
            s1 = s1->next();
            s2 = s2->next();
        }
    }

    template<typename TAdaptedString>
    inline VariantSlot *CollectionData::getSlot(TAdaptedString key) const {
        VariantSlot *slot = _head;
        while (slot) {
            if (key.compare(slot->key()) == 0)
                break;
            slot = slot->next();
        }
        return slot;
    }

    inline VariantSlot *CollectionData::getSlot(size_t index) const {
        if (!_head)
            return 0;
        return _head->next(index);
    }

    inline VariantSlot *CollectionData::getPreviousSlot(VariantSlot *target) const {
        VariantSlot *current = _head;
        while (current) {
            VariantSlot *next = current->next();
            if (next == target)
                return current;
            current = next;
        }
        return 0;
    }

    template<typename TAdaptedString>
    inline VariantData *CollectionData::getMember(TAdaptedString key) const {
        VariantSlot *slot = getSlot(key);
        return slot ? slot->data() : 0;
    }

    template<typename TAdaptedString>
    inline VariantData *CollectionData::getOrAddMember(TAdaptedString key,
                                                       MemoryPool *pool) {
        if (key.isNull())
            return 0;
        VariantSlot *slot = getSlot(key);
        if (slot)
            return slot->data();
        return addMember(key, pool);
    }

    inline VariantData *CollectionData::getElement(size_t index) const {
        VariantSlot *slot = getSlot(index);
        return slot ? slot->data() : 0;
    }

    inline VariantData *CollectionData::getOrAddElement(size_t index,
                                                        MemoryPool *pool) {
        VariantSlot *slot = _head;
        while (slot && index > 0) {
            slot = slot->next();
            index--;
        }
        if (!slot)
            index++;
        while (index > 0) {
            slot = addSlot(pool);
            index--;
        }
        return slotData(slot);
    }

    inline void CollectionData::removeSlot(VariantSlot *slot) {
        if (!slot)
            return;
        VariantSlot *prev = getPreviousSlot(slot);
        VariantSlot *next = slot->next();
        if (prev)
            prev->setNext(next);
        else
            _head = next;
        if (!next)
            _tail = prev;
    }

    inline void CollectionData::removeElement(size_t index) {
        removeSlot(getSlot(index));
    }

    inline size_t CollectionData::memoryUsage() const {
        size_t total = 0;
        for (VariantSlot *s = _head; s; s = s->next()) {
            total += sizeof(VariantSlot) + s->data()->memoryUsage();
            if (s->ownsKey())
                total += strlen(s->key()) + 1;
        }
        return total;
    }

    inline size_t CollectionData::nesting() const {
        size_t maxChildNesting = 0;
        for (VariantSlot *s = _head; s; s = s->next()) {
            size_t childNesting = s->data()->nesting();
            if (childNesting > maxChildNesting)
                maxChildNesting = childNesting;
        }
        return maxChildNesting + 1;
    }

    inline size_t CollectionData::size() const {
        return slotSize(_head);
    }

    template<typename T>
    inline void movePointer(T *&p, ptrdiff_t offset) {
        if (!p)
            return;
        p = reinterpret_cast<T *>(
                reinterpret_cast<void *>(reinterpret_cast<char *>(p) + offset));
        ARDUINOJSON_ASSERT(isAligned(p));
    }

    inline void CollectionData::movePointers(ptrdiff_t stringDistance,
                                             ptrdiff_t variantDistance) {
        movePointer(_head, variantDistance);
        movePointer(_tail, variantDistance);
        for (VariantSlot *slot = _head; slot; slot = slot->next())
            slot->movePointers(stringDistance, variantDistance);
    }

    template<typename TObject>
    template<typename TString>
    inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(
            const TString &key) const {
        return impl()->getOrAddMember(key).template to<ArrayRef>();
    }

    template<typename TObject>
    template<typename TChar>
    inline ArrayRef ObjectShortcuts<TObject>::createNestedArray(TChar *key) const {
        return impl()->getOrAddMember(key).template to<ArrayRef>();
    }

    template<typename TObject>
    template<typename TString>
    inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
            const TString &key) const {
        return impl()->getOrAddMember(key).template to<ObjectRef>();
    }

    template<typename TObject>
    template<typename TChar>
    inline ObjectRef ObjectShortcuts<TObject>::createNestedObject(
            TChar *key) const {
        return impl()->getOrAddMember(key).template to<ObjectRef>();
    }

    template<typename TObject>
    template<typename TString>
    inline typename enable_if<IsString<TString>::value, bool>::type
    ObjectShortcuts<TObject>::containsKey(const TString &key) const {
        return !impl()->getMember(key).isUndefined();
    }

    template<typename TObject>
    template<typename TChar>
    inline typename enable_if<IsString<TChar *>::value, bool>::type
    ObjectShortcuts<TObject>::containsKey(TChar *key) const {
        return !impl()->getMember(key).isUndefined();
    }

    template<typename TObject>
    template<typename TString>
    inline typename enable_if<IsString<TString *>::value,
            MemberProxy<TObject, TString *> >::type
    ObjectShortcuts<TObject>::operator[](TString *key) const {
        return MemberProxy<TObject, TString *>(*impl(), key);
    }

    template<typename TObject>
    template<typename TString>
    inline typename enable_if<IsString<TString>::value,
            MemberProxy<TObject, TString> >::type
    ObjectShortcuts<TObject>::operator[](const TString &key) const {
        return MemberProxy<TObject, TString>(*impl(), key);
    }
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
#endif
#if ARDUINOJSON_ENABLE_STD_STRING
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename>
    struct IsWriteableString : false_type {
    };
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
    template<>
    struct IsWriteableString<::String> : true_type {
    };
#endif
#if ARDUINOJSON_ENABLE_STD_STRING
                                                                                                                            template <typename TCharTraits, typename TAllocator>
struct IsWriteableString<std::basic_string<char, TCharTraits, TAllocator> >
    : true_type {};
#endif

    template<typename T, typename Enable>
    struct Converter {
        static void toJson(const T &src, VariantRef dst) {
            convertToJson(src, dst); // Error here? See https://arduinojson.org/v6/unsupported-set/
        }

        static T fromJson(VariantConstRef src) {
            T result; // Error here? See https://arduinojson.org/v6/non-default-constructible/
            convertFromJson(src, result);  // Error here? See https://arduinojson.org/v6/unsupported-as/
            return result;
        }

        static bool checkJson(VariantConstRef src) {
            T dummy;
            return canConvertFromJson(src, dummy);  // Error here? See https://arduinojson.org/v6/unsupported-is/
        }
    };

    template<typename T>
    struct Converter<
            T, typename enable_if<is_integral<T>::value && !is_same<bool, T>::value &&
                                  !is_same<char, T>::value>::type> {
        static void toJson(T src, VariantRef dst) {
            VariantData *data = getData(dst);
            ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
            if (data)
                data->setInteger(src);
        }

        static T fromJson(VariantConstRef src) {
            ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
            const VariantData *data = getData(src);
            return data ? data->asIntegral<T>() : T();
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isInteger<T>();
        }
    };

    template<typename T>
    struct Converter<T, typename enable_if<is_enum<T>::value>::type> {
        static void toJson(T src, VariantRef dst) {
            dst.set(static_cast<Integer>(src));
        }

        static T fromJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data ? static_cast<T>(data->asIntegral<int>()) : T();
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isInteger<int>();
        }
    };

    template<>
    struct Converter<bool> {
        static void toJson(bool src, VariantRef dst) {
            VariantData *data = getData(dst);
            if (data)
                data->setBoolean(src);
        }

        static bool fromJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data ? data->asBoolean() : false;
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isBoolean();
        }
    };

    template<typename T>
    struct Converter<T, typename enable_if<is_floating_point<T>::value>::type> {
        static void toJson(T src, VariantRef dst) {
            VariantData *data = getData(dst);
            if (data)
                data->setFloat(static_cast<Float>(src));
        }

        static T fromJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data ? data->asFloat<T>() : false;
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isFloat();
        }
    };

    template<>
    struct Converter<const char *> {
        static void toJson(const char *src, VariantRef dst) {
            variantSetString(getData(dst), adaptString(src), getPool(dst));
        }

        static const char *fromJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data ? data->asString() : 0;
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data && data->isString();
        }
    };

    template<typename T>
    inline typename enable_if<IsString<T>::value, bool>::type convertToJson(
            const T &src, VariantRef dst) {
        VariantData *data = getData(dst);
        MemoryPool *pool = getPool(dst);
        return variantSetString(data, adaptString(src), pool);
    }

    template<typename T>
    inline typename enable_if<IsWriteableString<T>::value>::type convertFromJson(
            VariantConstRef src, T &dst) {
        const VariantData *data = getData(src);
        const char *cstr = data != 0 ? data->asString() : 0;
        if (cstr)
            dst = cstr;
        else
            serializeJson(src, dst);
    }

    template<typename T>
    inline typename enable_if<IsWriteableString<T>::value, bool>::type
    canConvertFromJson(VariantConstRef src, const T &) {
        const VariantData *data = getData(src);
        return data && data->isString();
    }

    template<>
    struct Converter<SerializedValue<const char *> > {
        static void toJson(SerializedValue<const char *> src, VariantRef dst) {
            VariantData *data = getData(dst);
            if (data)
                data->setLinkedRaw(src);
        }
    };

    template<typename T>
    struct Converter<SerializedValue<T>,
            typename enable_if<!is_same<const char *, T>::value>::type> {
        static void toJson(SerializedValue<T> src, VariantRef dst) {
            VariantData *data = getData(dst);
            MemoryPool *pool = getPool(dst);
            if (data)
                data->setOwnedRaw(src, pool);
        }
    };

#if ARDUINOJSON_HAS_NULLPTR

    template<>
    struct Converter<decltype(nullptr)> {
        static void toJson(decltype(nullptr), VariantRef dst) {
            variantSetNull(getData(dst));
        }

        static decltype(nullptr) fromJson(VariantConstRef) {
            return nullptr;
        }

        static bool checkJson(VariantConstRef src) {
            const VariantData *data = getData(src);
            return data == 0 || data->isNull();
        }
    };

#endif
#if ARDUINOJSON_ENABLE_ARDUINO_STREAM

    class MemoryPoolPrint : public Print {
    public:
        MemoryPoolPrint(MemoryPool *pool) : _pool(pool), _size(0) {
            pool->getFreeZone(&_string, &_capacity);
        }

        const char *c_str() {
            _string[_size++] = 0;
            ARDUINOJSON_ASSERT(_size <= _capacity);
            return _pool->saveStringFromFreeZone(_size);
        }

        size_t write(uint8_t c) {
            if (_size >= _capacity)
                return 0;
            _string[_size++] = char(c);
            return 1;
        }

        size_t write(const uint8_t *buffer, size_t size) {
            if (_size + size >= _capacity) {
                _size = _capacity;  // mark as overflowed
                return 0;
            }
            memcpy(&_string[_size], buffer, size);
            _size += size;
            return size;
        }

        bool overflowed() const {
            return _size >= _capacity;
        }

    private:
        MemoryPool *_pool;
        size_t _size;
        char *_string;
        size_t _capacity;
    };

    inline void convertToJson(const ::Printable &src, VariantRef dst) {
        MemoryPool *pool = getPool(dst);
        VariantData *data = getData(dst);
        if (!pool || !data)
            return;
        MemoryPoolPrint print(pool);
        src.printTo(print);
        if (print.overflowed()) {
            pool->markAsOverflowed();
            data->setNull();
            return;
        }
        data->setStringPointer(print.c_str(), storage_policies::store_by_copy());
    }

#endif
#if ARDUINOJSON_ENABLE_STRING_VIEW
                                                                                                                            inline void convertFromJson(VariantConstRef src, std::string_view& dst) {
  const char* str = src.as<const char*>();
  if (str)  // the standard doesn't allow passing null to the constructor
    dst = std::string_view(str);
}
inline bool canConvertFromJson(VariantConstRef src, const std::string_view&) {
  return src.is<const char*>();
}
#endif

    class CollectionData;

    struct ComparerBase : Visitor<CompareResult> {
    };
    template<typename T, typename Enable = void>
    struct Comparer;

    template<typename T>
    struct Comparer<T, typename enable_if<IsString<T>::value>::type>
            : ComparerBase {
        T rhs;

        explicit Comparer(T value) : rhs(value) {}

        CompareResult visitString(const char *lhs) {
            int i = adaptString(rhs).compare(lhs);
            if (i < 0)
                return COMPARE_RESULT_GREATER;
            else if (i > 0)
                return COMPARE_RESULT_LESS;
            else
                return COMPARE_RESULT_EQUAL;
        }

        CompareResult visitNull() {
            if (adaptString(rhs).isNull())
                return COMPARE_RESULT_EQUAL;
            else
                return COMPARE_RESULT_DIFFER;
        }
    };

    template<typename T>
    struct Comparer<T, typename enable_if<is_integral<T>::value ||
                                          is_floating_point<T>::value>::type>
            : ComparerBase {
        T rhs;

        explicit Comparer(T value) : rhs(value) {}

        CompareResult visitFloat(Float lhs) {
            return arithmeticCompare(lhs, rhs);
        }

        CompareResult visitSignedInteger(Integer lhs) {
            return arithmeticCompare(lhs, rhs);
        }

        CompareResult visitUnsignedInteger(UInt lhs) {
            return arithmeticCompare(lhs, rhs);
        }

        CompareResult visitBoolean(bool lhs) {
            return visitUnsignedInteger(static_cast<UInt>(lhs));
        }
    };

    struct NullComparer : ComparerBase {
        CompareResult visitNull() {
            return COMPARE_RESULT_EQUAL;
        }
    };

#if ARDUINOJSON_HAS_NULLPTR

    template<>
    struct Comparer<decltype(nullptr), void> : NullComparer {
        explicit Comparer(decltype(nullptr)) : NullComparer() {}
    };

#endif

    struct ArrayComparer : ComparerBase {
        const CollectionData *_rhs;

        explicit ArrayComparer(const CollectionData &rhs) : _rhs(&rhs) {}

        CompareResult visitArray(const CollectionData &lhs) {
            if (lhs.equalsArray(*_rhs))
                return COMPARE_RESULT_EQUAL;
            else
                return COMPARE_RESULT_DIFFER;
        }
    };

    struct ObjectComparer : ComparerBase {
        const CollectionData *_rhs;

        explicit ObjectComparer(const CollectionData &rhs) : _rhs(&rhs) {}

        CompareResult visitObject(const CollectionData &lhs) {
            if (lhs.equalsObject(*_rhs))
                return COMPARE_RESULT_EQUAL;
            else
                return COMPARE_RESULT_DIFFER;
        }
    };

    struct RawComparer : ComparerBase {
        const char *_rhsData;
        size_t _rhsSize;

        explicit RawComparer(const char *rhsData, size_t rhsSize)
                : _rhsData(rhsData), _rhsSize(rhsSize) {}

        CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
            size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
            int n = memcmp(lhsData, _rhsData, size);
            if (n < 0)
                return COMPARE_RESULT_LESS;
            else if (n > 0)
                return COMPARE_RESULT_GREATER;
            else
                return COMPARE_RESULT_EQUAL;
        }
    };

    template<typename T>
    struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
            : ComparerBase {
        T rhs;

        explicit Comparer(T value) : rhs(value) {}

        CompareResult visitArray(const CollectionData &lhs) {
            ArrayComparer comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitObject(const CollectionData &lhs) {
            ObjectComparer comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitFloat(Float lhs) {
            Comparer<Float> comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitString(const char *lhs) {
            Comparer<const char *> comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitRawJson(const char *lhsData, size_t lhsSize) {
            RawComparer comparer(lhsData, lhsSize);
            return accept(comparer);
        }

        CompareResult visitSignedInteger(Integer lhs) {
            Comparer<Integer> comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitUnsignedInteger(UInt lhs) {
            Comparer<UInt> comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitBoolean(bool lhs) {
            Comparer<bool> comparer(lhs);
            return accept(comparer);
        }

        CompareResult visitNull() {
            NullComparer comparer;
            return accept(comparer);
        }

    private:
        template<typename TComparer>
        CompareResult accept(TComparer &comparer) {
            CompareResult reversedResult = rhs.accept(comparer);
            switch (reversedResult) {
                case COMPARE_RESULT_GREATER:
                    return COMPARE_RESULT_LESS;
                case COMPARE_RESULT_LESS:
                    return COMPARE_RESULT_GREATER;
                default:
                    return reversedResult;
            }
        }
    };

    template<typename T1, typename T2>
    CompareResult compare(const T1 &lhs, const T2 &rhs) {
        Comparer<T2> comparer(rhs);
        return lhs.accept(comparer);
    }

    inline int variantCompare(const VariantData *a, const VariantData *b) {
        return compare(VariantConstRef(a), VariantConstRef(b));
    }

#ifndef isnan

    template<typename T>
    bool isnan(T x) {
        return x != x;
    }

#endif
#ifndef isinf

    template<typename T>
    bool isinf(T x) {
        return x != 0.0 && x * 2 == x;
    }

#endif
    template<typename T, typename F>
    struct alias_cast_t {
        union {
            F raw;
            T data;
        };
    };

    template<typename T, typename F>
    T alias_cast(F raw_data) {
        alias_cast_t<T, F> ac;
        ac.raw = raw_data;
        return ac.data;
    }
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_PROGMEM
namespace ARDUINOJSON_NAMESPACE {
    template<typename T>
    typename enable_if<is_pointer<T>::value, T>::type pgm_read(const void *p) {
        return reinterpret_cast<T>(pgm_read_ptr(p));
    }

    template<typename T>
    typename enable_if<is_floating_point<T>::value &&
                       sizeof(T) == sizeof(float),  // on AVR sizeof(double) ==
            T>::type
    pgm_read(const void *p) {
        return pgm_read_float(p);
    }

    template<typename T>
    typename enable_if<is_same<T, uint32_t>::value, T>::type pgm_read(
            const void *p) {
        return pgm_read_dword(p);
    }
}  // namespace ARDUINOJSON_NAMESPACE
#  ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY
#    define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \
      static type const name[] PROGMEM = value;
#  endif
#  ifndef ARDUINOJSON_READ_STATIC_ARRAY
#    define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) \
      pgm_read<type>(name + index)
#  endif
#else  // i.e. ARDUINOJSON_ENABLE_PROGMEM == 0
                                                                                                                        #  ifndef ARDUINOJSON_DEFINE_STATIC_ARRAY
#    define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value) \
      static type const name[] = value;
#  endif
#  ifndef ARDUINOJSON_READ_STATIC_ARRAY
#    define ARDUINOJSON_READ_STATIC_ARRAY(type, name, index) name[index]
#  endif
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<typename T, size_t = sizeof(T)>
    struct FloatTraits {
    };

    template<typename T>
    struct FloatTraits<T, 8 /*64bits*/> {
        typedef uint64_t mantissa_type;
        static const short mantissa_bits = 52;
        static const mantissa_type mantissa_max =
                (mantissa_type(1) << mantissa_bits) - 1;
        typedef int16_t exponent_type;
        static const exponent_type exponent_max = 308;

        template<typename TExponent>
        static T make_float(T m, TExponent e) {
            if (e > 0) {
                for (uint8_t index = 0; e != 0; index++) {
                    if (e & 1)
                        m *= positiveBinaryPowerOfTen(index);
                    e >>= 1;
                }
            } else {
                e = TExponent(-e);
                for (uint8_t index = 0; e != 0; index++) {
                    if (e & 1)
                        m *= negativeBinaryPowerOfTen(index);
                    e >>= 1;
                }
            }
            return m;
        }

        static T positiveBinaryPowerOfTen(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(  //
                    uint32_t, factors,
                    ARDUINOJSON_EXPAND18({
                                                 0x40240000, 0x00000000,  // 1e1
                                                 0x40590000, 0x00000000,  // 1e2
                                                 0x40C38800, 0x00000000,  // 1e4
                                                 0x4197D784, 0x00000000,  // 1e8
                                                 0x4341C379, 0x37E08000,  // 1e16
                                                 0x4693B8B5, 0xB5056E17,  // 1e32
                                                 0x4D384F03, 0xE93FF9F5,  // 1e64
                                                 0x5A827748, 0xF9301D32,  // 1e128
                                                 0x75154FDD, 0x7F73BF3C   // 1e256
                                         }));
            return forge(
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index),
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1));
        }

        static T negativeBinaryPowerOfTen(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(  //
                    uint32_t, factors,
                    ARDUINOJSON_EXPAND18({
                                                 0x3FB99999, 0x9999999A,  // 1e-1
                                                 0x3F847AE1, 0x47AE147B,  // 1e-2
                                                 0x3F1A36E2, 0xEB1C432D,  // 1e-4
                                                 0x3E45798E, 0xE2308C3A,  // 1e-8
                                                 0x3C9CD2B2, 0x97D889BC,  // 1e-16
                                                 0x3949F623, 0xD5A8A733,  // 1e-32
                                                 0x32A50FFD, 0x44F4A73D,  // 1e-64
                                                 0x255BBA08, 0xCF8C979D,  // 1e-128
                                                 0x0AC80628, 0x64AC6F43   // 1e-256
                                         }));
            return forge(
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index),
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1));
        }

        static T negativeBinaryPowerOfTenPlusOne(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(  //
                    uint32_t, factors,
                    ARDUINOJSON_EXPAND18({
                                                 0x3FF00000, 0x00000000,  // 1e0
                                                 0x3FB99999, 0x9999999A,  // 1e-1
                                                 0x3F50624D, 0xD2F1A9FC,  // 1e-3
                                                 0x3E7AD7F2, 0x9ABCAF48,  // 1e-7
                                                 0x3CD203AF, 0x9EE75616,  // 1e-15
                                                 0x398039D6, 0x65896880,  // 1e-31
                                                 0x32DA53FC, 0x9631D10D,  // 1e-63
                                                 0x25915445, 0x81B7DEC2,  // 1e-127
                                                 0x0AFE07B2, 0x7DD78B14   // 1e-255
                                         }));
            return forge(
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index),
                    ARDUINOJSON_READ_STATIC_ARRAY(uint32_t, factors, 2 * index + 1));
        }

        static T nan() {
            return forge(0x7ff80000, 0x00000000);
        }

        static T inf() {
            return forge(0x7ff00000, 0x00000000);
        }

        static T highest() {
            return forge(0x7FEFFFFF, 0xFFFFFFFF);
        }

        static T lowest() {
            return forge(0xFFEFFFFF, 0xFFFFFFFF);
        }

        static T forge(uint32_t msb, uint32_t lsb) {
            return alias_cast<T>((uint64_t(msb) << 32) | lsb);
        }
    };

    template<typename T>
    struct FloatTraits<T, 4 /*32bits*/> {
        typedef uint32_t mantissa_type;
        static const short mantissa_bits = 23;
        static const mantissa_type mantissa_max =
                (mantissa_type(1) << mantissa_bits) - 1;
        typedef int8_t exponent_type;
        static const exponent_type exponent_max = 38;

        template<typename TExponent>
        static T make_float(T m, TExponent e) {
            if (e > 0) {
                for (uint8_t index = 0; e != 0; index++) {
                    if (e & 1)
                        m *= positiveBinaryPowerOfTen(index);
                    e >>= 1;
                }
            } else {
                e = -e;
                for (uint8_t index = 0; e != 0; index++) {
                    if (e & 1)
                        m *= negativeBinaryPowerOfTen(index);
                    e >>= 1;
                }
            }
            return m;
        }

        static T positiveBinaryPowerOfTen(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(
                    T, factors,
                    ARDUINOJSON_EXPAND6({1e1f, 1e2f, 1e4f, 1e8f, 1e16f, 1e32f}));
            return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index);
        }

        static T negativeBinaryPowerOfTen(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(
                    T, factors,
                    ARDUINOJSON_EXPAND6({1e-1f, 1e-2f, 1e-4f, 1e-8f, 1e-16f, 1e-32f}));
            return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index);
        }

        static T negativeBinaryPowerOfTenPlusOne(int index) {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(
                    T, factors,
                    ARDUINOJSON_EXPAND6({1e0f, 1e-1f, 1e-3f, 1e-7f, 1e-15f, 1e-31f}));
            return ARDUINOJSON_READ_STATIC_ARRAY(T, factors, index);
        }

        static T forge(uint32_t bits) {
            return alias_cast<T>(bits);
        }

        static T nan() {
            return forge(0x7fc00000);
        }

        static T inf() {
            return forge(0x7f800000);
        }

        static T highest() {
            return forge(0x7f7fffff);
        }

        static T lowest() {
            return forge(0xFf7fffff);
        }
    };

#ifndef isdigit

    inline bool isdigit(char c) {
        return '0' <= c && c <= '9';
    }

#endif

    inline bool issign(char c) {
        return '-' == c || c == '+';
    }

    template<typename A, typename B>
    struct choose_largest : conditional<(sizeof(A) > sizeof(B)), A, B> {
    };

    inline bool parseNumber(const char *s, VariantData &result) {
        typedef FloatTraits<Float> traits;
        typedef choose_largest<traits::mantissa_type, UInt>::type mantissa_t;
        typedef traits::exponent_type exponent_t;
        ARDUINOJSON_ASSERT(s != 0);
        bool is_negative = false;
        switch (*s) {
            case '-':
                is_negative = true;
                s++;
                break;
            case '+':
                s++;
                break;
        }
#if ARDUINOJSON_ENABLE_NAN
                                                                                                                                if (*s == 'n' || *s == 'N') {
    result.setFloat(traits::nan());
    return true;
  }
#endif
#if ARDUINOJSON_ENABLE_INFINITY
                                                                                                                                if (*s == 'i' || *s == 'I') {
    result.setFloat(is_negative ? -traits::inf() : traits::inf());
    return true;
  }
#endif
        if (!isdigit(*s) && *s != '.')
            return false;
        mantissa_t mantissa = 0;
        exponent_t exponent_offset = 0;
        const mantissa_t maxUint = UInt(-1);
        while (isdigit(*s)) {
            uint8_t digit = uint8_t(*s - '0');
            if (mantissa > maxUint / 10)
                break;
            mantissa *= 10;
            if (mantissa > maxUint - digit)
                break;
            mantissa += digit;
            s++;
        }
        if (*s == '\0') {
            if (is_negative) {
                const mantissa_t sintMantissaMax = mantissa_t(1)
                        << (sizeof(Integer) * 8 - 1);
                if (mantissa <= sintMantissaMax) {
                    result.setInteger(Integer(~mantissa + 1));
                    return true;
                }
            } else {
                result.setInteger(UInt(mantissa));
                return true;
            }
        }
        while (mantissa > traits::mantissa_max) {
            mantissa /= 10;
            exponent_offset++;
        }
        while (isdigit(*s)) {
            exponent_offset++;
            s++;
        }
        if (*s == '.') {
            s++;
            while (isdigit(*s)) {
                if (mantissa < traits::mantissa_max / 10) {
                    mantissa = mantissa * 10 + uint8_t(*s - '0');
                    exponent_offset--;
                }
                s++;
            }
        }
        int exponent = 0;
        if (*s == 'e' || *s == 'E') {
            s++;
            bool negative_exponent = false;
            if (*s == '-') {
                negative_exponent = true;
                s++;
            } else if (*s == '+') {
                s++;
            }
            while (isdigit(*s)) {
                exponent = exponent * 10 + (*s - '0');
                if (exponent + exponent_offset > traits::exponent_max) {
                    if (negative_exponent)
                        result.setFloat(is_negative ? -0.0f : 0.0f);
                    else
                        result.setFloat(is_negative ? -traits::inf() : traits::inf());
                    return true;
                }
                s++;
            }
            if (negative_exponent)
                exponent = -exponent;
        }
        exponent += exponent_offset;
        if (*s != '\0')
            return false;
        Float final_result =
                traits::make_float(static_cast<Float>(mantissa), exponent);
        result.setFloat(is_negative ? -final_result : final_result);
        return true;
    }

    template<typename T>
    inline T parseNumber(const char *s) {
        VariantData value;
        value.init();  // VariantData is a POD, so it has no constructor
        parseNumber(s, value);
        return Converter<T>::fromJson(VariantConstRef(&value));
    }

    template<typename T>
    inline T VariantData::asIntegral() const {
        switch (type()) {
            case VALUE_IS_BOOLEAN:
                return _content.asBoolean;
            case VALUE_IS_UNSIGNED_INTEGER:
                return convertNumber<T>(_content.asUnsignedInteger);
            case VALUE_IS_SIGNED_INTEGER:
                return convertNumber<T>(_content.asSignedInteger);
            case VALUE_IS_LINKED_STRING:
            case VALUE_IS_OWNED_STRING:
                return parseNumber<T>(_content.asString);
            case VALUE_IS_FLOAT:
                return convertNumber<T>(_content.asFloat);
            default:
                return 0;
        }
    }

    inline bool VariantData::asBoolean() const {
        switch (type()) {
            case VALUE_IS_BOOLEAN:
                return _content.asBoolean;
            case VALUE_IS_SIGNED_INTEGER:
            case VALUE_IS_UNSIGNED_INTEGER:
                return _content.asUnsignedInteger != 0;
            case VALUE_IS_FLOAT:
                return _content.asFloat != 0;
            case VALUE_IS_NULL:
                return false;
            default:
                return true;
        }
    }

    template<typename T>
    inline T VariantData::asFloat() const {
        switch (type()) {
            case VALUE_IS_BOOLEAN:
                return static_cast<T>(_content.asBoolean);
            case VALUE_IS_UNSIGNED_INTEGER:
                return static_cast<T>(_content.asUnsignedInteger);
            case VALUE_IS_SIGNED_INTEGER:
                return static_cast<T>(_content.asSignedInteger);
            case VALUE_IS_LINKED_STRING:
            case VALUE_IS_OWNED_STRING:
                return parseNumber<T>(_content.asString);
            case VALUE_IS_FLOAT:
                return static_cast<T>(_content.asFloat);
            default:
                return 0;
        }
    }

    inline const char *VariantData::asString() const {
        switch (type()) {
            case VALUE_IS_LINKED_STRING:
            case VALUE_IS_OWNED_STRING:
                return _content.asString;
            default:
                return 0;
        }
    }

    template<typename T>
    inline typename enable_if<is_same<T, ArrayRef>::value, ArrayRef>::type
    VariantRef::to() const {
        return ArrayRef(_pool, variantToArray(_data));
    }

    template<typename T>
    typename enable_if<is_same<T, ObjectRef>::value, ObjectRef>::type
    VariantRef::to() const {
        return ObjectRef(_pool, variantToObject(_data));
    }

    template<typename T>
    typename enable_if<is_same<T, VariantRef>::value, VariantRef>::type
    VariantRef::to() const {
        variantSetNull(_data);
        return *this;
    }

    inline VariantConstRef VariantConstRef::getElement(size_t index) const {
        return ArrayConstRef(_data != 0 ? _data->asArray() : 0)[index];
    }

    inline VariantRef VariantRef::addElement() const {
        return VariantRef(_pool, variantAddElement(_data, _pool));
    }

    inline VariantRef VariantRef::getElement(size_t index) const {
        return VariantRef(_pool, _data != 0 ? _data->getElement(index) : 0);
    }

    inline VariantRef VariantRef::getOrAddElement(size_t index) const {
        return VariantRef(_pool, variantGetOrAddElement(_data, index, _pool));
    }

    template<typename TChar>
    inline VariantRef VariantRef::getMember(TChar *key) const {
        return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0);
    }

    template<typename TString>
    inline typename enable_if<IsString<TString>::value, VariantRef>::type
    VariantRef::getMember(const TString &key) const {
        return VariantRef(_pool, _data != 0 ? _data->getMember(adaptString(key)) : 0);
    }

    template<typename TChar>
    inline VariantRef VariantRef::getOrAddMember(TChar *key) const {
        return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool));
    }

    template<typename TString>
    inline VariantRef VariantRef::getOrAddMember(const TString &key) const {
        return VariantRef(_pool, variantGetOrAddMember(_data, key, _pool));
    }

    inline VariantConstRef operator|(VariantConstRef preferedValue,
                                     VariantConstRef defaultValue) {
        return preferedValue ? preferedValue : defaultValue;
    }

    inline bool VariantRef::set(char value) const {
        return set < signed char > (value);
    }
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_STD_STREAM
#include <ostream>
#endif
namespace ARDUINOJSON_NAMESPACE {
    class DeserializationError {
        typedef void (DeserializationError::*bool_type)() const;

        void safeBoolHelper() const {}

    public:
        enum Code {
            Ok,
            EmptyInput,
            IncompleteInput,
            InvalidInput,
            NoMemory,
            TooDeep
        };

        DeserializationError() {}

        DeserializationError(Code c) : _code(c) {}

        friend bool operator==(const DeserializationError &lhs,
                               const DeserializationError &rhs) {
            return lhs._code == rhs._code;
        }

        friend bool operator!=(const DeserializationError &lhs,
                               const DeserializationError &rhs) {
            return lhs._code != rhs._code;
        }

        friend bool operator==(const DeserializationError &lhs, Code rhs) {
            return lhs._code == rhs;
        }

        friend bool operator==(Code lhs, const DeserializationError &rhs) {
            return lhs == rhs._code;
        }

        friend bool operator!=(const DeserializationError &lhs, Code rhs) {
            return lhs._code != rhs;
        }

        friend bool operator!=(Code lhs, const DeserializationError &rhs) {
            return lhs != rhs._code;
        }

        operator bool_type() const {
            return _code != Ok ? &DeserializationError::safeBoolHelper : 0;
        }

        friend bool operator==(bool value, const DeserializationError &err) {
            return static_cast<bool>(err) == value;
        }

        friend bool operator==(const DeserializationError &err, bool value) {
            return static_cast<bool>(err) == value;
        }

        friend bool operator!=(bool value, const DeserializationError &err) {
            return static_cast<bool>(err) != value;
        }

        friend bool operator!=(const DeserializationError &err, bool value) {
            return static_cast<bool>(err) != value;
        }

        Code code() const {
            return _code;
        }

        const char *c_str() const {
            static const char *messages[] = {
                    "Ok", "EmptyInput", "IncompleteInput",
                    "InvalidInput", "NoMemory", "TooDeep"};
            ARDUINOJSON_ASSERT(static_cast<size_t>(_code) <
                               sizeof(messages) / sizeof(messages[0]));
            return messages[_code];
        }

#if ARDUINOJSON_ENABLE_PROGMEM

        const __FlashStringHelper *f_str() const {
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s0, "Ok");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s1, "EmptyInput");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s2, "IncompleteInput");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s3, "InvalidInput");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s4, "NoMemory");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(char, s5, "TooDeep");
            ARDUINOJSON_DEFINE_STATIC_ARRAY(
                    const char*, messages, ARDUINOJSON_EXPAND6({s0, s1, s2, s3, s4, s5}));
            return ARDUINOJSON_READ_STATIC_ARRAY(const __FlashStringHelper*, messages,
                                                 _code);
        }

#endif
    private:
        Code _code;
    };

#if ARDUINOJSON_ENABLE_STD_STREAM
                                                                                                                            inline std::ostream& operator<<(std::ostream& s,
                                const DeserializationError& e) {
  s << e.c_str();
  return s;
}
inline std::ostream& operator<<(std::ostream& s, DeserializationError::Code c) {
  s << DeserializationError(c).c_str();
  return s;
}
#endif

    class Filter {
    public:
        explicit Filter(VariantConstRef v) : _variant(v) {}

        bool allow() const {
            return _variant;
        }

        bool allowArray() const {
            return _variant == true || _variant.is<ArrayConstRef>();
        }

        bool allowObject() const {
            return _variant == true || _variant.is<ObjectConstRef>();
        }

        bool allowValue() const {
            return _variant == true;
        }

        template<typename TKey>
        Filter operator[](const TKey &key) const {
            if (_variant == true)  // "true" means "allow recursively"
                return *this;
            else
                return Filter(_variant[key] | _variant["*"]);
        }

    private:
        VariantConstRef _variant;
    };

    struct AllowAllFilter {
        bool allow() const {
            return true;
        }

        bool allowArray() const {
            return true;
        }

        bool allowObject() const {
            return true;
        }

        bool allowValue() const {
            return true;
        }

        template<typename TKey>
        AllowAllFilter operator[](const TKey &) const {
            return AllowAllFilter();
        }
    };

    class NestingLimit {
    public:
        NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {}

        explicit NestingLimit(uint8_t n) : _value(n) {}

        NestingLimit decrement() const {
            ARDUINOJSON_ASSERT(_value > 0);
            return NestingLimit(static_cast<uint8_t>(_value - 1));
        }

        bool reached() const {
            return _value == 0;
        }

    private:
        uint8_t _value;
    };

    template<typename TSource, typename Enable = void>
    struct Reader {
    public:
        Reader(TSource &source) : _source(&source) {}

        int read() {
            return _source->read();
        }

        size_t readBytes(char *buffer, size_t length) {
            return _source->readBytes(buffer, length);
        }

    private:
        TSource *_source;
    };

    template<typename TSource, typename Enable = void>
    struct BoundedReader {
    };

    template<typename TIterator>
    class IteratorReader {
        TIterator _ptr, _end;
    public:
        explicit IteratorReader(TIterator begin, TIterator end)
                : _ptr(begin), _end(end) {}

        int read() {
            if (_ptr < _end)
                return static_cast<unsigned char>(*_ptr++);
            else
                return -1;
        }

        size_t readBytes(char *buffer, size_t length) {
            size_t i = 0;
            while (i < length && _ptr < _end) buffer[i++] = *_ptr++;
            return i;
        }
    };

    template<typename T>
    struct void_ {
        typedef void type;
    };

    template<typename TSource>
    struct Reader<TSource, typename void_<typename TSource::const_iterator>::type>
            : IteratorReader<typename TSource::const_iterator> {
        explicit Reader(const TSource &source)
                : IteratorReader<typename TSource::const_iterator>(source.begin(),
                                                                   source.end()) {}
    };

    template<typename T>
    struct IsCharOrVoid {
        static const bool value =
                is_same<T, void>::value || is_same<T, char>::value ||
                is_same<T, unsigned char>::value || is_same<T, signed char>::value;
    };
    template<typename T>
    struct IsCharOrVoid<const T> : IsCharOrVoid<T> {
    };

    template<typename TSource>
    struct Reader<TSource *,
            typename enable_if<IsCharOrVoid<TSource>::value>::type> {
        const char *_ptr;
    public:
        explicit Reader(const void *ptr)
                : _ptr(ptr ? reinterpret_cast<const char *>(ptr) : "") {}

        int read() {
            return static_cast<unsigned char>(*_ptr++);
        }

        size_t readBytes(char *buffer, size_t length) {
            for (size_t i = 0; i < length; i++) buffer[i] = *_ptr++;
            return length;
        }
    };

    template<typename TSource>
    struct BoundedReader<TSource *,
            typename enable_if<IsCharOrVoid<TSource>::value>::type>
            : public IteratorReader<const char *> {
    public:
        explicit BoundedReader(const void *ptr, size_t len)
                : IteratorReader<const char *>(reinterpret_cast<const char *>(ptr),
                                               reinterpret_cast<const char *>(ptr) + len) {}
    };

    template<typename TArray>
    struct Reader<ElementProxy<TArray>, void> : Reader<char *, void> {
        explicit Reader(const ElementProxy<TArray> &x)
                : Reader<char *, void>(x.template as<const char *>()) {}
    };

    template<typename TObject, typename TStringRef>
    struct Reader<MemberProxy<TObject, TStringRef>, void> : Reader<char *, void> {
        explicit Reader(const MemberProxy<TObject, TStringRef> &x)
                : Reader<char *, void>(x.template as<const char *>()) {}
    };

    template<>
    struct Reader<VariantRef, void> : Reader<char *, void> {
        explicit Reader(VariantRef x) : Reader<char *, void>(x.as<const char *>()) {}
    };

    template<>
    struct Reader<VariantConstRef, void> : Reader<char *, void> {
        explicit Reader(VariantConstRef x)
                : Reader<char *, void>(x.as<const char *>()) {}
    };
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
namespace ARDUINOJSON_NAMESPACE {
    template<typename TSource>
    struct Reader<TSource,
            typename enable_if<is_base_of<Stream, TSource>::value>::type> {
    public:
        explicit Reader(Stream &stream) : _stream(&stream) {}

        int read() {
            char c;
            return _stream->readBytes(&c, 1) ? static_cast<unsigned char>(c) : -1;
        }

        size_t readBytes(char *buffer, size_t length) {
            return _stream->readBytes(buffer, length);
        }

    private:
        Stream *_stream;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
namespace ARDUINOJSON_NAMESPACE {
    template<typename TSource>
    struct Reader<TSource,
            typename enable_if<is_base_of<::String, TSource>::value>::type>
            : BoundedReader<const char *> {
        explicit Reader(const ::String &s)
                : BoundedReader<const char *>(s.c_str(), s.length()) {}
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_PROGMEM
namespace ARDUINOJSON_NAMESPACE {
    template<>
    struct Reader<const __FlashStringHelper *, void> {
        const char *_ptr;
    public:
        explicit Reader(const __FlashStringHelper *ptr)
                : _ptr(reinterpret_cast<const char *>(ptr)) {}

        int read() {
            return pgm_read_byte(_ptr++);
        }

        size_t readBytes(char *buffer, size_t length) {
            memcpy_P(buffer, _ptr, length);
            _ptr += length;
            return length;
        }
    };

    template<>
    struct BoundedReader<const __FlashStringHelper *, void> {
        const char *_ptr;
        const char *_end;
    public:
        explicit BoundedReader(const __FlashStringHelper *ptr, size_t size)
                : _ptr(reinterpret_cast<const char *>(ptr)), _end(_ptr + size) {}

        int read() {
            if (_ptr < _end)
                return pgm_read_byte(_ptr++);
            else
                return -1;
        }

        size_t readBytes(char *buffer, size_t length) {
            size_t available = static_cast<size_t>(_end - _ptr);
            if (available < length)
                length = available;
            memcpy_P(buffer, _ptr, length);
            _ptr += length;
            return length;
        }
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_STD_STREAM
                                                                                                                        #include <istream>
namespace ARDUINOJSON_NAMESPACE {
template <typename TSource>
struct Reader<TSource, typename enable_if<
                           is_base_of<std::istream, TSource>::value>::type> {
 public:
  explicit Reader(std::istream& stream) : _stream(&stream) {}
  int read() {
    return _stream->get();
  }
  size_t readBytes(char* buffer, size_t length) {
    _stream->read(buffer, static_cast<std::streamsize>(length));
    return static_cast<size_t>(_stream->gcount());
  }
 private:
  std::istream* _stream;
};
}  // namespace ARDUINOJSON_NAMESPACE
#endif
namespace ARDUINOJSON_NAMESPACE {
    class StringCopier {
    public:
        StringCopier(MemoryPool &pool) : _pool(&pool) {}

        void startString() {
            _pool->getFreeZone(&_ptr, &_capacity);
            _size = 0;
        }

        const char *save() {
            ARDUINOJSON_ASSERT(_ptr);
            return _pool->saveStringFromFreeZone(_size);
        }

        void append(const char *s) {
            while (*s) append(*s++);
        }

        void append(const char *s, size_t n) {
            while (n-- > 0) append(*s++);
        }

        void append(char c) {
            if (!_ptr)
                return;
            if (_size >= _capacity) {
                _ptr = 0;
                _pool->markAsOverflowed();
                return;
            }
            _ptr[_size++] = c;
        }

        bool isValid() {
            return _ptr != 0;
        }

        const char *c_str() {
            return _ptr;
        }

        typedef storage_policies::store_by_copy storage_policy;
    private:
        MemoryPool *_pool;
        char *_ptr;
        size_t _size, _capacity;
    };

    class StringMover {
    public:
        StringMover(char *ptr) : _writePtr(ptr) {}

        void startString() {
            _startPtr = _writePtr;
        }

        const char *save() const {
            return _startPtr;
        }

        void append(char c) {
            *_writePtr++ = c;
        }

        bool isValid() const {
            return true;
        }

        const char *c_str() const {
            return _startPtr;
        }

        typedef storage_policies::store_by_address storage_policy;
    private:
        char *_writePtr;
        char *_startPtr;
    };

    template<typename TInput>
    StringCopier makeStringStorage(TInput &, MemoryPool &pool) {
        return StringCopier(pool);
    }

    template<typename TChar>
    StringMover makeStringStorage(
            TChar *input, MemoryPool &,
            typename enable_if<!is_const<TChar>::value>::type * = 0) {
        return StringMover(reinterpret_cast<char *>(input));
    }

    template<template<typename, typename> class TDeserializer, typename TReader,
            typename TWriter>
    TDeserializer<TReader, TWriter> makeDeserializer(MemoryPool &pool,
                                                     TReader reader,
                                                     TWriter writer) {
        return TDeserializer<TReader, TWriter>(pool, reader, writer);
    }

    template<template<typename, typename> class TDeserializer, typename TString,
            typename TFilter>
    typename enable_if<!is_array<TString>::value, DeserializationError>::type
    deserialize(JsonDocument &doc, const TString &input, NestingLimit nestingLimit,
                TFilter filter) {
        Reader<TString> reader(input);
        doc.clear();
        return makeDeserializer<TDeserializer>(
                doc.memoryPool(), reader,
                makeStringStorage(input, doc.memoryPool()))
                .parse(doc.data(), filter, nestingLimit);
    }

    template<template<typename, typename> class TDeserializer, typename TChar,
            typename TFilter>
    DeserializationError deserialize(JsonDocument &doc, TChar *input,
                                     size_t inputSize, NestingLimit nestingLimit,
                                     TFilter filter) {
        BoundedReader<TChar *> reader(input, inputSize);
        doc.clear();
        return makeDeserializer<TDeserializer>(
                doc.memoryPool(), reader,
                makeStringStorage(input, doc.memoryPool()))
                .parse(doc.data(), filter, nestingLimit);
    }

    template<template<typename, typename> class TDeserializer, typename TStream,
            typename TFilter>
    DeserializationError deserialize(JsonDocument &doc, TStream &input,
                                     NestingLimit nestingLimit, TFilter filter) {
        Reader<TStream> reader(input);
        doc.clear();
        return makeDeserializer<TDeserializer>(
                doc.memoryPool(), reader,
                makeStringStorage(input, doc.memoryPool()))
                .parse(doc.data(), filter, nestingLimit);
    }

    class EscapeSequence {
    public:
        static char escapeChar(char c) {
            const char *p = escapeTable(true);
            while (p[0] && p[1] != c) {
                p += 2;
            }
            return p[0];
        }

        static char unescapeChar(char c) {
            const char *p = escapeTable(false);
            for (;;) {
                if (p[0] == '\0')
                    return 0;
                if (p[0] == c)
                    return p[1];
                p += 2;
            }
        }

    private:
        static const char *escapeTable(bool excludeSolidus) {
            return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0];
        }
    };

    template<typename TReader>
    class Latch {
    public:
        Latch(TReader reader) : _reader(reader), _loaded(false) {
#if ARDUINOJSON_DEBUG
            _ended = false;
#endif
        }

        void clear() {
            _loaded = false;
        }

        int last() const {
            return _current;
        }

        FORCE_INLINE char current() {
            if (!_loaded) {
                load();
            }
            return _current;
        }

    private:
        void load() {
            ARDUINOJSON_ASSERT(!_ended);
            int c = _reader.read();
#if ARDUINOJSON_DEBUG
                                                                                                                                    if (c <= 0)
      _ended = true;
#endif
            _current = static_cast<char>(c > 0 ? c : 0);
            _loaded = true;
        }

        TReader _reader;
        char _current;  // NOLINT(clang-analyzer-optin.cplusplus.UninitializedObject)
        bool _loaded;
#if ARDUINOJSON_DEBUG
        bool _ended;
#endif
    };
}  // namespace ARDUINOJSON_NAMESPACE
#if defined(__GNUC__)
#  if __GNUC__ >= 7
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#  endif
#endif
namespace ARDUINOJSON_NAMESPACE {
    namespace Utf16 {
        inline bool isHighSurrogate(uint16_t codeunit) {
            return codeunit >= 0xD800 && codeunit < 0xDC00;
        }

        inline bool isLowSurrogate(uint16_t codeunit) {
            return codeunit >= 0xDC00 && codeunit < 0xE000;
        }

        class Codepoint {
        public:
            Codepoint() : _highSurrogate(0), _codepoint(0) {}

            bool append(uint16_t codeunit) {
                if (isHighSurrogate(codeunit)) {
                    _highSurrogate = codeunit & 0x3FF;
                    return false;
                }
                if (isLowSurrogate(codeunit)) {
                    _codepoint =
                            uint32_t(0x10000 + ((_highSurrogate << 10) | (codeunit & 0x3FF)));
                    return true;
                }
                _codepoint = codeunit;
                return true;
            }

            uint32_t value() const {
                return _codepoint;
            }

        private:
            uint16_t _highSurrogate;
            uint32_t _codepoint;
        };
    }  // namespace Utf16
}  // namespace ARDUINOJSON_NAMESPACE
#if defined(__GNUC__)
#  if __GNUC__ >= 8
#    pragma GCC diagnostic pop
#  endif
#endif
namespace ARDUINOJSON_NAMESPACE {
    namespace Utf8 {
        template<typename TStringBuilder>
        inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder &str) {
            char buf[5];
            char *p = buf;
            *(p++) = 0;
            if (codepoint32 < 0x80) {
                *(p++) = char((codepoint32));
            } else {
                *(p++) = char((codepoint32 | 0x80) & 0xBF);
                uint16_t codepoint16 = uint16_t(codepoint32 >> 6);
                if (codepoint16 < 0x20) {  // 0x800
                    *(p++) = char(codepoint16 | 0xC0);
                } else {
                    *(p++) = char((codepoint16 | 0x80) & 0xBF);
                    codepoint16 = uint16_t(codepoint16 >> 6);
                    if (codepoint16 < 0x10) {  // 0x10000
                        *(p++) = char(codepoint16 | 0xE0);
                    } else {
                        *(p++) = char((codepoint16 | 0x80) & 0xBF);
                        codepoint16 = uint16_t(codepoint16 >> 6);
                        *(p++) = char(codepoint16 | 0xF0);
                    }
                }
            }
            while (*(--p)) {
                str.append(*p);
            }
        }
    }  // namespace Utf8
    template<typename TReader, typename TStringStorage>
    class JsonDeserializer {
    public:
        JsonDeserializer(MemoryPool &pool, TReader reader,
                         TStringStorage stringStorage)
                : _stringStorage(stringStorage),
                  _foundSomething(false),
                  _latch(reader),
                  _pool(&pool),
                  _error(DeserializationError::Ok) {}

        template<typename TFilter>
        DeserializationError parse(VariantData &variant, TFilter filter,
                                   NestingLimit nestingLimit) {
            parseVariant(variant, filter, nestingLimit);
            if (!_error && _latch.last() != 0 && !variant.isEnclosed()) {
                return DeserializationError::InvalidInput;
            }
            return _error;
        }

    private:
        char current() {
            return _latch.current();
        }

        void move() {
            _latch.clear();
        }

        bool eat(char charToSkip) {
            if (current() != charToSkip)
                return false;
            move();
            return true;
        }

        template<typename TFilter>
        bool parseVariant(VariantData &variant, TFilter filter,
                          NestingLimit nestingLimit) {
            if (!skipSpacesAndComments())
                return false;
            switch (current()) {
                case '[':
                    if (filter.allowArray())
                        return parseArray(variant.toArray(), filter, nestingLimit);
                    else
                        return skipArray(nestingLimit);
                case '{':
                    if (filter.allowObject())
                        return parseObject(variant.toObject(), filter, nestingLimit);
                    else
                        return skipObject(nestingLimit);
                case '\"':
                case '\'':
                    if (filter.allowValue())
                        return parseStringValue(variant);
                    else
                        return skipString();
                default:
                    if (filter.allowValue())
                        return parseNumericValue(variant);
                    else
                        return skipNumericValue();
            }
        }

        bool skipVariant(NestingLimit nestingLimit) {
            if (!skipSpacesAndComments())
                return false;
            switch (current()) {
                case '[':
                    return skipArray(nestingLimit);
                case '{':
                    return skipObject(nestingLimit);
                case '\"':
                case '\'':
                    return skipString();
                default:
                    return skipNumericValue();
            }
        }

        template<typename TFilter>
        bool parseArray(CollectionData &array, TFilter filter,
                        NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            ARDUINOJSON_ASSERT(current() == '[');
            move();
            if (!skipSpacesAndComments())
                return false;
            if (eat(']'))
                return true;
            TFilter memberFilter = filter[0UL];
            for (;;) {
                if (memberFilter.allow()) {
                    VariantData *value = array.addElement(_pool);
                    if (!value) {
                        _error = DeserializationError::NoMemory;
                        return false;
                    }
                    if (!parseVariant(*value, memberFilter, nestingLimit.decrement()))
                        return false;
                } else {
                    if (!skipVariant(nestingLimit.decrement()))
                        return false;
                }
                if (!skipSpacesAndComments())
                    return false;
                if (eat(']'))
                    return true;
                if (!eat(',')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
            }
        }

        bool skipArray(NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            ARDUINOJSON_ASSERT(current() == '[');
            move();
            for (;;) {
                if (!skipVariant(nestingLimit.decrement()))
                    return false;
                if (!skipSpacesAndComments())
                    return false;
                if (eat(']'))
                    return true;
                if (!eat(',')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
            }
        }

        template<typename TFilter>
        bool parseObject(CollectionData &object, TFilter filter,
                         NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            ARDUINOJSON_ASSERT(current() == '{');
            move();
            if (!skipSpacesAndComments())
                return false;
            if (eat('}'))
                return true;
            for (;;) {
                if (!parseKey())
                    return false;
                if (!skipSpacesAndComments())
                    return false;
                if (!eat(':')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
                const char *key = _stringStorage.c_str();
                TFilter memberFilter = filter[key];
                if (memberFilter.allow()) {
                    VariantData *variant = object.getMember(adaptString(key));
                    if (!variant) {
                        key = _stringStorage.save();
                        VariantSlot *slot = object.addSlot(_pool);
                        if (!slot) {
                            _error = DeserializationError::NoMemory;
                            return false;
                        }
                        slot->setKey(key, typename TStringStorage::storage_policy());
                        variant = slot->data();
                    }
                    if (!parseVariant(*variant, memberFilter, nestingLimit.decrement()))
                        return false;
                } else {
                    if (!skipVariant(nestingLimit.decrement()))
                        return false;
                }
                if (!skipSpacesAndComments())
                    return false;
                if (eat('}'))
                    return true;
                if (!eat(',')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
                if (!skipSpacesAndComments())
                    return false;
            }
        }

        bool skipObject(NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            ARDUINOJSON_ASSERT(current() == '{');
            move();
            if (!skipSpacesAndComments())
                return false;
            if (eat('}'))
                return true;
            for (;;) {
                if (!skipVariant(nestingLimit.decrement()))
                    return false;
                if (!skipSpacesAndComments())
                    return false;
                if (!eat(':')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
                if (!skipVariant(nestingLimit.decrement()))
                    return false;
                if (!skipSpacesAndComments())
                    return false;
                if (eat('}'))
                    return true;
                if (!eat(',')) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
            }
        }

        bool parseKey() {
            _stringStorage.startString();
            if (isQuote(current())) {
                return parseQuotedString();
            } else {
                return parseNonQuotedString();
            }
        }

        bool parseStringValue(VariantData &variant) {
            _stringStorage.startString();
            if (!parseQuotedString())
                return false;
            const char *value = _stringStorage.save();
            variant.setStringPointer(value, typename TStringStorage::storage_policy());
            return true;
        }

        bool parseQuotedString() {
#if ARDUINOJSON_DECODE_UNICODE
            Utf16::Codepoint codepoint;
#endif
            const char stopChar = current();
            move();
            for (;;) {
                char c = current();
                move();
                if (c == stopChar)
                    break;
                if (c == '\0') {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                if (c == '\\') {
                    c = current();
                    if (c == '\0') {
                        _error = DeserializationError::IncompleteInput;
                        return false;
                    }
                    if (c == 'u') {
#if ARDUINOJSON_DECODE_UNICODE
                        move();
                        uint16_t codeunit;
                        if (!parseHex4(codeunit))
                            return false;
                        if (codepoint.append(codeunit))
                            Utf8::encodeCodepoint(codepoint.value(), _stringStorage);
#else
                        _stringStorage.append('\\');
#endif
                        continue;
                    }
                    c = EscapeSequence::unescapeChar(c);
                    if (c == '\0') {
                        _error = DeserializationError::InvalidInput;
                        return false;
                    }
                    move();
                }
                _stringStorage.append(c);
            }
            _stringStorage.append('\0');
            if (!_stringStorage.isValid()) {
                _error = DeserializationError::NoMemory;
                return false;
            }
            return true;
        }

        bool parseNonQuotedString() {
            char c = current();
            ARDUINOJSON_ASSERT(c);
            if (canBeInNonQuotedString(c)) {  // no quotes
                do {
                    move();
                    _stringStorage.append(c);
                    c = current();
                } while (canBeInNonQuotedString(c));
            } else {
                _error = DeserializationError::InvalidInput;
                return false;
            }
            _stringStorage.append('\0');
            if (!_stringStorage.isValid()) {
                _error = DeserializationError::NoMemory;
                return false;
            }
            return true;
        }

        bool skipString() {
            const char stopChar = current();
            move();
            for (;;) {
                char c = current();
                move();
                if (c == stopChar)
                    break;
                if (c == '\0') {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                if (c == '\\') {
                    if (current() != '\0')
                        move();
                }
            }
            return true;
        }

        bool parseNumericValue(VariantData &result) {
            uint8_t n = 0;
            char c = current();
            while (canBeInNonQuotedString(c) && n < 63) {
                move();
                _buffer[n++] = c;
                c = current();
            }
            _buffer[n] = 0;
            c = _buffer[0];
            if (c == 't') {  // true
                result.setBoolean(true);
                if (n != 4) {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                return true;
            }
            if (c == 'f') {  // false
                result.setBoolean(false);
                if (n != 5) {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                return true;
            }
            if (c == 'n') {  // null
                if (n != 4) {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                return true;
            }
            if (!parseNumber(_buffer, result)) {
                _error = DeserializationError::InvalidInput;
                return false;
            }
            return true;
        }

        bool skipNumericValue() {
            char c = current();
            while (canBeInNonQuotedString(c)) {
                move();
                c = current();
            }
            return true;
        }

        bool parseHex4(uint16_t &result) {
            result = 0;
            for (uint8_t i = 0; i < 4; ++i) {
                char digit = current();
                if (!digit) {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
                uint8_t value = decodeHex(digit);
                if (value > 0x0F) {
                    _error = DeserializationError::InvalidInput;
                    return false;
                }
                result = uint16_t((result << 4) | value);
                move();
            }
            return true;
        }

        static inline bool isBetween(char c, char min, char max) {
            return min <= c && c <= max;
        }

        static inline bool canBeInNonQuotedString(char c) {
            return isBetween(c, '0', '9') || isBetween(c, '_', 'z') ||
                   isBetween(c, 'A', 'Z') || c == '+' || c == '-' || c == '.';
        }

        static inline bool isQuote(char c) {
            return c == '\'' || c == '\"';
        }

        static inline uint8_t decodeHex(char c) {
            if (c < 'A')
                return uint8_t(c - '0');
            c = char(c & ~0x20);  // uppercase
            return uint8_t(c - 'A' + 10);
        }

        bool skipSpacesAndComments() {
            for (;;) {
                switch (current()) {
                    case '\0':
                        _error = _foundSomething ? DeserializationError::IncompleteInput
                                                 : DeserializationError::EmptyInput;
                        return false;
                    case ' ':
                    case '\t':
                    case '\r':
                    case '\n':
                        move();
                        continue;
#if ARDUINOJSON_ENABLE_COMMENTS
                                                                                                                                                case '/':
          move();  // skip '/'
          switch (current()) {
            case '*': {
              move();  // skip '*'
              bool wasStar = false;
              for (;;) {
                char c = current();
                if (c == '\0') {
                  _error = DeserializationError::IncompleteInput;
                  return false;
                }
                if (c == '/' && wasStar) {
                  move();
                  break;
                }
                wasStar = c == '*';
                move();
              }
              break;
            }
            case '/':
              for (;;) {
                move();
                char c = current();
                if (c == '\0') {
                  _error = DeserializationError::IncompleteInput;
                  return false;
                }
                if (c == '\n')
                  break;
              }
              break;
            default:
              _error = DeserializationError::InvalidInput;
              return false;
          }
          break;
#endif
                    default:
                        _foundSomething = true;
                        return true;
                }
            }
        }

        TStringStorage _stringStorage;
        bool _foundSomething;
        Latch<TReader> _latch;
        MemoryPool *_pool;
        char _buffer[64];  // using a member instead of a local variable because it
        DeserializationError _error;
    };

    template<typename TString>
    DeserializationError deserializeJson(
            JsonDocument &doc, const TString &input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                             AllowAllFilter());
    }

    template<typename TString>
    DeserializationError deserializeJson(
            JsonDocument &doc, const TString &input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TString>
    DeserializationError deserializeJson(JsonDocument &doc, const TString &input,
                                         NestingLimit nestingLimit, Filter filter) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TStream>
    DeserializationError deserializeJson(
            JsonDocument &doc, TStream &input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                             AllowAllFilter());
    }

    template<typename TStream>
    DeserializationError deserializeJson(
            JsonDocument &doc, TStream &input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TStream>
    DeserializationError deserializeJson(JsonDocument &doc, TStream &input,
                                         NestingLimit nestingLimit, Filter filter) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeJson(
            JsonDocument &doc, TChar *input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit,
                                             AllowAllFilter());
    }

    template<typename TChar>
    DeserializationError deserializeJson(
            JsonDocument &doc, TChar *input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeJson(JsonDocument &doc, TChar *input,
                                         NestingLimit nestingLimit, Filter filter) {
        return deserialize<JsonDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeJson(
            JsonDocument &doc, TChar *input, size_t inputSize,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
                                             AllowAllFilter());
    }

    template<typename TChar>
    DeserializationError deserializeJson(
            JsonDocument &doc, TChar *input, size_t inputSize, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
                                             filter);
    }

    template<typename TChar>
    DeserializationError deserializeJson(JsonDocument &doc, TChar *input,
                                         size_t inputSize,
                                         NestingLimit nestingLimit, Filter filter) {
        return deserialize<JsonDeserializer>(doc, input, inputSize, nestingLimit,
                                             filter);
    }

    template<typename TFloat>
    struct FloatParts {
        uint32_t integral;
        uint32_t decimal;
        int16_t exponent;
        int8_t decimalPlaces;

        FloatParts(TFloat value) {
            uint32_t maxDecimalPart = sizeof(TFloat) >= 8 ? 1000000000 : 1000000;
            decimalPlaces = sizeof(TFloat) >= 8 ? 9 : 6;
            exponent = normalize(value);
            integral = uint32_t(value);
            for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
                maxDecimalPart /= 10;
                decimalPlaces--;
            }
            TFloat remainder = (value - TFloat(integral)) * TFloat(maxDecimalPart);
            decimal = uint32_t(remainder);
            remainder = remainder - TFloat(decimal);
            decimal += uint32_t(remainder * 2);
            if (decimal >= maxDecimalPart) {
                decimal = 0;
                integral++;
                if (exponent && integral >= 10) {
                    exponent++;
                    integral = 1;
                }
            }
            while (decimal % 10 == 0 && decimalPlaces > 0) {
                decimal /= 10;
                decimalPlaces--;
            }
        }

        static int16_t normalize(TFloat &value) {
            typedef FloatTraits<TFloat> traits;
            int16_t powersOf10 = 0;
            int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
            int bit = 1 << index;
            if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
                for (; index >= 0; index--) {
                    if (value >= traits::positiveBinaryPowerOfTen(index)) {
                        value *= traits::negativeBinaryPowerOfTen(index);
                        powersOf10 = int16_t(powersOf10 + bit);
                    }
                    bit >>= 1;
                }
            }
            if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
                for (; index >= 0; index--) {
                    if (value < traits::negativeBinaryPowerOfTenPlusOne(index)) {
                        value *= traits::positiveBinaryPowerOfTen(index);
                        powersOf10 = int16_t(powersOf10 - bit);
                    }
                    bit >>= 1;
                }
            }
            return powersOf10;
        }
    };

    template<typename TWriter>
    class CountingDecorator {
    public:
        explicit CountingDecorator(TWriter &writer) : _writer(writer), _count(0) {}

        void write(uint8_t c) {
            _count += _writer.write(c);
        }

        void write(const uint8_t *s, size_t n) {
            _count += _writer.write(s, n);
        }

        size_t count() const {
            return _count;
        }

    private:
        TWriter _writer;
        size_t _count;
    };

    template<typename TWriter>
    class TextFormatter {
    public:
        explicit TextFormatter(TWriter writer) : _writer(writer) {}

        size_t bytesWritten() const {
            return _writer.count();
        }

        void writeBoolean(bool value) {
            if (value)
                writeRaw("true");
            else
                writeRaw("false");
        }

        void writeString(const char *value) {
            ARDUINOJSON_ASSERT(value != NULL);
            writeRaw('\"');
            while (*value) writeChar(*value++);
            writeRaw('\"');
        }

        void writeChar(char c) {
            char specialChar = EscapeSequence::escapeChar(c);
            if (specialChar) {
                writeRaw('\\');
                writeRaw(specialChar);
            } else {
                writeRaw(c);
            }
        }

        template<typename T>
        void writeFloat(T value) {
            if (isnan(value))
                return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null");
#if ARDUINOJSON_ENABLE_INFINITY
                                                                                                                                    if (value < 0.0) {
      writeRaw('-');
      value = -value;
    }
    if (isinf(value))
      return writeRaw("Infinity");
#else
            if (isinf(value))
                return writeRaw("null");
            if (value < 0.0) {
                writeRaw('-');
                value = -value;
            }
#endif
            FloatParts<T> parts(value);
            writeInteger(parts.integral);
            if (parts.decimalPlaces)
                writeDecimals(parts.decimal, parts.decimalPlaces);
            if (parts.exponent) {
                writeRaw('e');
                writeInteger(parts.exponent);
            }
        }

        template<typename T>
        typename enable_if<is_signed<T>::value>::type writeInteger(T value) {
            typedef typename make_unsigned<T>::type unsigned_type;
            unsigned_type unsigned_value;
            if (value < 0) {
                writeRaw('-');
                unsigned_value = unsigned_type(unsigned_type(~value) + 1);
            } else {
                unsigned_value = unsigned_type(value);
            }
            writeInteger(unsigned_value);
        }

        template<typename T>
        typename enable_if<is_unsigned<T>::value>::type writeInteger(T value) {
            char buffer[22];
            char *end = buffer + sizeof(buffer);
            char *begin = end;
            do {
                *--begin = char(value % 10 + '0');
                value = T(value / 10);
            } while (value);
            writeRaw(begin, end);
        }

        void writeDecimals(uint32_t value, int8_t width) {
            char buffer[16];
            char *end = buffer + sizeof(buffer);
            char *begin = end;
            while (width--) {
                *--begin = char(value % 10 + '0');
                value /= 10;
            }
            *--begin = '.';
            writeRaw(begin, end);
        }

        void writeRaw(const char *s) {
            _writer.write(reinterpret_cast<const uint8_t *>(s), strlen(s));
        }

        void writeRaw(const char *s, size_t n) {
            _writer.write(reinterpret_cast<const uint8_t *>(s), n);
        }

        void writeRaw(const char *begin, const char *end) {
            _writer.write(reinterpret_cast<const uint8_t *>(begin),
                          static_cast<size_t>(end - begin));
        }

        template<size_t N>
        void writeRaw(const char (&s)[N]) {
            _writer.write(reinterpret_cast<const uint8_t *>(s), N - 1);
        }

        void writeRaw(char c) {
            _writer.write(static_cast<uint8_t>(c));
        }

    protected:
        CountingDecorator<TWriter> _writer;
    private:
        TextFormatter &operator=(const TextFormatter &);  // cannot be assigned
    };

    class DummyWriter {
    public:
        size_t write(uint8_t) {
            return 1;
        }

        size_t write(const uint8_t *, size_t n) {
            return n;
        }
    };

    template<template<typename> class TSerializer, typename TSource>
    size_t measure(const TSource &source) {
        DummyWriter dp;
        TSerializer<DummyWriter> serializer(dp);
        return source.accept(serializer);
    }

    template<typename TDestination, typename Enable = void>
    class Writer {
    public:
        explicit Writer(TDestination &dest) : _dest(&dest) {}

        size_t write(uint8_t c) {
            return _dest->write(c);
        }

        size_t write(const uint8_t *s, size_t n) {
            return _dest->write(s, n);
        }

    private:
        TDestination *_dest;
    };

    class StaticStringWriter {
    public:
        StaticStringWriter(char *buf, size_t size) : end(buf + size), p(buf) {}

        size_t write(uint8_t c) {
            if (p >= end)
                return 0;
            *p++ = static_cast<char>(c);
            return 1;
        }

        size_t write(const uint8_t *s, size_t n) {
            char *begin = p;
            while (p < end && n > 0) {
                *p++ = static_cast<char>(*s++);
                n--;
            }
            return size_t(p - begin);
        }

    private:
        char *end;
        char *p;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#if ARDUINOJSON_ENABLE_STD_STRING
                                                                                                                        namespace ARDUINOJSON_NAMESPACE {
template <class T>
struct is_std_string : false_type {};
template <class TCharTraits, class TAllocator>
struct is_std_string<std::basic_string<char, TCharTraits, TAllocator> >
    : true_type {};
template <typename TDestination>
class Writer<TDestination,
             typename enable_if<is_std_string<TDestination>::value>::type> {
 public:
  Writer(TDestination &str) : _str(&str) {}
  size_t write(uint8_t c) {
    _str->operator+=(static_cast<char>(c));
    return 1;
  }
  size_t write(const uint8_t *s, size_t n) {
    _str->append(reinterpret_cast<const char *>(s), n);
    return n;
  }
 private:
  TDestination *_str;
};
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_ARDUINO_STRING
namespace ARDUINOJSON_NAMESPACE {
    template<>
    class Writer<::String, void> {
        static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE;
    public:
        explicit Writer(::String &str) : _destination(&str) {
            _size = 0;
        }

        ~Writer() {
            flush();
        }

        size_t write(uint8_t c) {
            if (_size + 1 >= bufferCapacity)
                if (flush() != 0)
                    return 0;
            _buffer[_size++] = static_cast<char>(c);
            return 1;
        }

        size_t write(const uint8_t *s, size_t n) {
            for (size_t i = 0; i < n; i++) {
                write(s[i]);
            }
            return n;
        }

        size_t flush() {
            ARDUINOJSON_ASSERT(_size < bufferCapacity);
            _buffer[_size] = 0;
            if (_destination->concat(_buffer))
                _size = 0;
            return _size;
        }

    private:
        ::String *_destination;
        char _buffer[bufferCapacity];
        size_t _size;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_STD_STREAM
                                                                                                                        namespace ARDUINOJSON_NAMESPACE {
template <typename TDestination>
class Writer<
    TDestination,
    typename enable_if<is_base_of<std::ostream, TDestination>::value>::type> {
 public:
  explicit Writer(std::ostream& os) : _os(&os) {}
  size_t write(uint8_t c) {
    _os->put(static_cast<char>(c));
    return 1;
  }
  size_t write(const uint8_t* s, size_t n) {
    _os->write(reinterpret_cast<const char*>(s),
               static_cast<std::streamsize>(n));
    return n;
  }
 private:
  std::ostream* _os;
};
}  // namespace ARDUINOJSON_NAMESPACE
#endif
#if ARDUINOJSON_ENABLE_ARDUINO_PRINT
namespace ARDUINOJSON_NAMESPACE {
    template<typename TDestination>
    class Writer<
            TDestination,
            typename enable_if<is_base_of<::Print, TDestination>::value>::type> {
    public:
        explicit Writer(::Print &print) : _print(&print) {}

        size_t write(uint8_t c) {
            return _print->write(c);
        }

        size_t write(const uint8_t *s, size_t n) {
            return _print->write(s, n);
        }

    private:
        ::Print *_print;
    };
}  // namespace ARDUINOJSON_NAMESPACE
#endif
namespace ARDUINOJSON_NAMESPACE {
    template<template<typename> class TSerializer, typename TSource,
            typename TWriter>
    size_t doSerialize(const TSource &source, TWriter writer) {
        TSerializer<TWriter> serializer(writer);
        return source.accept(serializer);
    }

    template<template<typename> class TSerializer, typename TSource,
            typename TDestination>
    size_t serialize(const TSource &source, TDestination &destination) {
        Writer<TDestination> writer(destination);
        return doSerialize<TSerializer>(source, writer);
    }

    template<template<typename> class TSerializer, typename TSource>
    typename enable_if<!TSerializer<StaticStringWriter>::producesText, size_t>::type
    serialize(const TSource &source, void *buffer, size_t bufferSize) {
        StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize);
        return doSerialize<TSerializer>(source, writer);
    }

    template<template<typename> class TSerializer, typename TSource>
    typename enable_if<TSerializer<StaticStringWriter>::producesText, size_t>::type
    serialize(const TSource &source, void *buffer, size_t bufferSize) {
        StaticStringWriter writer(reinterpret_cast<char *>(buffer), bufferSize);
        size_t n = doSerialize<TSerializer>(source, writer);
        if (n < bufferSize)
            reinterpret_cast<char *>(buffer)[n] = 0;
        return n;
    }

    template<template<typename> class TSerializer, typename TSource,
            typename TChar, size_t N>
#if defined _MSC_VER && _MSC_VER < 1900
    typename enable_if<sizeof(remove_reference<TChar>::type) == 1, size_t>::type
#else
    typename enable_if<sizeof(TChar) == 1, size_t>::type
#endif
    serialize(const TSource &source, TChar (&buffer)[N]) {
        return serialize<TSerializer>(source, buffer, N);
    }

    template<typename TWriter>
    class JsonSerializer : public Visitor<size_t> {
    public:
        static const bool producesText = true;

        JsonSerializer(TWriter writer) : _formatter(writer) {}

        FORCE_INLINE size_t visitArray(const CollectionData &array) {
            write('[');
            VariantSlot *slot = array.head();
            while (slot != 0) {
                slot->data()->accept(*this);
                slot = slot->next();
                if (slot == 0)
                    break;
                write(',');
            }
            write(']');
            return bytesWritten();
        }

        size_t visitObject(const CollectionData &object) {
            write('{');
            VariantSlot *slot = object.head();
            while (slot != 0) {
                _formatter.writeString(slot->key());
                write(':');
                slot->data()->accept(*this);
                slot = slot->next();
                if (slot == 0)
                    break;
                write(',');
            }
            write('}');
            return bytesWritten();
        }

        size_t visitFloat(Float value) {
            _formatter.writeFloat(value);
            return bytesWritten();
        }

        size_t visitString(const char *value) {
            _formatter.writeString(value);
            return bytesWritten();
        }

        size_t visitRawJson(const char *data, size_t n) {
            _formatter.writeRaw(data, n);
            return bytesWritten();
        }

        size_t visitSignedInteger(Integer value) {
            _formatter.writeInteger(value);
            return bytesWritten();
        }

        size_t visitUnsignedInteger(UInt value) {
            _formatter.writeInteger(value);
            return bytesWritten();
        }

        size_t visitBoolean(bool value) {
            _formatter.writeBoolean(value);
            return bytesWritten();
        }

        size_t visitNull() {
            _formatter.writeRaw("null");
            return bytesWritten();
        }

    protected:
        size_t bytesWritten() const {
            return _formatter.bytesWritten();
        }

        void write(char c) {
            _formatter.writeRaw(c);
        }

        void write(const char *s) {
            _formatter.writeRaw(s);
        }

    private:
        TextFormatter<TWriter> _formatter;
    };

    template<typename TSource, typename TDestination>
    size_t serializeJson(const TSource &source, TDestination &destination) {
        return serialize<JsonSerializer>(source, destination);
    }

    template<typename TSource>
    size_t serializeJson(const TSource &source, void *buffer, size_t bufferSize) {
        return serialize<JsonSerializer>(source, buffer, bufferSize);
    }

    template<typename TSource>
    size_t measureJson(const TSource &source) {
        return measure<JsonSerializer>(source);
    }

#if ARDUINOJSON_ENABLE_STD_STREAM
                                                                                                                            template <typename T>
inline typename enable_if<IsVisitable<T>::value, std::ostream &>::type
operator<<(std::ostream &os, const T &source) {
  serializeJson(source, os);
  return os;
}
#endif

    template<typename TWriter>
    class PrettyJsonSerializer : public JsonSerializer<TWriter> {
        typedef JsonSerializer<TWriter> base;
    public:
        PrettyJsonSerializer(TWriter writer) : base(writer), _nesting(0) {}

        size_t visitArray(const CollectionData &array) {
            VariantSlot *slot = array.head();
            if (slot) {
                base::write("[\r\n");
                _nesting++;
                while (slot != 0) {
                    indent();
                    slot->data()->accept(*this);
                    slot = slot->next();
                    base::write(slot ? ",\r\n" : "\r\n");
                }
                _nesting--;
                indent();
                base::write("]");
            } else {
                base::write("[]");
            }
            return this->bytesWritten();
        }

        size_t visitObject(const CollectionData &object) {
            VariantSlot *slot = object.head();
            if (slot) {
                base::write("{\r\n");
                _nesting++;
                while (slot != 0) {
                    indent();
                    base::visitString(slot->key());
                    base::write(": ");
                    slot->data()->accept(*this);
                    slot = slot->next();
                    base::write(slot ? ",\r\n" : "\r\n");
                }
                _nesting--;
                indent();
                base::write("}");
            } else {
                base::write("{}");
            }
            return this->bytesWritten();
        }

    private:
        void indent() {
            for (uint8_t i = 0; i < _nesting; i++) base::write(ARDUINOJSON_TAB);
        }

        uint8_t _nesting;
    };

    template<typename TSource, typename TDestination>
    size_t serializeJsonPretty(const TSource &source, TDestination &destination) {
        return serialize<PrettyJsonSerializer>(source, destination);
    }

    template<typename TSource>
    size_t serializeJsonPretty(const TSource &source, void *buffer,
                               size_t bufferSize) {
        return serialize<PrettyJsonSerializer>(source, buffer, bufferSize);
    }

    template<typename TSource>
    size_t measureJsonPretty(const TSource &source) {
        return measure<PrettyJsonSerializer>(source);
    }

    template<typename T>
    inline void swap(T &a, T &b) {
        T t(a);
        a = b;
        b = t;
    }

#if ARDUINOJSON_HAS_RVALUE_REFERENCES

    template<typename T>
    typename remove_reference<T>::type &&move(T &&t) {
        return static_cast<typename remove_reference<T>::type &&>(t);
    }

#else
                                                                                                                            template <typename T>
T& move(T& t) {
  return t;
}
#endif
#if ARDUINOJSON_LITTLE_ENDIAN

    inline void fixEndianess(uint8_t *p, integral_constant<size_t, 8>) {
        swap(p[0], p[7]);
        swap(p[1], p[6]);
        swap(p[2], p[5]);
        swap(p[3], p[4]);
    }

    inline void fixEndianess(uint8_t *p, integral_constant<size_t, 4>) {
        swap(p[0], p[3]);
        swap(p[1], p[2]);
    }

    inline void fixEndianess(uint8_t *p, integral_constant<size_t, 2>) {
        swap(p[0], p[1]);
    }

    inline void fixEndianess(uint8_t *, integral_constant<size_t, 1>) {}

    template<typename T>
    inline void fixEndianess(T &value) {
        fixEndianess(reinterpret_cast<uint8_t *>(&value),
                     integral_constant<size_t, sizeof(T)>());
    }

#else
                                                                                                                            template <typename T>
inline void fixEndianess(T &) {}
#endif

    inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) {
        f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5));
        f[1] = uint8_t((d[1] << 3) | (d[2] >> 5));
        f[2] = uint8_t((d[2] << 3) | (d[3] >> 5));
        f[3] = uint8_t((d[3] << 3) | (d[4] >> 5));
    }

    template<typename TReader, typename TStringStorage>
    class MsgPackDeserializer {
    public:
        MsgPackDeserializer(MemoryPool &pool, TReader reader,
                            TStringStorage stringStorage)
                : _pool(&pool),
                  _reader(reader),
                  _stringStorage(stringStorage),
                  _error(DeserializationError::Ok),
                  _foundSomething(false) {}

        template<typename TFilter>
        DeserializationError parse(VariantData &variant, TFilter filter,
                                   NestingLimit nestingLimit) {
            parseVariant(&variant, filter, nestingLimit);
            return _foundSomething ? _error : DeserializationError::EmptyInput;
        }

    private:
        bool invalidInput() {
            _error = DeserializationError::InvalidInput;
            return false;
        }

        template<typename TFilter>
        bool parseVariant(VariantData *variant, TFilter filter,
                          NestingLimit nestingLimit) {
            uint8_t code = 0;  // TODO: why do we need to initialize this variable?
            if (!readByte(code))
                return false;
            _foundSomething = true;
            bool allowValue = filter.allowValue();
            switch (code) {
                case 0xc0:
                    return true;
                case 0xc1:
                    return invalidInput();
                case 0xc2:
                    if (allowValue)
                        variant->setBoolean(false);
                    return true;
                case 0xc3:
                    if (allowValue)
                        variant->setBoolean(true);
                    return true;
                case 0xc4:  // bin 8 (not supported)
                    return skipString<uint8_t>();
                case 0xc5:  // bin 16 (not supported)
                    return skipString<uint16_t>();
                case 0xc6:  // bin 32 (not supported)
                    return skipString<uint32_t>();
                case 0xc7:  // ext 8 (not supported)
                    return skipExt<uint8_t>();
                case 0xc8:  // ext 16 (not supported)
                    return skipExt<uint16_t>();
                case 0xc9:  // ext 32 (not supported)
                    return skipExt<uint32_t>();
                case 0xca:
                    if (allowValue)
                        return readFloat<float>(variant);
                    else
                        return skipBytes(4);
                case 0xcb:
                    if (allowValue)
                        return readDouble<double>(variant);
                    else
                        return skipBytes(8);
                case 0xcc:
                    if (allowValue)
                        return readInteger<uint8_t>(variant);
                    else
                        return skipBytes(1);
                case 0xcd:
                    if (allowValue)
                        return readInteger<uint16_t>(variant);
                    else
                        return skipBytes(2);
                case 0xce:
                    if (allowValue)
                        return readInteger<uint32_t>(variant);
                    else
                        return skipBytes(4);
                case 0xcf:
#if ARDUINOJSON_USE_LONG_LONG
                                                                                                                                            if (allowValue)
          return readInteger<uint64_t>(variant);
        else
          return skipBytes(8);
#else
                    return skipBytes(8);  // not supported
#endif
                case 0xd0:
                    if (allowValue)
                        return readInteger<int8_t>(variant);
                    else
                        return skipBytes(1);
                case 0xd1:
                    if (allowValue)
                        return readInteger<int16_t>(variant);
                    else
                        return skipBytes(2);
                case 0xd2:
                    if (allowValue)
                        return readInteger<int32_t>(variant);
                    else
                        return skipBytes(4);
                case 0xd3:
#if ARDUINOJSON_USE_LONG_LONG
                                                                                                                                            if (allowValue)
          return readInteger<int64_t>(variant);
        else
          return skipBytes(8);  // not supported
#else
                    return skipBytes(8);
#endif
                case 0xd4:  // fixext 1 (not supported)
                    return skipBytes(2);
                case 0xd5:  // fixext 2 (not supported)
                    return skipBytes(3);
                case 0xd6:  // fixext 4 (not supported)
                    return skipBytes(5);
                case 0xd7:  // fixext 8 (not supported)
                    return skipBytes(9);
                case 0xd8:  // fixext 16 (not supported)
                    return skipBytes(17);
                case 0xd9:
                    if (allowValue)
                        return readString<uint8_t>(variant);
                    else
                        return skipString<uint8_t>();
                case 0xda:
                    if (allowValue)
                        return readString<uint16_t>(variant);
                    else
                        return skipString<uint16_t>();
                case 0xdb:
                    if (allowValue)
                        return readString<uint32_t>(variant);
                    else
                        return skipString<uint32_t>();
                case 0xdc:
                    return readArray<uint16_t>(variant, filter, nestingLimit);
                case 0xdd:
                    return readArray<uint32_t>(variant, filter, nestingLimit);
                case 0xde:
                    return readObject<uint16_t>(variant, filter, nestingLimit);
                case 0xdf:
                    return readObject<uint32_t>(variant, filter, nestingLimit);
            }
            switch (code & 0xf0) {
                case 0x80:
                    return readObject(variant, code & 0x0F, filter, nestingLimit);
                case 0x90:
                    return readArray(variant, code & 0x0F, filter, nestingLimit);
            }
            if ((code & 0xe0) == 0xa0) {
                if (allowValue)
                    return readString(variant, code & 0x1f);
                else
                    return skipBytes(code & 0x1f);
            }
            if (allowValue)
                variant->setInteger(static_cast<int8_t>(code));
            return true;
        }

        bool readByte(uint8_t &value) {
            int c = _reader.read();
            if (c < 0) {
                _error = DeserializationError::IncompleteInput;
                return false;
            }
            value = static_cast<uint8_t>(c);
            return true;
        }

        bool readBytes(uint8_t *p, size_t n) {
            if (_reader.readBytes(reinterpret_cast<char *>(p), n) == n)
                return true;
            _error = DeserializationError::IncompleteInput;
            return false;
        }

        template<typename T>
        bool readBytes(T &value) {
            return readBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value));
        }

        bool skipBytes(size_t n) {
            for (; n; --n) {
                if (_reader.read() < 0) {
                    _error = DeserializationError::IncompleteInput;
                    return false;
                }
            }
            return true;
        }

        template<typename T>
        bool readInteger(T &value) {
            if (!readBytes(value))
                return false;
            fixEndianess(value);
            return true;
        }

        template<typename T>
        bool readInteger(VariantData *variant) {
            T value;
            if (!readInteger(value))
                return false;
            variant->setInteger(value);
            return true;
        }

        template<typename T>
        typename enable_if<sizeof(T) == 4, bool>::type readFloat(
                VariantData *variant) {
            T value;
            if (!readBytes(value))
                return false;
            fixEndianess(value);
            variant->setFloat(value);
            return true;
        }

        template<typename T>
        typename enable_if<sizeof(T) == 8, bool>::type readDouble(
                VariantData *variant) {
            T value;
            if (!readBytes(value))
                return false;
            fixEndianess(value);
            variant->setFloat(value);
            return true;
        }

        template<typename T>
        typename enable_if<sizeof(T) == 4, bool>::type readDouble(
                VariantData *variant) {
            uint8_t i[8];  // input is 8 bytes
            T value;       // output is 4 bytes
            uint8_t *o = reinterpret_cast<uint8_t *>(&value);
            if (!readBytes(i, 8))
                return false;
            doubleToFloat(i, o);
            fixEndianess(value);
            variant->setFloat(value);
            return true;
        }

        template<typename T>
        bool readString(VariantData *variant) {
            T size;
            if (!readInteger(size))
                return false;
            return readString(variant, size);
        }

        template<typename T>
        bool readString() {
            T size;
            if (!readInteger(size))
                return false;
            return readString(size);
        }

        template<typename T>
        bool skipString() {
            T size;
            if (!readInteger(size))
                return false;
            return skipBytes(size);
        }

        bool readString(VariantData *variant, size_t n) {
            if (!readString(n))
                return false;
            variant->setStringPointer(_stringStorage.save(),
                                      typename TStringStorage::storage_policy());
            return true;
        }

        bool readString(size_t n) {
            _stringStorage.startString();
            for (; n; --n) {
                uint8_t c;
                if (!readBytes(c))
                    return false;
                _stringStorage.append(static_cast<char>(c));
            }
            _stringStorage.append('\0');
            if (!_stringStorage.isValid()) {
                _error = DeserializationError::NoMemory;
                return false;
            }
            return true;
        }

        template<typename TSize, typename TFilter>
        bool readArray(VariantData *variant, TFilter filter,
                       NestingLimit nestingLimit) {
            TSize size;
            if (!readInteger(size))
                return false;
            return readArray(variant, size, filter, nestingLimit);
        }

        template<typename TFilter>
        bool readArray(VariantData *variant, size_t n, TFilter filter,
                       NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            bool allowArray = filter.allowArray();
            CollectionData *array = allowArray ? &variant->toArray() : 0;
            TFilter memberFilter = filter[0U];
            for (; n; --n) {
                VariantData *value;
                if (memberFilter.allow()) {
                    value = array->addElement(_pool);
                    if (!value) {
                        _error = DeserializationError::NoMemory;
                        return false;
                    }
                } else {
                    value = 0;
                }
                if (!parseVariant(value, memberFilter, nestingLimit.decrement()))
                    return false;
            }
            return true;
        }

        template<typename TSize, typename TFilter>
        bool readObject(VariantData *variant, TFilter filter,
                        NestingLimit nestingLimit) {
            TSize size;
            if (!readInteger(size))
                return false;
            return readObject(variant, size, filter, nestingLimit);
        }

        template<typename TFilter>
        bool readObject(VariantData *variant, size_t n, TFilter filter,
                        NestingLimit nestingLimit) {
            if (nestingLimit.reached()) {
                _error = DeserializationError::TooDeep;
                return false;
            }
            CollectionData *object = filter.allowObject() ? &variant->toObject() : 0;
            for (; n; --n) {
                if (!readKey())
                    return false;
                const char *key = _stringStorage.c_str();
                TFilter memberFilter = filter[key];
                VariantData *member;
                if (memberFilter.allow()) {
                    key = _stringStorage.save();
                    VariantSlot *slot = object->addSlot(_pool);
                    if (!slot) {
                        _error = DeserializationError::NoMemory;
                        return false;
                    }
                    slot->setKey(key, typename TStringStorage::storage_policy());
                    member = slot->data();
                } else {
                    member = 0;
                }
                if (!parseVariant(member, memberFilter, nestingLimit.decrement()))
                    return false;
            }
            return true;
        }

        bool readKey() {
            uint8_t code;
            if (!readByte(code))
                return false;
            if ((code & 0xe0) == 0xa0)
                return readString(code & 0x1f);
            switch (code) {
                case 0xd9:
                    return readString<uint8_t>();
                case 0xda:
                    return readString<uint16_t>();
                case 0xdb:
                    return readString<uint32_t>();
                default:
                    return invalidInput();
            }
        }

        template<typename T>
        bool skipExt() {
            T size;
            if (!readInteger(size))
                return false;
            return skipBytes(size + 1);
        }

        MemoryPool *_pool;
        TReader _reader;
        TStringStorage _stringStorage;
        DeserializationError _error;
        bool _foundSomething;
    };

    template<typename TString>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, const TString &input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                                AllowAllFilter());
    }

    template<typename TString>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, const TString &input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TString>
    DeserializationError deserializeMsgPack(JsonDocument &doc, const TString &input,
                                            NestingLimit nestingLimit,
                                            Filter filter) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TStream>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TStream &input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                                AllowAllFilter());
    }

    template<typename TStream>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TStream &input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TStream>
    DeserializationError deserializeMsgPack(JsonDocument &doc, TStream &input,
                                            NestingLimit nestingLimit,
                                            Filter filter) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TChar *input,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit,
                                                AllowAllFilter());
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TChar *input, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input,
                                            NestingLimit nestingLimit,
                                            Filter filter) {
        return deserialize<MsgPackDeserializer>(doc, input, nestingLimit, filter);
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TChar *input, size_t inputSize,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
                                                AllowAllFilter());
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(
            JsonDocument &doc, TChar *input, size_t inputSize, Filter filter,
            NestingLimit nestingLimit = NestingLimit()) {
        return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
                                                filter);
    }

    template<typename TChar>
    DeserializationError deserializeMsgPack(JsonDocument &doc, TChar *input,
                                            size_t inputSize,
                                            NestingLimit nestingLimit,
                                            Filter filter) {
        return deserialize<MsgPackDeserializer>(doc, input, inputSize, nestingLimit,
                                                filter);
    }

    template<typename TWriter>
    class MsgPackSerializer : public Visitor<size_t> {
    public:
        static const bool producesText = false;

        MsgPackSerializer(TWriter writer) : _writer(writer) {}

        template<typename T>
        typename enable_if<sizeof(T) == 4, size_t>::type visitFloat(T value32) {
            writeByte(0xCA);
            writeInteger(value32);
            return bytesWritten();
        }

        template<typename T>
        ARDUINOJSON_NO_SANITIZE("float-cast-overflow")
        typename enable_if<sizeof(T) == 8, size_t>::type visitFloat(T value64) {
            float value32 = float(value64);
            if (value32 == value64) {
                writeByte(0xCA);
                writeInteger(value32);
            } else {
                writeByte(0xCB);
                writeInteger(value64);
            }
            return bytesWritten();
        }

        size_t visitArray(const CollectionData &array) {
            size_t n = array.size();
            if (n < 0x10) {
                writeByte(uint8_t(0x90 + array.size()));
            } else if (n < 0x10000) {
                writeByte(0xDC);
                writeInteger(uint16_t(n));
            } else {
                writeByte(0xDD);
                writeInteger(uint32_t(n));
            }
            for (VariantSlot *slot = array.head(); slot; slot = slot->next()) {
                slot->data()->accept(*this);
            }
            return bytesWritten();
        }

        size_t visitObject(const CollectionData &object) {
            size_t n = object.size();
            if (n < 0x10) {
                writeByte(uint8_t(0x80 + n));
            } else if (n < 0x10000) {
                writeByte(0xDE);
                writeInteger(uint16_t(n));
            } else {
                writeByte(0xDF);
                writeInteger(uint32_t(n));
            }
            for (VariantSlot *slot = object.head(); slot; slot = slot->next()) {
                visitString(slot->key());
                slot->data()->accept(*this);
            }
            return bytesWritten();
        }

        size_t visitString(const char *value) {
            ARDUINOJSON_ASSERT(value != NULL);
            size_t n = strlen(value);
            if (n < 0x20) {
                writeByte(uint8_t(0xA0 + n));
            } else if (n < 0x100) {
                writeByte(0xD9);
                writeInteger(uint8_t(n));
            } else if (n < 0x10000) {
                writeByte(0xDA);
                writeInteger(uint16_t(n));
            } else {
                writeByte(0xDB);
                writeInteger(uint32_t(n));
            }
            writeBytes(reinterpret_cast<const uint8_t *>(value), n);
            return bytesWritten();
        }

        size_t visitRawJson(const char *data, size_t size) {
            writeBytes(reinterpret_cast<const uint8_t *>(data), size);
            return bytesWritten();
        }

        size_t visitSignedInteger(Integer value) {
            if (value > 0) {
                visitUnsignedInteger(static_cast<UInt>(value));
            } else if (value >= -0x20) {
                writeInteger(int8_t(value));
            } else if (value >= -0x80) {
                writeByte(0xD0);
                writeInteger(int8_t(value));
            } else if (value >= -0x8000) {
                writeByte(0xD1);
                writeInteger(int16_t(value));
            }
#if ARDUINOJSON_USE_LONG_LONG
                else if (value >= -0x80000000LL)
#else
            else
#endif
            {
                writeByte(0xD2);
                writeInteger(int32_t(value));
            }
#if ARDUINOJSON_USE_LONG_LONG
                                                                                                                                    else {
      writeByte(0xD3);
      writeInteger(int64_t(value));
    }
#endif
            return bytesWritten();
        }

        size_t visitUnsignedInteger(UInt value) {
            if (value <= 0x7F) {
                writeInteger(uint8_t(value));
            } else if (value <= 0xFF) {
                writeByte(0xCC);
                writeInteger(uint8_t(value));
            } else if (value <= 0xFFFF) {
                writeByte(0xCD);
                writeInteger(uint16_t(value));
            }
#if ARDUINOJSON_USE_LONG_LONG
                else if (value <= 0xFFFFFFFF)
#else
            else
#endif
            {
                writeByte(0xCE);
                writeInteger(uint32_t(value));
            }
#if ARDUINOJSON_USE_LONG_LONG
                                                                                                                                    else {
      writeByte(0xCF);
      writeInteger(uint64_t(value));
    }
#endif
            return bytesWritten();
        }

        size_t visitBoolean(bool value) {
            writeByte(value ? 0xC3 : 0xC2);
            return bytesWritten();
        }

        size_t visitNull() {
            writeByte(0xC0);
            return bytesWritten();
        }

    private:
        size_t bytesWritten() const {
            return _writer.count();
        }

        void writeByte(uint8_t c) {
            _writer.write(c);
        }

        void writeBytes(const uint8_t *p, size_t n) {
            _writer.write(p, n);
        }

        template<typename T>
        void writeInteger(T value) {
            fixEndianess(value);
            writeBytes(reinterpret_cast<uint8_t *>(&value), sizeof(value));
        }

        CountingDecorator<TWriter> _writer;
    };

    template<typename TSource, typename TDestination>
    inline size_t serializeMsgPack(const TSource &source, TDestination &output) {
        return serialize<MsgPackSerializer>(source, output);
    }

    template<typename TSource>
    inline size_t serializeMsgPack(const TSource &source, void *output,
                                   size_t size) {
        return serialize<MsgPackSerializer>(source, output, size);
    }

    template<typename TSource>
    inline size_t measureMsgPack(const TSource &source) {
        return measure<MsgPackSerializer>(source);
    }
}  // namespace ARDUINOJSON_NAMESPACE
#ifdef __GNUC__
#define ARDUINOJSON_PRAGMA(x) _Pragma(#x)
#define ARDUINOJSON_COMPILE_ERROR(msg) ARDUINOJSON_PRAGMA(GCC error msg)
#define ARDUINOJSON_STRINGIFY(S) #S
#define ARDUINOJSON_DEPRECATION_ERROR(X, Y) \
  ARDUINOJSON_COMPILE_ERROR(ARDUINOJSON_STRINGIFY(X is a Y from ArduinoJson 5. Please see https:/\/arduinojson.org/upgrade to learn how to upgrade your program to ArduinoJson version 6))
#define StaticJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(StaticJsonBuffer, class)
#define DynamicJsonBuffer ARDUINOJSON_DEPRECATION_ERROR(DynamicJsonBuffer, class)
#define JsonBuffer ARDUINOJSON_DEPRECATION_ERROR(JsonBuffer, class)
#define RawJson ARDUINOJSON_DEPRECATION_ERROR(RawJson, function)
#endif
namespace ArduinoJson {
    typedef ARDUINOJSON_NAMESPACE::ArrayConstRef JsonArrayConst;
    typedef ARDUINOJSON_NAMESPACE::ArrayRef JsonArray;
    typedef ARDUINOJSON_NAMESPACE::Float JsonFloat;
    typedef ARDUINOJSON_NAMESPACE::Integer JsonInteger;
    typedef ARDUINOJSON_NAMESPACE::ObjectConstRef JsonObjectConst;
    typedef ARDUINOJSON_NAMESPACE::ObjectRef JsonObject;
    typedef ARDUINOJSON_NAMESPACE::Pair JsonPair;
    typedef ARDUINOJSON_NAMESPACE::PairConst JsonPairConst;
    typedef ARDUINOJSON_NAMESPACE::String JsonString;
    typedef ARDUINOJSON_NAMESPACE::UInt JsonUInt;
    typedef ARDUINOJSON_NAMESPACE::VariantConstRef JsonVariantConst;
    typedef ARDUINOJSON_NAMESPACE::VariantRef JsonVariant;
    using ARDUINOJSON_NAMESPACE::BasicJsonDocument;
    using ARDUINOJSON_NAMESPACE::copyArray;
    using ARDUINOJSON_NAMESPACE::DeserializationError;
    using ARDUINOJSON_NAMESPACE::deserializeJson;
    using ARDUINOJSON_NAMESPACE::deserializeMsgPack;
    using ARDUINOJSON_NAMESPACE::DynamicJsonDocument;
    using ARDUINOJSON_NAMESPACE::JsonDocument;
    using ARDUINOJSON_NAMESPACE::measureJson;
    using ARDUINOJSON_NAMESPACE::serialized;
    using ARDUINOJSON_NAMESPACE::serializeJson;
    using ARDUINOJSON_NAMESPACE::serializeJsonPretty;
    using ARDUINOJSON_NAMESPACE::serializeMsgPack;
    using ARDUINOJSON_NAMESPACE::StaticJsonDocument;
    namespace DeserializationOption {
        using ARDUINOJSON_NAMESPACE::Filter;
        using ARDUINOJSON_NAMESPACE::NestingLimit;
    }  // namespace DeserializationOption
}  // namespace ArduinoJson

using namespace ArduinoJson;

#else

#error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp

#endif