value.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_VALUE_HPP
#define JOIN_DATA_VALUE_HPP
 
// libjoin.
#include <join/variant.hpp>
#include <join/error.hpp>
 
// C++.
#include <functional>
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <limits>
 
// C.
#include <cstdint>
#include <cmath>
 
namespace join
{
    class Value;
 
    using Array = std::vector<Value>;
 
    using Member = std::pair<Value, Value>;
 
    using Object = std::vector<Member>;
 
    class Value
    : public Variant<std::nullptr_t, bool, int32_t, uint32_t, int64_t, uint64_t, double, std::string, Array, Object>
    {
    public:
        enum Index : size_t
        {
            Null        = 0, 
            Boolean     = 1, 
            Integer     = 2, 
            Unsigned    = 3, 
            Integer64   = 4, 
            Unsigned64  = 5, 
            Real        = 6, 
            String      = 7, 
            ArrayValue  = 8, 
            ObjectValue = 9, 
        };
 
        using Ptr = Value*;
 
        using Variant::Variant;
 
        using Variant::operator=;
 
        constexpr Value () = default;
 
        constexpr Value (const char* other)
        : Variant (in_place_index_t<String>{}, other)
        {
        }
 
        Value& operator= (const char* other)
        {
            Variant::operator= (Value (in_place_index_t<String>{}, other));
            return *this;
        }
 
        constexpr Value (const Value& other) = default;
 
        Value& operator= (const Value& other) = default;
 
        constexpr Value (Value&& other) = default;
 
        Value& operator= (Value&& other) = default;
 
        virtual ~Value () = default;
 
        constexpr bool isNull () const
        {
            return index () == Null;
        }
 
        constexpr bool isBool () const
        {
            return index () == Boolean;
        }
 
        constexpr bool getBool () const
        {
            switch (index ())
            {
                case Null:
                    return false;
 
                case Boolean:
                    return get<Boolean> ();
 
                case Integer:
                    return get<Integer> ();
 
                case Unsigned:
                    return get<Unsigned> ();
 
                case Integer64:
                    return get<Integer64> ();
 
                case Unsigned64:
                    return get<Unsigned64> ();
 
                case Real:
                    return get<Real> ();
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator bool () const
        {
            return getBool ();
        }
 
        constexpr bool isTrue () const
        {
            return getBool ();
        }
 
        constexpr bool isFalse () const
        {
            return !getBool ();
        }
 
        constexpr bool isNumber () const
        {
            return index () == Integer || index () == Unsigned || index () == Integer64 || index () == Unsigned64 ||
                   index () == Real;
        }
 
        constexpr bool isInt8 () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= static_cast<int32_t> (std::numeric_limits<int8_t>::min ()) &&
                           get<Integer> () <= static_cast<int32_t> (std::numeric_limits<int8_t>::max ());
 
                case Unsigned:
                    return get<Unsigned> () <= static_cast<uint32_t> (std::numeric_limits<int8_t>::max ());
 
                case Integer64:
                    return get<Integer64> () >= static_cast<int64_t> (std::numeric_limits<int8_t>::min ()) &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<int8_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<int8_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () &&
                           get<Real> () >= static_cast<double> (std::numeric_limits<int8_t>::min ()) &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<int8_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr int8_t getInt8 () const
        {
            if (isInt8 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<int8_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<int8_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<int8_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<int8_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<int8_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator int8_t () const
        {
            return getInt8 ();
        }
 
        constexpr bool isUint8 () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= 0 &&
                           get<Integer> () <= static_cast<int32_t> (std::numeric_limits<uint8_t>::max ());
 
                case Unsigned:
                    return get<Unsigned> () <= static_cast<uint32_t> (std::numeric_limits<uint8_t>::max ());
 
                case Integer64:
                    return get<Integer64> () >= 0 &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<uint8_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<uint8_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () && get<Real> () >= 0 &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<uint8_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr uint8_t getUint8 () const
        {
            if (isUint8 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<uint8_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<uint8_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<uint8_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<uint8_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<uint8_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator uint8_t () const
        {
            return getUint8 ();
        }
 
        constexpr bool isInt16 () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= static_cast<int32_t> (std::numeric_limits<int16_t>::min ()) &&
                           get<Integer> () <= static_cast<int32_t> (std::numeric_limits<int16_t>::max ());
 
                case Unsigned:
                    return get<Unsigned> () <= static_cast<uint32_t> (std::numeric_limits<int16_t>::max ());
 
                case Integer64:
                    return get<Integer64> () >= static_cast<int64_t> (std::numeric_limits<int16_t>::min ()) &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<int16_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<int16_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () &&
                           get<Real> () >= static_cast<double> (std::numeric_limits<int16_t>::min ()) &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<int16_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr int16_t getInt16 () const
        {
            if (isInt16 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<int16_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<int16_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<int16_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<int16_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<int16_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator int16_t () const
        {
            return getInt16 ();
        }
 
        constexpr bool isUint16 () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= 0 &&
                           get<Integer> () <= static_cast<int32_t> (std::numeric_limits<uint16_t>::max ());
 
                case Unsigned:
                    return get<Unsigned> () <= static_cast<uint32_t> (std::numeric_limits<uint16_t>::max ());
 
                case Integer64:
                    return get<Integer64> () >= 0 &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<uint16_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<uint16_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () && get<Real> () >= 0 &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<uint16_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr uint16_t getUint16 () const
        {
            if (isUint16 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<uint16_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<uint16_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<uint16_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<uint16_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<uint16_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator uint16_t () const
        {
            return getUint16 ();
        }
 
        constexpr bool isInt () const
        {
            switch (index ())
            {
                case Integer:
                    return true;
 
                case Unsigned:
                    return get<Unsigned> () <= static_cast<uint32_t> (std::numeric_limits<int32_t>::max ());
 
                case Integer64:
                    return get<Integer64> () >= static_cast<int64_t> (std::numeric_limits<int32_t>::min ()) &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<int32_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<int32_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () &&
                           get<Real> () >= static_cast<double> (std::numeric_limits<int32_t>::min ()) &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<int32_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr int32_t getInt () const
        {
            if (isInt ())
            {
                switch (index ())
                {
                    case Integer:
                        return get<Integer> ();
 
                    case Unsigned:
                        return static_cast<int32_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<int32_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<int32_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<int32_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator int32_t () const
        {
            return getInt ();
        }
 
        constexpr bool isUint () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= 0;
 
                case Unsigned:
                    return true;
 
                case Integer64:
                    return get<Integer64> () >= 0 &&
                           get<Integer64> () <= static_cast<int64_t> (std::numeric_limits<uint32_t>::max ());
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<uint32_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () && get<Real> () >= 0 &&
                           get<Real> () <= static_cast<double> (std::numeric_limits<uint32_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr uint32_t getUint () const
        {
            if (isUint ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<uint32_t> (get<Integer> ());
 
                    case Unsigned:
                        return get<Unsigned> ();
 
                    case Integer64:
                        return static_cast<uint32_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return static_cast<uint32_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<uint32_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator uint32_t () const
        {
            return getUint ();
        }
 
        constexpr bool isInt64 () const
        {
            switch (index ())
            {
                case Integer:
                case Unsigned:
                case Integer64:
                    return true;
 
                case Unsigned64:
                    return get<Unsigned64> () <= static_cast<uint64_t> (std::numeric_limits<int64_t>::max ());
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () &&
                           get<Real> () >= static_cast<double> (std::numeric_limits<int64_t>::min ()) &&
                           get<Real> () < static_cast<double> (std::numeric_limits<int64_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr int64_t getInt64 () const
        {
            if (isInt64 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<int64_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<int64_t> (get<Unsigned> ());
 
                    case Integer64:
                        return get<Integer64> ();
 
                    case Unsigned64:
                        return static_cast<int64_t> (get<Unsigned64> ());
 
                    default:
                        return static_cast<int64_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator int64_t () const
        {
            return getInt64 ();
        }
 
        constexpr bool isUint64 () const
        {
            switch (index ())
            {
                case Integer:
                    return get<Integer> () >= 0;
 
                case Unsigned:
                    return true;
 
                case Integer64:
                    return get<Integer64> () >= 0;
 
                case Unsigned64:
                    return true;
 
                case Real:
                    return std::trunc (get<Real> ()) == get<Real> () && get<Real> () >= 0 &&
                           get<Real> () < static_cast<double> (std::numeric_limits<uint64_t>::max ());
 
                default:
                    break;
            }
 
            return false;
        }
 
        constexpr uint64_t getUint64 () const
        {
            if (isUint64 ())
            {
                switch (index ())
                {
                    case Integer:
                        return static_cast<uint64_t> (get<Integer> ());
 
                    case Unsigned:
                        return static_cast<uint64_t> (get<Unsigned> ());
 
                    case Integer64:
                        return static_cast<uint64_t> (get<Integer64> ());
 
                    case Unsigned64:
                        return get<Unsigned64> ();
 
                    default:
                        return static_cast<uint64_t> (get<Real> ());
                }
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator uint64_t () const
        {
            return getUint64 ();
        }
 
        constexpr bool isFloat () const
        {
            return isNumber ();
        }
 
        constexpr float getFloat () const
        {
            switch (index ())
            {
                case Integer:
                    return static_cast<float> (get<Integer> ());
 
                case Unsigned:
                    return static_cast<float> (get<Unsigned> ());
 
                case Integer64:
                    return static_cast<float> (get<Integer64> ());
 
                case Unsigned64:
                    return static_cast<float> (get<Unsigned64> ());
 
                case Real:
                    return static_cast<float> (get<Real> ());
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator float () const
        {
            return getFloat ();
        }
 
        constexpr bool isDouble () const
        {
            return isNumber ();
        }
 
        constexpr double getDouble () const
        {
            switch (index ())
            {
                case Integer:
                    return static_cast<double> (get<Integer> ());
 
                case Unsigned:
                    return static_cast<double> (get<Unsigned> ());
 
                case Integer64:
                    return static_cast<double> (get<Integer64> ());
 
                case Unsigned64:
                    return static_cast<double> (get<Unsigned64> ());
 
                case Real:
                    return get<Real> ();
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        explicit operator double () const
        {
            return getDouble ();
        }
 
        constexpr bool isString () const
        {
            return index () == String;
        }
 
        constexpr const std::string& getString () const
        {
            return get<String> ();
        }
 
        constexpr std::string& getString ()
        {
            return get<String> ();
        }
 
        explicit operator const char* () const
        {
            return getString ().c_str ();
        }
 
        constexpr bool isArray () const
        {
            return index () == ArrayValue;
        }
 
        constexpr const Array& getArray () const
        {
            return get<ArrayValue> ();
        }
 
        constexpr Array& getArray ()
        {
            return get<ArrayValue> ();
        }
 
        constexpr bool isObject () const
        {
            return index () == ObjectValue;
        }
 
        constexpr const Object& getObject () const
        {
            return get<ObjectValue> ();
        }
 
        constexpr Object& getObject ()
        {
            return get<ObjectValue> ();
        }
 
        Value& at (const Value& key)
        {
            if (index () == ArrayValue)
            {
                return get<ArrayValue> ().at (key.getUint64 ());
            }
 
            for (auto& member : get<ObjectValue> ())
            {
                if (member.first == key)
                {
                    return member.second;
                }
            }
 
            throw std::out_of_range ("invalid key");
        }
 
        const Value& at (const Value& key) const
        {
            if (index () == ArrayValue)
            {
                return get<ArrayValue> ().at (key.getUint64 ());
            }
 
            for (auto const& member : get<ObjectValue> ())
            {
                if (member.first == key)
                {
                    return member.second;
                }
            }
 
            throw std::out_of_range ("invalid key");
        }
 
        Value& operator[] (const Value& key)
        {
            if (index () == ArrayValue)
            {
                return get<ArrayValue> ()[key.getUint64 ()];
            }
 
            if (index () == Null)
            {
                set<ObjectValue> ();
            }
 
            for (auto& member : get<ObjectValue> ())
            {
                if (member.first == key)
                {
                    return member.second;
                }
            }
 
            get<ObjectValue> ().emplace_back (key, nullptr);
 
            return get<ObjectValue> ().back ().second;
        }
 
        bool empty () const
        {
            switch (index ())
            {
                case String:
                    return get<String> ().empty ();
 
                case ArrayValue:
                    return get<ArrayValue> ().empty ();
 
                case ObjectValue:
                    return get<ObjectValue> ().empty ();
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        size_t size () const
        {
            switch (index ())
            {
                case String:
                    return get<String> ().size ();
 
                case ArrayValue:
                    return get<ArrayValue> ().size ();
 
                case ObjectValue:
                    return get<ObjectValue> ().size ();
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        void reserve (size_t cap)
        {
            switch (index ())
            {
                case String:
                    get<String> ().reserve (cap);
                    return;
 
                case ArrayValue:
                    get<ArrayValue> ().reserve (cap);
                    return;
 
                case ObjectValue:
                    get<ObjectValue> ().reserve (cap);
                    return;
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        void clear ()
        {
            switch (index ())
            {
                case String:
                    get<String> ().clear ();
                    return;
 
                case ArrayValue:
                    get<ArrayValue> ().clear ();
                    return;
 
                case ObjectValue:
                    get<ObjectValue> ().clear ();
                    return;
 
                default:
                    break;
            }
 
            throw std::bad_cast ();
        }
 
        Value& insert (const Member& member)
        {
            get<ObjectValue> ().push_back (member);
            return get<ObjectValue> ().back ().second;
        }
 
        Value& insert (Member&& member)
        {
            get<ObjectValue> ().emplace_back (std::move (member));
            return get<ObjectValue> ().back ().second;
        }
 
        size_t erase (const Value& key)
        {
            auto beg = get<ObjectValue> ().begin ();
            auto end = get<ObjectValue> ().end ();
 
            for (auto it = beg; it != end; ++it)
            {
                if (it->first == key)
                {
                    get<ObjectValue> ().erase (it);
                    return 1;
                }
            }
 
            return 0;
        }
 
        template <typename... Args>
        Value& emplaceBack (Args&&... args)
        {
            if (index () == Null)
            {
                set<ArrayValue> ();
            }
            return get<ArrayValue> ().emplace_back (std::forward<Args> (args)...);
        }
 
        Value& pushBack (const Value& value)
        {
            if (index () == Null)
            {
                set<ArrayValue> ();
            }
            get<ArrayValue> ().push_back (value);
            return get<ArrayValue> ().back ();
        }
 
        Value& pushBack (Value&& value)
        {
            if (index () == Null)
            {
                set<ArrayValue> ();
            }
            get<ArrayValue> ().emplace_back (std::move (value));
            return get<ArrayValue> ().back ();
        }
 
        void popBack ()
        {
            get<ArrayValue> ().pop_back ();
        }
 
        bool contains (const Value& key) const
        {
            if (index () == ArrayValue)
            {
                return get<ArrayValue> ().size () > key.getUint64 ();
            }
 
            for (auto const& member : get<ObjectValue> ())
            {
                if (member.first == key)
                {
                    return true;
                }
            }
 
            return false;
        }
 
        void swap (Value& other)
        {
            Value temp (std::move (*this));
            *this = std::move (other);
            other = std::move (temp);
        }
 
        template <typename Reader>
        int deserialize (const char* document, size_t length)
        {
            Reader reader (*this);
            return reader.deserialize (document, length);
        }
 
        template <typename Reader>
        int deserialize (const char* first, const char* last)
        {
            Reader reader (*this);
            return reader.deserialize (first, last);
        }
 
        template <typename Reader>
        int deserialize (const std::string& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::stringstream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::istringstream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::fstream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::ifstream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::iostream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Reader>
        int deserialize (std::istream& document)
        {
            Reader reader (*this);
            return reader.deserialize (document);
        }
 
        template <typename Writer>
        int serialize (std::ostream& document) const
        {
            Writer writer (document);
            return writer.serialize (*this);
        }
 
        int jsonRead (const char* document, size_t length);
 
        int jsonRead (const char* first, const char* last);
 
        int jsonRead (const std::string& document);
 
        int jsonRead (std::stringstream& document);
 
        int jsonRead (std::istringstream& document);
 
        int jsonRead (std::fstream& document);
 
        int jsonRead (std::ifstream& document);
 
        int jsonRead (std::iostream& document);
 
        int jsonRead (std::istream& document);
 
        int jsonWrite (std::ostream& document, size_t indentation = 0) const;
 
        int jsonCanonicalize (std::ostream& document);
 
        int packRead (const char* document, size_t length);
 
        int packRead (const char* first, const char* last);
 
        int packRead (const std::string& document);
 
        int packRead (std::stringstream& document);
 
        int packRead (std::istringstream& document);
 
        int packRead (std::fstream& document);
 
        int packRead (std::ifstream& document);
 
        int packRead (std::iostream& document);
 
        int packRead (std::istream& document);
 
        int packWrite (std::ostream& document) const;
 
        // friendship with equal operator.
        friend constexpr bool operator== (const Value& lhs, const Value& rhs);
 
        // friendship with lower operator.
        friend constexpr bool operator< (const Value& lhs, const Value& rhs);
    };
 
    constexpr bool operator== (const Value& lhs, const Value& rhs)
    {
        if (lhs.isNumber () && rhs.isNumber () && (lhs.index () != rhs.index ()))
        {
            if (lhs.isInt64 () && rhs.isUint64 ())
            {
                return lhs.getInt64 () >= 0 && uint64_t (lhs.getInt64 ()) == rhs.getUint64 ();
            }
            else if (lhs.isUint64 () && rhs.isInt64 ())
            {
                return rhs.getInt64 () >= 0 && uint64_t (rhs.getInt64 ()) == lhs.getUint64 ();
            }
            else
            {
                return lhs.getDouble () == rhs.getDouble ();
            }
        }
 
        return lhs.equal (rhs);
    }
 
    constexpr bool operator!= (const Value& lhs, const Value& rhs)
    {
        return !(lhs == rhs);
    }
 
    constexpr bool operator< (const Value& lhs, const Value& rhs)
    {
        if (lhs.isNumber () && rhs.isNumber () && (lhs.index () != rhs.index ()))
        {
            if (lhs.isInt64 () && rhs.isUint64 ())
            {
                return lhs.getInt64 () < 0 || uint64_t (lhs.getInt64 ()) < rhs.getUint64 ();
            }
            else if (lhs.isUint64 () && rhs.isInt64 ())
            {
                return rhs.getInt64 () >= 0 && lhs.getUint64 () < uint64_t (rhs.getInt64 ());
            }
            else
            {
                return lhs.getDouble () < rhs.getDouble ();
            }
        }
 
        return lhs.lower (rhs);
    }
 
    constexpr bool operator> (const Value& lhs, const Value& rhs)
    {
        return rhs < lhs;
    }
 
    constexpr bool operator<= (const Value& lhs, const Value& rhs)
    {
        return !(rhs < lhs);
    }
 
    constexpr bool operator>= (const Value& lhs, const Value& rhs)
    {
        return !(lhs < rhs);
    }
}
 
#endif