value.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_VALUE_HPP__
#define __JOIN_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 <std::string, 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 (size_t pos)
        {
            return get <ArrayValue> ().at (pos);
        }
 
        const Value& at (size_t pos) const
        {
            return get <ArrayValue> ().at (pos);
        }
 
        Value& at (const std::string& key)
        {
            for (auto& member : get <ObjectValue> ())
            {
                if (member.first == key)
                {
                    return member.second;
                }
            }
 
            throw std::out_of_range ("invalid key");
        }
 
        const Value& at (const std::string& key) const
        {
            for (auto const& member : get <ObjectValue> ())
            {
                if (member.first == key)
                {
                    return member.second;
                }
            }
 
            throw std::out_of_range ("invalid key");
        }
 
        Value& operator[] (size_t pos)
        {
            return get <ArrayValue> ()[pos];
        }
 
        Value& operator[] (const std::string& key)
        {
            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 std::string& 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 (size_t pos) const
        {
            return get <ArrayValue> ().size () > pos;
        }
 
        bool contains (const std::string& key) const
        {
            for (auto& 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