json_value.h

#ifndef XRPL_JSON_JSON_VALUE_H_INCLUDED
#define XRPL_JSON_JSON_VALUE_H_INCLUDED
 
#include <xrpl/basics/Number.h>
#include <xrpl/json/json_forwards.h>
 
#include <cstring>
#include <limits>
#include <map>
#include <string>
#include <vector>
 
namespace Json {
 
enum ValueType {
    nullValue = 0,  
    intValue,       
    uintValue,      
    realValue,      
    stringValue,    
    booleanValue,   
    arrayValue,     
    objectValue     
};
 
class StaticString
{
public:
    constexpr explicit StaticString(char const* czstring) : str_(czstring)
    {
    }
 
    constexpr
    operator char const*() const
    {
        return str_;
    }
 
    constexpr char const*
    c_str() const
    {
        return str_;
    }
 
private:
    char const* str_;
};
 
inline bool
operator==(StaticString x, StaticString y)
{
    return strcmp(x.c_str(), y.c_str()) == 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.c_str()) == 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 null;
    static constexpr Int minInt = std::numeric_limits<Int>::min();
    static constexpr Int maxInt = std::numeric_limits<Int>::max();
    static constexpr UInt maxUInt = std::numeric_limits<UInt>::max();
 
private:
    class CZString
    {
    public:
        enum 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;
        int
        index() const;
        char const*
        c_str() const;
        bool
        isStaticString() const;
 
    private:
        char const* cstr_;
        int index_;
    };
 
public:
    using ObjectValues = std::map<CZString, Value>;
 
public:
    Value(ValueType type = nullValue);
    Value(Int value);
    Value(UInt value);
    Value(double value);
    Value(char const* value);
    Value(ripple::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;
 
    ValueType
    type() const;
 
    char const*
    asCString() const;
    std::string
    asString() const;
    Int
    asInt() const;
    UInt
    asUInt() const;
    double
    asDouble() const;
    bool
    asBool() const;
 
    UInt
    asAbsUInt() const;
 
    // TODO: What is the "empty()" method this docstring mentions?
    bool
    isNull() const;
    bool
    isBool() const;
    bool
    isInt() const;
    bool
    isUInt() const;
    bool
    isIntegral() const;
    bool
    isDouble() const;
    bool
    isNumeric() const;
    bool
    isString() const;
    bool
    isArray() const;
    bool
    isArrayOrNull() const;
    bool
    isObject() const;
    bool
    isObjectOrNull() const;
 
    bool
    isConvertibleTo(ValueType other) const;
 
    UInt
    size() const;
 
    explicit
    operator bool() const;
 
    void
    clear();
 
    Value&
    operator[](UInt index);
    Value const&
    operator[](UInt index) const;
    Value
    get(UInt index, Value const& defaultValue) const;
    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;
    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;
    bool
    isMember(std::string const& key) const;
 
    Members
    getMemberNames() const;
 
    std::string
    toStyledString() const;
 
    const_iterator
    begin() const;
    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 int_;
        UInt uint_;
        double real_;
        bool bool_;
        char* string_;
        ObjectValues* map_{nullptr};
    } value_;
    ValueType type_ : 8;
    int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
};
 
inline Value
to_json(ripple::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:
    enum { unknown = (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 = unknown) = 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);
    }
 
    Value
    key() const;
 
    UInt
    index() const;
 
    char const*
    memberName() const;
 
protected:
    Value&
    deref() const;
 
    void
    increment();
 
    void
    decrement();
 
    difference_type
    computeDistance(SelfType const& other) const;
 
    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;
 
private:
    explicit ValueConstIterator(Value::ObjectValues::iterator const& current);
 
public:
    SelfType&
    operator=(ValueIteratorBase const& other);
 
    SelfType
    operator++(int)
    {
        SelfType temp(*this);
        ++*this;
        return temp;
    }
 
    SelfType
    operator--(int)
    {
        SelfType 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 temp(*this);
        ++*this;
        return temp;
    }
 
    SelfType
    operator--(int)
    {
        SelfType temp(*this);
        --*this;
        return temp;
    }
 
    SelfType&
    operator--()
    {
        decrement();
        return *this;
    }
 
    SelfType&
    operator++()
    {
        increment();
        return *this;
    }
 
    reference
    operator*() const
    {
        return deref();
    }
};
 
}  // namespace Json
 
#endif  // CPPTL_JSON_H_INCLUDED