serializer.cpp

Go to the documentation of this file.

#define RAPIDJSON_HAS_STDSTRING 1
 
#include "core/serializer.h"
#include "rapidjson/document.h"
#include "rapidjson/istreamwrapper.h"
#include "rapidjson/prettywriter.h" // for stringify JSON
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
 
bool debug = false;
 
namespace Json
{
 
    rapidjson::Value
    ISInt::ToDom(rapidjson::Document&)
    {
        rapidjson::Value v;
        v.SetInt(value);
        return v;
    }
 
    void
    ISInt::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        assert(v.IsInt());
        value = v.GetInt();
    }
 
    rapidjson::Value
    ISFloat::ToDom(rapidjson::Document&)
    {
        rapidjson::Value v;
        v.SetFloat(value);
        return v;
    }
 
    void
    ISFloat::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        assert(v.IsFloat());
        value = v.GetFloat();
    }
 
    rapidjson::Value
    ISDouble::ToDom(rapidjson::Document&)
    {
        rapidjson::Value v;
        if (debug)
            std::cout << value << std::endl;
        v.SetDouble(value);
        return v;
    }
 
    void
    ISDouble::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        assert(v.IsDouble());
        value = v.GetFloat();
    }
 
    rapidjson::Value
    ISBool::ToDom(rapidjson::Document&)
    {
        rapidjson::Value v;
        v.SetBool(value);
        return v;
    }
 
    void
    ISBool::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        assert(v.IsBool());
        value = v.GetBool();
    }
 
    rapidjson::Value
    ISString::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value v;
        v.SetString(value.c_str(), d.GetAllocator());
        return v;
    }
 
    void
    ISString::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        assert(v.IsString());
        value = v.GetString();
    }
 
    rapidjson::Value
    ISValue::ToDom(rapidjson::Document& d)
    {
        ISProperties p = GetProperty();
 
        rapidjson::Value v;
        v.SetObject();
        v.AddMember("TypeId", GetName(d), d.GetAllocator());
 
        for (auto& element : p) {
            rapidjson::Value n;
            n.SetString(element.name, d.GetAllocator());
            if (element.value != nullptr)
                v.AddMember(n, element.value->ToDom(d), d.GetAllocator());
        }
        return v;
    }
 
    void
    ISValue::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        ISProperties p = GetProperty();
        if (v.IsObject()) {
            for (auto& element : p) {
                element.value->FromDom(v[element.name], d);
            }
        }
    }
 
    rapidjson::Value
    ISIntVector::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value a;
        a.SetArray();
        for (auto& element : value) {
            rapidjson::Value v;
            v.SetInt(element);
            a.PushBack(v, d.GetAllocator());
        }
        return a;
    }
 
    void
    ISIntVector::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        for (rapidjson::SizeType i = 0; i < v.Size();
             i++) { // rapidjson uses SizeType instead of size_t.
            value.push_back(v[i].GetInt());
        }
    }
 
    rapidjson::Value
    ISFloatVector::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value a;
        a.SetArray();
        for (auto& element : value) {
            rapidjson::Value v;
            v.SetFloat(element);
            a.PushBack(v, d.GetAllocator());
        }
        return a;
    }
 
    void
    ISFloatVector::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        for (rapidjson::SizeType i = 0; i < v.Size();
             i++) { // rapidjson uses SizeType instead of size_t.
            value.push_back(v[i].GetFloat());
        }
    }
 
    rapidjson::Value
    ISDoubleVector::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value a;
        a.SetArray();
        for (auto& element : value) {
            rapidjson::Value v;
            v.SetDouble(element);
            a.PushBack(v, d.GetAllocator());
        }
        return a;
    }
 
    void
    ISDoubleVector::FromDom(rapidjson::Value& v, rapidjson::Document&)
    {
        for (rapidjson::SizeType i = 0; i < v.Size();
             i++) { // rapidjson uses SizeType instead of size_t.
            value.push_back(v[i].GetDouble());
        }
    }
 
    int
    ISConstructors::AddConstructor(std::string name, ISValuePtr (*creator)())
    {
        m_TheRegistry[name] = creator;
 
        return 0;
    }
 
    ISValuePtr
    ISConstructors::GetObject(std::string name)
    {
        Json::ISValuePtr (*cnsctr)() = m_TheRegistry[name];
        Json::ISValuePtr no = cnsctr();
        return no;
    }
 
    void
    serialize(std::string filename, ISValue* top)
    {
        rapidjson::Document document;
        document.SetObject();
 
        ISProperties p = top->GetProperty();
 
        document.AddMember("TypeId", top->GetName(document),
                           document.GetAllocator());
 
        for (auto& element : p) {
            rapidjson::Value n;
            n.SetString(element.name, document.GetAllocator());
            if (element.value != nullptr)
                document.AddMember(n, element.value->ToDom(document),
                                   document.GetAllocator());
        }
 
        rapidjson::StringBuffer sb;
 
        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
        document.Accept(
            writer); // Accept() traverses the DOM and generates Handler events.
        std::fstream jsonout(filename, std::ios_base::out);
        jsonout << sb.GetString() << std::endl;
        jsonout.close();
    }
 
    void
    deserialize(std::string filename, ISValue* top)
    {
        rapidjson::Document document;
 
        std::ifstream ifs(filename);
        rapidjson::IStreamWrapper isw(ifs);
 
        document.ParseStream(isw);
        ISProperties p = top->GetProperty();
        if (document.IsObject()) {
            for (auto& element : p) {
                element.value->FromDom(document[element.name], document);
            }
        }
    }
 
} // namespace Json