Json.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/String/Id.h"
#include "Honey/Misc/Variant.h"
#include "Honey/Memory/SmallAllocator.h"

namespace honey
{
namespace json
{

enum class ValueType                                { Null, Int, Real, Bool, String, Array, Object };
struct null_t {};
static null_t null;

struct ValueError : Exception                       { EXCEPTION(ValueError) };
    
template<class Config> class Value_;


template<bool ordered = false, template<class> class Alloc = SmallAllocator>
struct Config
{
    typedef Value_<Config> Value;
    typedef recursive_wrap<Value, Alloc<Value>> value_wrap;
    typedef vector<value_wrap, Alloc<value_wrap>> Array;
    typedef stdutil::unordered_map<NameId, value_wrap, Alloc> ObjectUnordered;
    
    struct ObjectOrdered : ObjectUnordered
    {
        typedef typename ObjectUnordered::iterator Iter;
        typedef typename ObjectUnordered::const_iterator ConstIter;
        
        template<class Pair>
        pair<Iter, bool> insert(Pair&& pair)
        {
            auto res = ObjectUnordered::insert(forward<Pair>(pair));
            if (res.second) orderedNames.push_back(res.first->first);
            return res;
        }
        
        Iter erase(ConstIter pos)                   { stdutil::eraseVal(orderedNames, pos->first); return ObjectUnordered::erase(pos); }
        void clear()                                { orderedNames.clear(); ObjectUnordered::clear(); }
        
        const String& name(const Id& id) const
        {
            auto it = this->find(NameId(id));
            if (it == this->end()) throw_ ValueError() << "Value not found. Id: " << id;
            return it->first.name();
        }
    
        vector<Id, Alloc<Id>> orderedNames;
    };
    
    typedef typename std::conditional<ordered, ObjectOrdered, ObjectUnordered>::type Object;
    
    typedef variant<null_t, int64, double, bool, String, Array, Object> Variant;
};

template<class Config_>
class Value_ : public Config_::Variant
{
public:
    typedef Config_ Config;
    typedef typename Config::Array Array;
    typedef typename Config::Object Object;
    typedef typename Config::ObjectUnordered ObjectUnordered;
    typedef typename Config::ObjectOrdered ObjectOrdered;
    typedef typename Config::Variant Variant;
    
    Value_()                                        : Value_(null) {}
    template<class T>
    Value_(T&& val)                                 : Variant(forward<T>(val)) {}
    Value_(const Value_& rhs)                       : Value_(static_cast<const Variant&>(rhs)) {}
    Value_(Value_& rhs)                             : Value_(static_cast<Variant&>(rhs)) {}
    Value_(Value_&& rhs)                            : Value_(move(static_cast<Variant&>(rhs))) {}
    
    template<class T>
    Value_& operator=(T&& val)                      { Variant::operator=(forward<T>(val)); return *this; }
    Value_& operator=(const Value_& rhs)            { Variant::operator=(static_cast<const Variant&>(rhs)); return *this; }
    Value_& operator=(Value_& rhs)                  { Variant::operator=(static_cast<Variant&>(rhs)); return *this; }
    Value_& operator=(Value_&& rhs)                 { Variant::operator=(move(static_cast<Variant&>(rhs))); return *this; }
    
    Value_& operator[](szt i)
    {
        assert(type() == ValueType::Array);
        auto& arr = get_<Array>();
        assert(i < arr.size());
        return arr[i];
    }
    const Value_& operator[](szt i) const           { return const_cast<Value_&>(*this)[i]; }
    
    Value_& operator[](const String& name)
    {
        assert(type() == ValueType::Object);
        auto& obj = get_<Object>();
        Id id = name;
        auto it = obj.find(NameId(id));
        if (it == obj.end()) it = obj.insert(make_pair(NameId(name, id), Value_())).first;
        return it->second;
    }
    //resolves ambiguity between String and built-in asymmetric operator[](int, const Char*)
    Value_& operator[](const Char* name)            { return (*this)[String(name)]; }
    Value_& operator[](const char* name)            { return (*this)[String(name)]; }
    
    Value_& operator[](const Id& id)
    {
        assert(type() == ValueType::Object);
        auto& obj = get_<Object>();
        auto it = obj.find(NameId(id));
        if (it == obj.end()) throw_ ValueError() << "Value not found. Id: " << id;
        return it->second;
    }
    const Value_& operator[](const Id& id) const    { return const_cast<Value_&>(this)[id]; }
    //resolves ambiguity between Id and int
    Value_& operator[](const IdLiteral& id)             { return (*this)[Id(id)]; }
    const Value_& operator[](const IdLiteral& id) const { return (*this)[Id(id)]; }
    
    ValueType type() const                          { return static_cast<ValueType>(Variant::type()); }
    
    typename Array::iterator begin()                { assert(type() == ValueType::Array); return get_<Array>().begin(); }
    typename Array::const_iterator begin() const    { assert(type() == ValueType::Array); return get_<Array>().begin(); }
    
    typename Array::iterator end()                  { assert(type() == ValueType::Array); return get_<Array>().end(); }
    typename Array::const_iterator end() const      { assert(type() == ValueType::Array); return get_<Array>().end(); }
    
    Value_& front()                                 { assert(!empty()); return get_<Array>().front(); }
    const Value_& front() const                     { assert(!empty()); return get_<Array>().front(); }
    Value_& back()                                  { assert(!empty()); return get_<Array>().back(); }
    const Value_& back() const                      { assert(!empty()); return get_<Array>().back(); }
    
    template<class T>
    void push_back(T&& val)                         { assert(type() == ValueType::Array); get_<Array>().push_back(Value_(forward<T>(val))); }
    void pop_back()                                 { assert(type() == ValueType::Array); get_<Array>().pop_back(); }
    
    bool contains(const Id& id)                     { assert(type() == ValueType::Object); return get_<Object>().count(NameId(id)); }
    
    template<class T>
    void insert(szt i, T&& val)
    {
        assert(type() == ValueType::Array);
        auto& arr = get_<Array>();
        assert(i <= arr.size());
        arr.insert(arr.begin() + i, Value_(forward<T>(val)));
    }
    

    template<class T>
    pair<typename Object::iterator, bool> insert(const String& name, T&& val)
    {
        assert(type() == ValueType::Object);
        return get_<Object>().insert(make_pair(NameId(name), Value_(forward<T>(val))));
    }
    
    void erase(szt i)
    {
        assert(type() == ValueType::Array);
        auto& arr = get_<Array>();
        assert(i < arr.size());
        arr.erase(arr.begin() + i);
    }
    
    bool erase(const Id& id)
    {
        assert(type() == ValueType::Object);
        auto& obj = get_<Object>();
        auto it = obj.find(NameId(id));
        if (it == obj.end()) return false;
        obj.erase(it);
        return true;
    }
    bool erase(const IdLiteral& id)                 { return erase(Id(id)); }
    
    void clear()
    {
        assert(type() == ValueType::Array || type() == ValueType::Object);
        return visit(overload(
            [](Array& arr) { arr.clear(); },
            [](Object& obj) { obj.clear(); }
        ));
    }
    
    bool empty() const                              { return !size(); }
    
    szt size() const
    {
        assert(type() == ValueType::Array || type() == ValueType::Object);
        return this->template visit<szt>(overload(
            [](const Array& arr) { return arr.size(); },
            [](const Object& obj) { return obj.size(); }
        ));
    }
    
private:    
    template<class T> T& get_()                     { return this->template get<T>(); }
    template<class T> const T& get_() const         { return this->template get<T>(); }
};

typedef Value_<Config<>> Value;


template<class Config> istream& operator>>(istream& is, Value_<Config>& val);

namespace priv
{
    struct WriterManip : Manip<WriterManip>
    {
        bool beautify = false;
        bool escapeSlash = false;
    };
}
inline ostream& beautify(ostream& os)               { priv::WriterManip::inst(os).beautify = true; return os; }
inline ostream& escapeSlash(ostream& os)            { priv::WriterManip::inst(os).escapeSlash = true; return os; }

template<class Config> ostream& operator<<(ostream& os, const Value_<Config>& val);

}

extern template class Manip<json::priv::WriterManip>;

}