json_value.h

#pragma once
 
#include <xrpl/basics/Number.h>
#include <xrpl/json/json_forwards.h>
 
#include <cstring>
#include <limits>
#include <map>
#include <string>
#include <vector>

namespace json {

enum class ValueType {
    Null = 0,  
    Int,       
    UInt,      
    Real,      
    String,    
    Boolean,   
    Array,     
    Object     
};

class StaticString
{
public:
    constexpr explicit StaticString(char const* czString) : str_(czString)
    {
    }
 
    constexpr
    operator char const*() const
    {
        return str_;
    }
 
    [[nodiscard]] constexpr char const*
    cStr() const
    {
        return str_;
    }
 
private:
    char const* str_;
};
 
inline bool
operator==(StaticString x, StaticString y)
{
    return strcmp(x.cStr(), y.cStr()) == 0;
}
 
inline bool
operator!=(StaticString x, StaticString y)
{
    return !(x == y);
}
 
inline bool
operator==(std::string const& x, StaticString y)
{
    return strcmp(x.c_str(), y.cStr()) == 0;
}
 
inline bool
operator!=(std::string const& x, StaticString y)
{
    return !(x == y);
}
 
inline bool
operator==(StaticString x, std::string const& y)
{
    return y == x;
}
 
inline bool
operator!=(StaticString x, std::string const& y)
{
    return !(y == x);
}

class Value
{
    friend class ValueIteratorBase;
 
public:
    using Members = std::vector<std::string>;
    using iterator = ValueIterator;
    using const_iterator = ValueConstIterator;
    using UInt = json::UInt;
    using Int = json::Int;
    using ArrayIndex = UInt;
 
    static Value const kNull;
    static constexpr Int kMinInt = std::numeric_limits<Int>::min();
    static constexpr Int kMaxInt = std::numeric_limits<Int>::max();
    static constexpr UInt kMaxUInt = std::numeric_limits<UInt>::max();
 
private:
    class CZString
    {
    public:
        enum class DuplicationPolicy { NoDuplication = 0, Duplicate, DuplicateOnCopy };
 
        CZString(int index);
        CZString(char const* cstr, DuplicationPolicy allocate);
        CZString(CZString const& other);
        ~CZString();
        CZString&
        operator=(CZString const& other) = delete;
        bool
        operator<(CZString const& other) const;
        bool
        operator==(CZString const& other) const;
        [[nodiscard]] int
        index() const;
        [[nodiscard]] char const*
        cStr() const;
        [[nodiscard]] bool
        isStaticString() const;
 
    private:
        char const* cstr_;
        int index_;
    };
 
public:
    using ObjectValues = std::map<CZString, Value>;
 
public:
    Value(ValueType type = ValueType::Null);
    Value(Int value);
    Value(UInt value);
    Value(double value);
    Value(char const* value);
    Value(xrpl::Number const& value);
    Value(StaticString const& value);
    Value(std::string const& value);
    Value(bool value);
    Value(Value const& other);
    ~Value();
 
    Value&
    operator=(Value const& other);
    Value&
    operator=(Value&& other);
 
    Value(Value&& other) noexcept;

    void
    swap(Value& other) noexcept;
 
    [[nodiscard]] ValueType
    type() const;
 
    [[nodiscard]] char const*
    asCString() const;
    [[nodiscard]] std::string
    asString() const;
    [[nodiscard]] Int
    asInt() const;
    [[nodiscard]] UInt
    asUInt() const;
    [[nodiscard]] double
    asDouble() const;
    [[nodiscard]] bool
    asBool() const;

    [[nodiscard]] UInt
    asAbsUInt() const;
 
    // TODO: What is the "empty()" method this docstring mentions?
    [[nodiscard]] bool
    isNull() const;
    [[nodiscard]] bool
    isBool() const;
    [[nodiscard]] bool
    isInt() const;
    [[nodiscard]] bool
    isUInt() const;
    [[nodiscard]] bool
    isIntegral() const;
    [[nodiscard]] bool
    isDouble() const;
    [[nodiscard]] bool
    isNumeric() const;
    [[nodiscard]] bool
    isString() const;
    [[nodiscard]] bool
    isArray() const;
    [[nodiscard]] bool
    isArrayOrNull() const;
    [[nodiscard]] bool
    isObject() const;
    [[nodiscard]] bool
    isObjectOrNull() const;
 
    [[nodiscard]] bool
    isConvertibleTo(ValueType other) const;

    [[nodiscard]] UInt
    size() const;

    explicit
    operator bool() const;

    void
    clear();

    Value&
    operator[](UInt index);
    Value const&
    operator[](UInt index) const;
    [[nodiscard]] Value
    get(UInt index, Value const& defaultValue) const;
    [[nodiscard]] bool
    isValidIndex(UInt index) const;
    Value&
    append(Value const& value);
    Value&
    append(Value&& value);

    Value&
    operator[](char const* key);
    Value const&
    operator[](char const* key) const;
    Value&
    operator[](std::string const& key);
    Value const&
    operator[](std::string const& key) const;
    Value&
    operator[](StaticString const& key);
    Value const&
    operator[](StaticString const& key) const;

    Value
    get(char const* key, Value const& defaultValue) const;
    [[nodiscard]] Value
    get(std::string const& key, Value const& defaultValue) const;

    Value
    removeMember(char const* key);
    Value
    removeMember(std::string const& key);

    bool
    isMember(char const* key) const;
    [[nodiscard]] bool
    isMember(std::string const& key) const;
    [[nodiscard]] bool
    isMember(StaticString const& key) const;

    [[nodiscard]] Members
    getMemberNames() const;
 
    [[nodiscard]] std::string
    toStyledString() const;
 
    [[nodiscard]] const_iterator
    begin() const;
    [[nodiscard]] const_iterator
    end() const;
 
    iterator
    begin();
    iterator
    end();
 
    friend bool
    operator==(Value const&, Value const&);
    friend bool
    operator<(Value const&, Value const&);
 
private:
    Value&
    resolveReference(char const* key, bool isStatic);
 
private:
    union ValueHolder
    {
        Int intVal;
        UInt uintVal;
        double realVal;
        bool boolVal;
        char* stringVal;
        ObjectValues* mapVal{nullptr};
    } value_;
    ValueType type_ : 8;
    int allocated_ : 1 {};  // Notes: if declared as bool, bitfield is useless.
};
 
inline Value
toJson(xrpl::Number const& number)
{
    return to_string(number);
}
 
bool
operator==(Value const&, Value const&);
 
inline bool
operator!=(Value const& x, Value const& y)
{
    return !(x == y);
}
 
bool
operator<(Value const&, Value const&);
 
inline bool
operator<=(Value const& x, Value const& y)
{
    return !(y < x);
}
 
inline bool
operator>(Value const& x, Value const& y)
{
    return y < x;
}
 
inline bool
operator>=(Value const& x, Value const& y)
{
    return !(x < y);
}

class ValueAllocator
{
public:
    static constexpr auto kUnknown = (unsigned)-1;
 
    virtual ~ValueAllocator() = default;
 
    virtual char*
    makeMemberName(char const* memberName) = 0;
    virtual void
    releaseMemberName(char* memberName) = 0;
    virtual char*
    duplicateStringValue(char const* value, unsigned int length = kUnknown) = 0;
    virtual void
    releaseStringValue(char* value) = 0;
};

class ValueIteratorBase
{
public:
    using size_t = unsigned int;
    using difference_type = int;
    using SelfType = ValueIteratorBase;
 
    ValueIteratorBase();
 
    explicit ValueIteratorBase(Value::ObjectValues::iterator const& current);
 
    bool
    operator==(SelfType const& other) const
    {
        return isEqual(other);
    }
 
    bool
    operator!=(SelfType const& other) const
    {
        return !isEqual(other);
    }

    [[nodiscard]] Value
    key() const;

    [[nodiscard]] UInt
    index() const;

    [[nodiscard]] char const*
    memberName() const;
 
protected:
    [[nodiscard]] Value&
    deref() const;
 
    void
    increment();
 
    void
    decrement();
 
    [[nodiscard]] difference_type
    computeDistance(SelfType const& other) const;
 
    [[nodiscard]] bool
    isEqual(SelfType const& other) const;
 
    void
    copy(SelfType const& other);
 
private:
    Value::ObjectValues::iterator current_;
    // Indicates that iterator is for a null value.
    bool isNull_;
};

class ValueConstIterator : public ValueIteratorBase
{
    friend class Value;
 
public:
    using size_t = unsigned int;
    using difference_type = int;
    using reference = Value const&;
    using pointer = Value const*;
    using SelfType = ValueConstIterator;
 
    ValueConstIterator() = default;
    ValueConstIterator(ValueConstIterator const& other) = default;
 
private:
    explicit ValueConstIterator(Value::ObjectValues::iterator const& current);
 
public:
    SelfType&
    operator=(SelfType const& other);
 
    SelfType
    operator++(int)
    {
        SelfType const temp(*this);
        ++*this;
        return temp;
    }
 
    SelfType
    operator--(int)
    {
        SelfType const temp(*this);
        --*this;
        return temp;
    }
 
    SelfType&
    operator--()
    {
        decrement();
        return *this;
    }
 
    SelfType&
    operator++()
    {
        increment();
        return *this;
    }
 
    reference
    operator*() const
    {
        return deref();
    }
};

class ValueIterator : public ValueIteratorBase
{
    friend class Value;
 
public:
    using size_t = unsigned int;
    using difference_type = int;
    using reference = Value&;
    using pointer = Value*;
    using SelfType = ValueIterator;
 
    ValueIterator() = default;
    ValueIterator(ValueConstIterator const& other);
    ValueIterator(ValueIterator const& other);
 
private:
    explicit ValueIterator(Value::ObjectValues::iterator const& current);
 
public:
    SelfType&
    operator=(SelfType const& other);
 
    SelfType
    operator++(int)
    {
        SelfType const temp(*this);
        ++*this;
        return temp;
    }
 
    SelfType
    operator--(int)
    {
        SelfType const temp(*this);
        --*this;
        return temp;
    }
 
    SelfType&
    operator--()
    {
        decrement();
        return *this;
    }
 
    SelfType&
    operator++()
    {
        increment();
        return *this;
    }
 
    reference
    operator*() const
    {
        return deref();
    }
};
 
}  // namespace json