json.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_JSON_HPP
#define JOIN_DATA_JSON_HPP
 
// libjoin.
#include <join/atodpow.hpp>
#include <join/dtoa.hpp>
#include <join/sax.hpp>
 
// C++.
#include <codecvt>
#include <memory>
#include <locale>
 
namespace join
{
    namespace details
    {
        constexpr char digitPairs[201] = {
            "00010203040506070809"
            "10111213141516171819"
            "20212223242526272829"
            "30313233343536373839"
            "40414243444546474849"
            "50515253545556575859"
            "60616263646566676869"
            "70717273747576777879"
            "80818283848586878889"
            "90919293949596979899"};
 
        struct UnescapedTable
        {
            uint8_t data[256];
 
            constexpr UnescapedTable ()
            : data{}
            {
                for (int i = 0; i < 32; ++i)
                {
                    data[i] = 'u';
                }
                data[static_cast<unsigned char> ('\b')] = 'b';
                data[static_cast<unsigned char> ('\t')] = 't';
                data[static_cast<unsigned char> ('\n')] = 'n';
                data[static_cast<unsigned char> ('\f')] = 'f';
                data[static_cast<unsigned char> ('\r')] = 'r';
                data[static_cast<unsigned char> ('"')] = '"';
                data[static_cast<unsigned char> ('\\')] = '\\';
            }
        };
 
        constexpr UnescapedTable unescapedLookup{};
    }
 
    struct LocaleDelete
    {
        constexpr LocaleDelete () noexcept = default;
 
        void operator() (locale_t loc) noexcept
        {
            freelocale (loc);
        }
    };
 
    using LocalePtr = std::unique_ptr<std::remove_pointer_t<locale_t>, LocaleDelete>;
 
    enum class JsonErrc
    {
        InvalidComment = 1,   
        InvalidEscaping,      
        InvalidEncoding,      
        IllegalCharacter,     
        MissingCurlyBracket,  
        MissingSquareBracket, 
        MissingQuote,         
        MissingColon,         
        MissingComma,         
        EndOfFile,            
    };
 
    class JsonCategory : public std::error_category
    {
    public:
        virtual const char* name () const noexcept;
 
        virtual std::string message (int code) const;
    };
 
    const std::error_category& jsonCategory () noexcept;
 
    std::error_code make_error_code (JsonErrc code) noexcept;
 
    std::error_condition make_error_condition (JsonErrc code) noexcept;
 
    class JsonWriter : public StreamWriter
    {
    public:
        JsonWriter (std::ostream& document, size_t indentation = 0)
        : StreamWriter (document)
        , _indentation (indentation)
        {
        }
 
        JsonWriter (const JsonWriter& other) = delete;
 
        JsonWriter& operator= (const JsonWriter& other) = delete;
 
        JsonWriter (JsonWriter&& other) = delete;
 
        JsonWriter& operator= (JsonWriter&& other) = delete;
 
        virtual ~JsonWriter () = default;
 
        virtual int setNull () override
        {
            array ();
            append4 ("null");
            _first = false;
            return 0;
        }
 
        virtual int setBool (bool value) override
        {
            array ();
            if (value)
            {
                append4 ("true");
            }
            else
            {
                append5 ("false");
            }
            _first = false;
            return 0;
        }
 
        virtual int setInt (int32_t value) override
        {
            array ();
            writeInt (value);
            _first = false;
            return 0;
        }
 
        virtual int setUint (uint32_t value) override
        {
            array ();
            writeUint (value);
            _first = false;
            return 0;
        }
 
        virtual int setInt64 (int64_t value) override
        {
            array ();
            writeInt64 (value);
            _first = false;
            return 0;
        }
 
        virtual int setUint64 (uint64_t value) override
        {
            array ();
            writeUint64 (value);
            _first = false;
            return 0;
        }
 
        virtual int setDouble (double value) override
        {
            array ();
            uint64_t bits;
            memcpy (&bits, &value, sizeof (bits));
            const bool neg = (bits >> 63) != 0;
            const uint64_t exp = (bits >> 52) & 0x7FFULL;
            const uint64_t frac = bits & 0x000FFFFFFFFFFFFFULL;
            if (exp != 0x7FFULL)
            {
                writeDouble (value);
            }
            else if (frac != 0)
            {
                if (neg)
                {
                    append4 ("-NaN");
                }
                else
                {
                    append3 ("NaN");
                }
            }
            else
            {
                if (neg)
                {
                    append4 ("-Inf");
                }
                else
                {
                    append3 ("Inf");
                }
            }
            _first = false;
            return 0;
        }
 
        virtual int setString (const std::string& value) override
        {
            array ();
            append ('"');
            if (writeEscaped (value) == -1)
            {
                return -1;
            }
            append ('"');
            _first = false;
            return 0;
        }
 
        virtual int startArray ([[maybe_unused]] uint32_t size = 0) override
        {
            array ();
            append ('[');
            _tab.append (_indentation, ' ');
            _first = true;
            _stack.push (true);
            return 0;
        }
 
        virtual int stopArray () override
        {
            _tab.erase (_tab.size () - _indentation);
            if (!_first)
            {
                endLine ();
                indent ();
            }
            append (']');
            _first = false;
            _stack.pop ();
            return 0;
        }
 
        virtual int startObject ([[maybe_unused]] uint32_t size = 0) override
        {
            array ();
            append ('{');
            _tab.append (_indentation, ' ');
            _first = true;
            _stack.push (false);
            return 0;
        }
 
        virtual int setKey (const Value& key) override
        {
            if (JOIN_UNLIKELY (!key.isString ()))
            {
                join::lastError = make_error_code (SaxErrc::InvalidKey);
                return -1;
            }
            comma ();
            endLine ();
            indent ();
            append ('"');
            if (writeEscaped (key.getString ()) == -1)
            {
                return -1;
            }
            append ('"');
            append (':');
            space ();
            _first = true;
            return 0;
        }
 
        virtual int stopObject () override
        {
            _tab.erase (_tab.size () - _indentation);
            if (!_first)
            {
                endLine ();
                indent ();
            }
            append ('}');
            _first = false;
            _stack.pop ();
            return 0;
        }
 
    protected:
        virtual void writeInt (int32_t value)
        {
            if (value == std::numeric_limits<int32_t>::min ())
            {
                append ('-');
                writeUint64 (static_cast<uint64_t> (std::numeric_limits<int32_t>::max ()) + 1);
                return;
            }
 
            if (value < 0)
            {
                append ('-');
                writeUint64 (static_cast<uint64_t> (-value));
                return;
            }
 
            writeUint64 (static_cast<uint64_t> (value));
        }
 
        virtual void writeUint (uint32_t value)
        {
            writeUint64 (static_cast<uint64_t> (value));
        }
 
        virtual void writeInt64 (int64_t value)
        {
            if (value == std::numeric_limits<int64_t>::min ())
            {
                append ('-');
                writeUint64 (static_cast<uint64_t> (std::numeric_limits<int64_t>::max ()) + 1);
                return;
            }
 
            if (value < 0)
            {
                append ('-');
                writeUint64 (static_cast<uint64_t> (-value));
                return;
            }
 
            writeUint64 (static_cast<uint64_t> (value));
        }
 
        virtual void writeUint64 (uint64_t value)
        {
            if (value == 0)
            {
                append ('0');
                return;
            }
 
            char buffer[20];
            char* ptr = buffer + 20;
 
            while (value >= 100)
            {
                uint64_t r = value % 100;
                value /= 100;
                ptr -= 2;
                std::memcpy (ptr, &details::digitPairs[r * 2], 2);
            }
 
            if (value >= 10)
            {
                ptr -= 2;
                std::memcpy (ptr, &details::digitPairs[value * 2], 2);
            }
            else
            {
                *--ptr = '0' + static_cast<char> (value);
            }
 
            size_t length = (buffer + 20) - ptr;
            append (ptr, length);
        }
 
        virtual void writeDouble (double value)
        {
            char buf[25];
            char* end = join::dtoa (buf, value);
            append (buf, end - buf);
        }
 
        virtual int utf8Codepoint (std::string::const_iterator& cur, std::string::const_iterator& end,
                                   uint32_t& codepoint)
        {
            uint8_t u0 = static_cast<uint8_t> (*cur);
            if (u0 < 0x80)
            {
                codepoint = u0;
                return 0;
            }
 
            if (++cur == end)
            {
                return -1;
            }
 
            uint8_t u1 = static_cast<uint8_t> (*cur);
            if (u0 < 0xE0)
            {
                codepoint = ((u0 & 0x1F) << 6) | (u1 & 0x3F);
                if (codepoint < 0x80)
                {
                    return -1;
                }
                return 0;
            }
 
            if (++cur == end)
            {
                return -1;
            }
 
            uint8_t u2 = static_cast<uint8_t> (*cur);
            if (u0 < 0xF0)
            {
                codepoint = ((u0 & 0x0F) << 12) | ((u1 & 0x3F) << 6) | (u2 & 0x3F);
                if ((codepoint > 0xD7FF) && (codepoint < 0xE000))
                {
                    return -1;
                }
                if (codepoint < 0x800)
                {
                    return -1;
                }
                return 0;
            }
 
            if (++cur == end)
            {
                return -1;
            }
 
            uint8_t u3 = static_cast<uint8_t> (*cur);
            if (u0 < 0xF8)
            {
                codepoint = ((u0 & 0x07) << 18) | ((u1 & 0x3F) << 12) | ((u2 & 0x3F) << 6) | (u3 & 0x3F);
                if (codepoint < 0x10000)
                {
                    return -1;
                }
                return 0;
            }
 
            return -1;
        }
 
        virtual int writeEscaped (const std::string& value)
        {
            auto cur = value.cbegin ();
            auto end = value.cend ();
 
            while (cur != end)
            {
                auto beg = cur;
 
                while (cur != end && details::unescapedLookup.data[static_cast<uint8_t> (*cur)] == 0)
                {
                    ++cur;
                }
 
                if (cur != beg)
                {
                    append (&(*beg), cur - beg);
                }
 
                if (cur == end)
                {
                    break;
                }
 
                uint8_t ch = static_cast<uint8_t> (*cur);
                uint8_t esc = details::unescapedLookup.data[ch];
                if (esc == 'u')
                {
                    uint32_t codepoint = 0;
                    char hex[5];
 
                    if (utf8Codepoint (cur, end, codepoint) == -1)
                    {
                        join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                        return -1;
                    }
 
                    if (codepoint <= 0xFFFF)
                    {
                        append2 ("\\u");
                        snprintf (hex, sizeof (hex), "%04x", uint16_t (codepoint));
                        append4 (hex);
                    }
                    else
                    {
                        codepoint -= 0x10000;
                        append2 ("\\u");
                        snprintf (hex, sizeof (hex), "%04x", uint16_t (0xD800 + ((codepoint >> 10) & 0x3FF)));
                        append4 (hex);
                        append2 ("\\u");
                        snprintf (hex, sizeof (hex), "%04x", uint16_t (0xDC00 + (codepoint & 0x3FF)));
                        append4 (hex);
                    }
                }
                else
                {
                    char escapeSeq[2] = {'\\', static_cast<char> (esc)};
                    append2 (escapeSeq);
                }
 
                ++cur;
            }
 
            return 0;
        }
 
        inline void comma () noexcept
        {
            if (!_stack.empty () && !_first)
            {
                append (',');
            }
        }
 
        inline void indent () noexcept
        {
            if (_indentation)
            {
                append (_tab.c_str (), _tab.size ());
            }
        }
 
        inline void space () noexcept
        {
            if (_indentation)
            {
                append (' ');
            }
        }
 
        inline void endLine () noexcept
        {
            if (_indentation)
            {
                append ('\n');
            }
        }
 
        inline void array () noexcept
        {
            comma ();
            if (!_stack.empty () && _stack.top ())
            {
                endLine ();
                indent ();
            }
        }
 
        std::stack<bool> _stack;
 
        size_t _indentation;
 
        std::string _tab;
 
        bool _first = true;
    };
 
    class JsonCanonicalizer : public JsonWriter
    {
    public:
        JsonCanonicalizer (std::ostream& document)
        : JsonWriter (document, 0)
        {
        }
 
        JsonCanonicalizer (const JsonCanonicalizer& other) = delete;
 
        JsonCanonicalizer& operator= (const JsonCanonicalizer& other) = delete;
 
        JsonCanonicalizer (JsonCanonicalizer&& other) = delete;
 
        JsonCanonicalizer& operator= (JsonCanonicalizer&& other) = delete;
 
        virtual ~JsonCanonicalizer () = default;
 
        virtual int setDouble (double value) override
        {
            array ();
            if (std::isfinite (value))
            {
                if ((std::trunc (value) == value) && (value >= 0) &&
                    (value < static_cast<double> (std::numeric_limits<uint64_t>::max ())))
                {
                    writeUint64 (static_cast<uint64_t> (value));
                }
                else if ((std::trunc (value) == value) &&
                         (value >= static_cast<double> (std::numeric_limits<int64_t>::min ())) &&
                         (value < static_cast<double> (std::numeric_limits<int64_t>::max ())))
                {
                    writeInt64 (static_cast<int64_t> (value));
                }
                else
                {
                    writeDouble (value);
                }
            }
            else
            {
                append4 ("null");
            }
            _first = false;
            return 0;
        }
 
    protected:
        virtual int setObject (const Object& object) override
        {
            startObject (object.size ());
            std::vector<const Member*> members;
            std::transform (object.begin (), object.end (), std::back_inserter (members), [] (const Member& member) {
                return &member;
            });
            std::sort (members.begin (), members.end (), [] (const Member* a, const Member* b) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
                std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> cvt_utf8_utf16;
#pragma GCC diagnostic pop
                std::u16string wa = cvt_utf8_utf16.from_bytes (a->first.getString ().data ());
                std::u16string wb = cvt_utf8_utf16.from_bytes (b->first.getString ().data ());
                return wa < wb;
            });
            for (auto const& member : members)
            {
                setKey (member->first);
                setValue (member->second);
            }
            stopObject ();
            return 0;
        }
 
        virtual void writeDouble (double value) noexcept override
        {
            char beg[25];
            char* end = join::dtoa (beg, value);
            for (char* pos = beg; pos < end; ++pos)
            {
                append (*pos);
                if ((*pos == 'e') && (*(pos + 1) != '-'))
                {
                    append ('+');
                }
            }
        }
    };
 
    enum JsonReadMode
    {
        None = 0,                    
        ParseComments = 1L << 0,     
        ValidateEncoding = 1L << 1,  
        StopParsingOnDone = 1L << 2, 
    };
 
    constexpr JsonReadMode operator& (JsonReadMode a, JsonReadMode b) noexcept
    {
        return JsonReadMode (static_cast<int> (a) & static_cast<int> (b));
    }
 
    constexpr JsonReadMode operator| (JsonReadMode a, JsonReadMode b) noexcept
    {
        return JsonReadMode (static_cast<int> (a) | static_cast<int> (b));
    }
 
    constexpr const JsonReadMode& operator&= (JsonReadMode& a, JsonReadMode b) noexcept
    {
        return a = a & b;
    }
 
    constexpr const JsonReadMode& operator|= (JsonReadMode& a, JsonReadMode b) noexcept
    {
        return a = a | b;
    }
 
    class JsonReader : public StreamReader
    {
    public:
        JsonReader (Value& root)
        : StreamReader (root)
        {
        }
 
        JsonReader (const JsonReader& other) = delete;
 
        JsonReader& operator= (const JsonReader& other) = delete;
 
        JsonReader (JsonReader&& other) = delete;
 
        JsonReader& operator= (JsonReader&& other) = delete;
 
        virtual ~JsonReader () = default;
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (const char* document, size_t length)
        {
            StringView in (document, length);
            return read<ReadMode> (in);
        }
 
        int deserialize (const char* document, size_t length) override
        {
            return deserialize<> (document, length);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (const char* first, const char* last)
        {
            StringView in (first, last);
            return read<ReadMode> (in);
        }
 
        int deserialize (const char* first, const char* last) override
        {
            return deserialize<> (first, last);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (const std::string& document)
        {
            StringView in (document.c_str (), document.size ());
            return read<ReadMode> (in);
        }
 
        int deserialize (const std::string& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::stringstream& document)
        {
            StringStreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::stringstream& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::istringstream& document)
        {
            StringStreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::istringstream& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::fstream& document)
        {
            FileStreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::fstream& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::ifstream& document)
        {
            FileStreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::ifstream& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::iostream& document)
        {
            StreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::iostream& document) override
        {
            return deserialize<> (document);
        }
 
        template <JsonReadMode ReadMode = JsonReadMode::None>
        int deserialize (std::istream& document)
        {
            StreamView in (document);
            return read<ReadMode> (in);
        }
 
        int deserialize (std::istream& document) override
        {
            return deserialize<> (document);
        }
 
    protected:
        template <JsonReadMode ReadMode, typename ViewType>
        int read (ViewType& document)
        {
            if (skipWhitespaces<ReadMode> (document) != 0)
            {
                return -1;
            }
 
            if (readValue<ReadMode> (document) != 0)
            {
                return -1;
            }
 
            if (ReadMode & JsonReadMode::StopParsingOnDone)
            {
                return 0;
            }
 
            if (skipWhitespaces<ReadMode> (document) != 0)
            {
                return -1;
            }
 
            if (document.peek () != std::char_traits<char>::eof ())
            {
                join::lastError = make_error_code (SaxErrc::ExtraData);
                return -1;
            }
 
            return 0;
        }
 
        template <JsonReadMode ReadMode, typename ViewType>
        int readValue (ViewType& document)
        {
            int ch = document.peek ();
            switch (ch)
            {
                case '[':
                    document.get ();
                    return readArray<ReadMode> (document);
                case '{':
                    document.get ();
                    return readObject<ReadMode> (document);
                case '"':
                    document.get ();
                    return readString (document);
                case 'n':
                    document.get ();
                    return readNull (document);
                case 't':
                    document.get ();
                    return readTrue (document);
                case 'f':
                    document.get ();
                    return readFalse (document);
                default:
                    return readNumber (document);
            }
        }
 
        template <typename ViewType>
        int readNull (ViewType& document)
        {
            if (JOIN_UNLIKELY ((document.get () != 'u') || (document.get () != 'l') || (document.get () != 'l')))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setNull ();
        }
 
        template <typename ViewType>
        int readTrue (ViewType& document)
        {
            if (JOIN_UNLIKELY ((document.get () != 'r') || (document.get () != 'u') || (document.get () != 'e')))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setBool (true);
        }
 
        template <typename ViewType>
        int readFalse (ViewType& document)
        {
            if (JOIN_UNLIKELY ((document.get () != 'a') || (document.get () != 'l') || (document.get () != 's') ||
                               (document.get () != 'e')))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setBool (false);
        }
 
        template <typename ViewType>
        int readInf (ViewType& document, bool negative)
        {
            if (JOIN_UNLIKELY (!(document.getIfNoCase ('n') && document.getIfNoCase ('f'))))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            if (JOIN_UNLIKELY (document.getIfNoCase ('i') &&
                               !(document.getIfNoCase ('n') && document.getIfNoCase ('i') &&
                                 document.getIfNoCase ('t') && document.getIfNoCase ('y'))))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setDouble (negative ? -std::numeric_limits<double>::infinity ()
                                       : std::numeric_limits<double>::infinity ());
        }
 
        template <typename ViewType>
        int readNan (ViewType& document, bool negative)
        {
            if (JOIN_UNLIKELY (!(document.getIfNoCase ('a') && document.getIfNoCase ('n'))))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setDouble (negative ? -std::numeric_limits<double>::quiet_NaN ()
                                       : std::numeric_limits<double>::quiet_NaN ());
        }
 
        inline void umul192 (uint64_t hi, uint64_t lo, uint64_t significand, uint64_t& high, uint64_t& middle,
                             uint64_t& low) noexcept
        {
#if defined(__SIZEOF_INT128__)
            __uint128_t h = static_cast<__uint128_t> (hi) * significand;
            __uint128_t l = static_cast<__uint128_t> (lo) * significand;
            __uint128_t s = h + (l >> 64);
 
            high = static_cast<uint64_t> (s >> 64);
            middle = static_cast<uint64_t> (s);
            low = static_cast<uint64_t> (l);
#else
            uint64_t hi_hi, hi_lo, lo_hi, lo_lo;
 
            uint64_t m_lo = static_cast<uint32_t> (significand);
            uint64_t m_hi = significand >> 32;
            uint64_t p0 = (hi & 0xFFFFFFFF) * m_lo;
            uint64_t p1 = (hi >> 32) * m_lo;
            uint64_t p2 = (hi & 0xFFFFFFFF) * m_hi;
            uint64_t p3 = (hi >> 32) * m_hi;
            uint64_t carry = (p0 >> 32) + (p1 & 0xFFFFFFFF) + (p2 & 0xFFFFFFFF);
            hi_lo = (carry << 32) | (p0 & 0xFFFFFFFF);
            hi_hi = (carry >> 32) + (p1 >> 32) + (p2 >> 32) + p3;
 
            p0 = (lo & 0xFFFFFFFF) * m_lo;
            p1 = (lo >> 32) * m_lo;
            p2 = (lo & 0xFFFFFFFF) * m_hi;
            p3 = (lo >> 32) * m_hi;
            carry = (p0 >> 32) + (p1 & 0xFFFFFFFF) + (p2 & 0xFFFFFFFF);
            lo_lo = (carry << 32) | (p0 & 0xFFFFFFFF);
            lo_hi = (carry >> 32) + (p1 >> 32) + (p2 >> 32) + p3;
 
            low = lo_lo;
            middle = hi_lo + lo_hi;
            high = hi_hi + (middle < hi_lo ? 1 : 0);
#endif
        }
 
        inline bool strtodFast (uint64_t significand, int64_t exponent, double& value)
        {
            constexpr double pow10[] = {1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
                                        1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
 
            value = static_cast<double> (significand);
 
            if (JOIN_UNLIKELY ((exponent > 22) && (exponent < (22 + 16))))
            {
                value *= pow10[exponent - 22];
                exponent = 22;
            }
 
            if (JOIN_LIKELY ((exponent >= -22) && (exponent <= 22) && (value <= 9007199254740991.0)))
            {
                value = (exponent < 0) ? (value / pow10[-exponent]) : (value * pow10[exponent]);
                return true;
            }
 
            if (JOIN_UNLIKELY (value == 0.0))
            {
                return true;
            }
 
            if (JOIN_UNLIKELY (exponent < -325 || exponent > 308))
            {
                return false;
            }
 
            uint64_t high, middle, low;
            const details::Power& power = details::atodpow[exponent + 325];
            umul192 (power.hi, power.lo, significand, high, middle, low);
            int64_t exp = ((exponent * 217706) >> 16) + 1087;
 
            int lz;
            if (high != 0)
            {
                lz = __builtin_clzll (high);
                exp -= lz;
            }
            else if (middle != 0)
            {
                lz = __builtin_clzll (middle);
                exp -= lz + 64;
            }
            else
            {
                return false;  // LCOV_EXCL_LINE
            }
 
            if (JOIN_UNLIKELY (exp <= 0 || exp >= 2047))
            {
                return false;
            }
 
            if (high == 0)
            {
                high = middle << lz;
                middle = 0;
            }
            else if (lz != 0)
            {
                high = (high << lz) | (middle >> (64 - lz));
                middle <<= lz;
            }
 
            middle |= (low != 0);
 
            uint64_t mant = (high >> 11) & 0xFFFFFFFFFFFFF;
            uint64_t bits = (static_cast<uint64_t> (exp) << 52) | mant;
            uint64_t frac = high & 0x7FF;
 
            bool roundUp = ((frac > 0x400) | ((frac == 0x400) && ((middle != 0) || (mant & 1))) |
                            ((frac == 0x3FF) && ((middle != 0))));
 
            bits += roundUp;
            std::memcpy (&value, &bits, sizeof (double));
 
            return true;
        }
 
        inline bool strtodSlow (const std::string& num, double& d)
        {
            static LocalePtr locale (newlocale (LC_ALL_MASK, "C", nullptr));
            char* end = nullptr;
            d = strtod_l (num.c_str (), &end, locale.get ());
            return (end && (*end == '\0'));
        }
 
        template <typename ViewType>
        int readNumber (ViewType& document)
        {
            BufferingView<ViewType> view (document);
 
            bool negative = view.getIf ('-');
 
            uint64_t max64 = std::numeric_limits<uint64_t>::max ();
            if (negative)
            {
                max64 = static_cast<uint64_t> (std::numeric_limits<int64_t>::max ()) + 1;
            }
 
            uint64_t digits = 0;
            bool isDouble = false;
            uint64_t u = 0;
 
            if (JOIN_UNLIKELY (view.getIf ('0')))
            {
                if (JOIN_UNLIKELY (isDigit (view.peek ())))
                {
                    join::lastError = make_error_code (SaxErrc::InvalidValue);
                    return -1;
                }
            }
            else if (JOIN_LIKELY (isDigit (view.peek ())))
            {
                u = view.get () - '0';
                ++digits;
 
                while (JOIN_LIKELY (isDigit (view.peek ())))
                {
                    int digit = view.peek () - '0';
 
                    if (JOIN_UNLIKELY (u > ((max64 - digit) / 10)))
                    {
                        isDouble = true;
                        break;
                    }
 
                    u = (u * 10) + (view.get () - '0');
                    ++digits;
                }
            }
            else if (JOIN_LIKELY (document.getIfNoCase ('i')))
            {
                return readInf (document, negative);
            }
            else if (JOIN_LIKELY (document.getIfNoCase ('n')))
            {
                return readNan (document, negative);
            }
            else
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            if (isDouble)
            {
                while (JOIN_LIKELY (isDigit (view.peek ())))
                {
                    u = (u * 10) + (view.get () - '0');
                    ++digits;
                }
            }
 
            int64_t frac = 0;
            if (view.getIf ('.'))
            {
                isDouble = true;
 
                while (JOIN_LIKELY (isDigit (view.peek ())))
                {
                    u = (u * 10) + (view.get () - '0');
                    if (JOIN_LIKELY (u || digits))
                    {
                        ++digits;
                    }
                    --frac;
                }
            }
 
            int64_t exponent = 0;
            if (view.getIf ('e') || view.getIf ('E'))
            {
                isDouble = true;
 
                bool negExp = false;
                if (isSign (view.peek ()))
                {
                    negExp = (view.get () == '-');
                }
 
                if (JOIN_LIKELY (isDigit (view.peek ())))
                {
                    exponent = (view.get () - '0');
 
                    while (JOIN_LIKELY (isDigit (view.peek ())))
                    {
                        int digit = view.get () - '0';
 
                        if (JOIN_LIKELY (exponent <= ((std::numeric_limits<int>::max () - digit) / 10)))
                        {
                            exponent = (exponent * 10) + digit;
                        }
                    }
                }
                else
                {
                    join::lastError = make_error_code (SaxErrc::InvalidValue);
                    return -1;
                }
 
                if (negExp)
                {
                    exponent = -exponent;
                }
            }
 
            if (!isDouble)
            {
                return negative ? setInt64 (-static_cast<int64_t> (u)) : setUint64 (u);
            }
 
            if (JOIN_LIKELY (digits <= 19))
            {
                double d = 0.0;
                if (strtodFast (u, exponent + frac, d))
                {
                    return setDouble (negative ? -d : d);
                }
            }
 
            std::string number;
            view.snapshot (number);
 
            double d = 0.0;
            if (strtodSlow (number, d))
            {
                return setDouble (d);
            }
 
            join::lastError = make_error_code (SaxErrc::InvalidValue);
            return -1;
        }
 
        template <typename ViewType>
        inline int readHex (ViewType& document, uint32_t& u)
        {
            for (int i = 0; i < 4; ++i)
            {
                char c = document.get ();
 
                if (isDigit (c))
                {
                    c -= '0';
                }
                else if (isUpperAlpha (c))
                {
                    c = c - 'A' + 10;
                }
                else if (isLowerAlpha (c))
                {
                    c = c - 'a' + 10;
                }
                else
                {
                    join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                    return -1;
                }
 
                u = (u << 4) + c;
            }
 
            return 0;
        }
 
        inline void encodeUtf8 (uint32_t codepoint, std::string& output)
        {
            if (codepoint < 0x80)
            {
                output.push_back (static_cast<char> (codepoint));
            }
            else if (codepoint < 0x800)
            {
                char buf[2];
                buf[0] = static_cast<char> (0xC0 | (codepoint >> 6));
                buf[1] = static_cast<char> (0x80 | (codepoint & 0x3F));
                output.append (buf, 2);
            }
            else if (codepoint < 0x10000)
            {
                char buf[3];
                buf[0] = static_cast<char> (0xE0 | (codepoint >> 12));
                buf[1] = static_cast<char> (0x80 | ((codepoint >> 6) & 0x3F));
                buf[2] = static_cast<char> (0x80 | (codepoint & 0x3F));
                output.append (buf, 3);
            }
            else
            {
                char buf[4];
                buf[0] = static_cast<char> (0xF0 | (codepoint >> 18));
                buf[1] = static_cast<char> (0x80 | ((codepoint >> 12) & 0x3F));
                buf[2] = static_cast<char> (0x80 | ((codepoint >> 6) & 0x3F));
                buf[3] = static_cast<char> (0x80 | (codepoint & 0x3F));
                output.append (buf, 4);
            }
        }
 
        template <typename ViewType>
        inline int readUnicode (ViewType& document, std::string& output)
        {
            uint32_t u = 0;
 
            if (readHex (document, u) == -1)
            {
                return -1;
            }
 
            if (u >= 0xDC00 && u <= 0xDFFF)
            {
                join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                return -1;
            }
 
            if (u >= 0xD800 && u <= 0xDBFF)
            {
                if ((document.get () != '\\') || (document.get () != 'u'))
                {
                    join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                    return -1;
                }
 
                uint32_t v = 0;
 
                if (readHex (document, v) == -1)
                {
                    join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                    return -1;
                }
 
                if (v < 0xDC00 || v > 0xDFFF)
                {
                    join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                    return -1;
                }
 
                u = 0x10000 + (((u - 0xD800) << 10) | (v - 0xDC00));
            }
 
            if (u > 0x10FFFF)
            {
                join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                return -1;
            }
 
            encodeUtf8 (u, output);
 
            return 0;
        }
 
        template <typename ViewType>
        inline int readEscaped (ViewType& document, std::string& output)
        {
            int ch = document.get ();
            switch (ch)
            {
                case '"':
                    output.push_back ('"');
                    break;
                case '\\':
                    output.push_back ('\\');
                    break;
                case '/':
                    output.push_back ('/');
                    break;
                case 'b':
                    output.push_back ('\b');
                    break;
                case 'f':
                    output.push_back ('\f');
                    break;
                case 'n':
                    output.push_back ('\n');
                    break;
                case 'r':
                    output.push_back ('\r');
                    break;
                case 't':
                    output.push_back ('\t');
                    break;
                case 'u':
                    return readUnicode (document, output);
                default:
                    join::lastError = make_error_code (JsonErrc::InvalidEscaping);
                    return -1;
            }
 
            return 0;
        }
 
        /*template <typename ViewType>
        inline int readUtf8 (ViewType& document, std::string& output) noexcept
        {
            size_t count = 0;
 
            if (static_cast <uint8_t> (document.peek ()) < 0x80)
            {
                output.push_back (document.get ());
            }
            else if (static_cast <uint8_t> (document.peek ()) < 0xE0)
            {
                output.push_back (document.get ());
                count = 1;
            }
            else if (static_cast <uint8_t> (document.peek ()) < 0xF0)
            {
                output.push_back (document.get ());
                count = 2;
            }
            else if (static_cast <uint8_t> (document.peek ()) < 0xF8)
            {
                output.push_back (document.get ());
                count = 3;
            }
            else
            {
                join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                return -1;
            }
 
            for (size_t i = 0; i < count; ++i)
            {
                if (static_cast <uint8_t> (document.peek ()) < 0x80 || static_cast <uint8_t> (document.peek ()) > 0xBF)
                {
                    join::lastError = make_error_code (JsonErrc::InvalidEncoding);
                    return -1;
                }
 
                output.push_back (document.get ());
            }
 
            return 0;
        }*/
 
        template <typename ViewType>
        int readString (ViewType& document, bool isKey = false)
        {
            thread_local Value output (in_place_index_t<Value::String>{});
            output.clear ();
            output.reserve (64);
 
            for (;;)
            {
                document.readUntilEscaped (output.getString ());
                int ch = document.peek ();
 
                if (ch == '"')
                {
                    document.get ();
                    break;
                }
 
                if (ch == '\\')
                {
                    document.get ();
                    if (readEscaped (document, output.getString ()) == -1)
                    {
                        return -1;
                    }
                    continue;
                }
 
                /*if (static_cast <uint8_t> (ch) > 0x7F)
                {
                    if (readUtf8 (document, output) == -1)
                    {
                        return -1;
                    }
                    continue;
                }*/
 
                if (ch < 0x20)
                {
                    join::lastError = make_error_code (JsonErrc::IllegalCharacter);
                    return -1;
                }
            }
 
            return isKey ? setKey (output) : setString (output.getString ());
        }
 
        template <JsonReadMode ReadMode, typename ViewType>
        int readArray (ViewType& document)
        {
            if (JOIN_UNLIKELY (startArray () == -1))
            {
                return -1;
            }
 
            if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
            {
                return -1;
            }
 
            if (document.getIf (']'))
            {
                return stopArray ();
            }
 
            for (;;)
            {
                if (JOIN_UNLIKELY (readValue<ReadMode> (document) == -1))
                {
                    return -1;
                }
 
                int ch = document.get ();
 
                if (JOIN_UNLIKELY (details::whitespaceLookup.data[static_cast<unsigned char> (ch)]))
                {
                    if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                    {
                        return -1;
                    }
                    ch = document.get ();
                }
 
                if (JOIN_LIKELY (ch == ','))
                {
                    if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                    {
                        return -1;
                    }
                    continue;
                }
 
                if (JOIN_LIKELY (ch == ']'))
                {
                    break;
                }
 
                join::lastError = make_error_code (JsonErrc::MissingComma);
                return -1;
            }
 
            return stopArray ();
        }
 
        template <JsonReadMode ReadMode, typename ViewType>
        int readObject (ViewType& document)
        {
            if (JOIN_UNLIKELY (startObject () == -1))
            {
                return -1;
            }
 
            if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
            {
                return -1;
            }
 
            if (document.getIf ('}'))
            {
                return stopObject ();
            }
 
            for (;;)
            {
                if (JOIN_UNLIKELY (document.get () != '"'))
                {
                    join::lastError = make_error_code (JsonErrc::MissingQuote);
                    return -1;
                }
 
                if (JOIN_UNLIKELY (readString (document, true) == -1))
                {
                    return -1;
                }
 
                if (document.peek () != ':')
                {
                    if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                    {
                        return -1;
                    }
                }
 
                if (JOIN_UNLIKELY (document.get () != ':'))
                {
                    join::lastError = make_error_code (JsonErrc::MissingColon);
                    return -1;
                }
 
                if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                {
                    return -1;
                }
 
                if (JOIN_UNLIKELY (readValue<ReadMode> (document) == -1))
                {
                    return -1;
                }
 
                int ch = document.get ();
 
                if (JOIN_UNLIKELY (details::whitespaceLookup.data[static_cast<unsigned char> (ch)]))
                {
                    if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                    {
                        return -1;
                    }
                    ch = document.get ();
                }
 
                if (JOIN_LIKELY (ch == ','))
                {
                    if (JOIN_UNLIKELY (skipWhitespaces<ReadMode> (document) == -1))
                    {
                        return -1;
                    }
                    continue;
                }
 
                if (JOIN_LIKELY (ch == '}'))
                {
                    break;
                }
 
                join::lastError = make_error_code (JsonErrc::MissingComma);
                return -1;
            }
 
            return stopObject ();
        }
 
        template <JsonReadMode ReadMode, typename ViewType>
        inline typename std::enable_if<!(ReadMode & JsonReadMode::ParseComments), int>::type skipWhitespaces (
            ViewType& document)
        {
            return document.skipWhitespaces ();
        }
 
        template <JsonReadMode ReadMode, typename ViewType>
        inline typename std::enable_if<(ReadMode & JsonReadMode::ParseComments), int>::type skipWhitespaces (
            ViewType& document)
        {
            return document.skipWhitespacesAndComments ();
        }
 
        constexpr bool isUpperAlpha (char c) noexcept
        {
            return static_cast<unsigned char> (c - 'A') <= 5u;
        }
 
        constexpr bool isLowerAlpha (char c) noexcept
        {
            return static_cast<unsigned char> (c - 'a') <= 5u;
        }
 
        constexpr bool isDigit (char c) noexcept
        {
            return static_cast<unsigned char> (c - '0') <= 9u;
        }
 
        constexpr bool isSign (char c) noexcept
        {
            return ((c ^ '+') & (c ^ '-')) == 0;
        }
    };
}
 
namespace std
{
    template <>
    struct is_error_condition_enum<join::JsonErrc> : public true_type
    {
    };
}
 
#endif