serializer.h

Go to the documentation of this file.

#pragma once
 
#include "rapidjson/document.h"
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
 
extern bool debug;
 
namespace Json
{
    // IS... IntroSpection
    class ISValue;
    using ISValuePtr = std::shared_ptr<ISValue>;
    using ISValues = std::vector<ISValuePtr>;
 
///
///\brief Serializing and deserializing (persistent values) requires recflection which is a way for the programmer to ensure that
///the data you serialize will get back to the place you want it to be when you deserialize it later.
///As this is not supported by C++ this is implemented by the ISProperty structure with the ISValue helper classes. The ISValue keeps the references
///to the actual values in the application. The ISProperty is the collection of all the application data.
///
    struct ISProperty
    {
        std::string name;
        ISValuePtr value;
    };
///
///\brief ISProperties is a vector with ISProperty.
///
    using ISProperties = std::vector<ISProperty>;
///
///\brief Rflection is made possible by the help of the ISValue class and the type classes. Each type needs their own implementation for
///reflection to work. At the moment only JSON is supported by this library.
///Making the library work for other format than JSON would require implementing each type again for the new format by in theory would not
///impact the application programmers at all
///
    class ISValue
    {
      public:
///
///\brief GetProperty enables the serializer to deal with composite type like objects and members.
///
        virtual ISProperties
        GetProperty()
        {
            return ISProperties{};
        };
///
///\brief For future expansion.
///
        virtual void CreateObject(){};
///
///\brief For future expansion
///
        virtual rapidjson::Value
        GetName(rapidjson::Document& d)
        {
///
///\brief Typeid is mostly implemented for future expansion, but it helps with making the JSON file more readable for humans.
///
            rapidjson::Value tid;
            tid.SetString(typeid(*this).name(), d.GetAllocator());
            return tid;
        };
///
///\brief ToDom is the function that enables the serializer to take data from the application to the JSON file.
///
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
///
///\brief FromDom is the function that enables the serializer to get data out of the JSON file and put it in the application.
///
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for integers
///
    class ISInt : public ISValue
    {
        int& value;
 
      public:
        ISInt(int& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for floats
///
    class ISFloat : public ISValue
    {
        float& value;
 
      public:
        ISFloat(float& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for doubles
///
    class ISDouble : public ISValue
    {
        double& value;
 
      public:
        ISDouble(double& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for bools
///
    class ISBool : public ISValue
    {
        bool& value;
 
      public:
        ISBool(bool& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for strings
///
    class ISString : public ISValue
    {
        std::string& value;
 
      public:
        ISString(std::string& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
///
///\brief Implementation for objects
///
    template<typename T>
    class ISObject : public ISValue
    {
        std::shared_ptr<T>& value;
 
      public:
        ISObject(std::shared_ptr<T>& v) : value(v){};
        virtual rapidjson::Value GetName(rapidjson::Document& d);
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
        void CreateObject();
    };
 
    template<typename T>
    rapidjson::Value
    ISObject<T>::ToDom(rapidjson::Document& d)
    {
        if (value != nullptr)
            return value->ToDom(d);
        else
            return rapidjson::Value("");
    };
 
    template<typename T>
    void
    ISObject<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        if (v.IsObject()) {
            CreateObject();
            value->FromDom(v, d);
        }
    };
 
    template<typename T>
    rapidjson::Value
    ISObject<T>::GetName(rapidjson::Document& d)
    {
        rapidjson::Value tid;
        tid.SetString(typeid(T).name(), d.GetAllocator());
        return tid;
    }
 
    template<typename T>
    void
    ISObject<T>::CreateObject()
    {
        value = std::make_shared<T>();
    }
 
///
///\brief Implementation for a vector with objects
///
    template<typename T>
    class ISObjectVector : public ISValue
    {
        std::vector<std::shared_ptr<T>>& value;
 
      public:
        ISObjectVector(std::vector<std::shared_ptr<T>>& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    template<typename T>
    rapidjson::Value
    ISObjectVector<T>::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value a;
        a.SetArray();
        for (auto& element : value) {
            rapidjson::Value v = element->ToDom(d);
            a.PushBack(v, d.GetAllocator());
        }
        return a;
    }
 
    template<typename T>
    void
    ISObjectVector<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        for (rapidjson::SizeType i = 0; i < v.Size();
             i++) { // rapidjson uses SizeType instead of size_t.
            std::shared_ptr<T> cv = std::make_shared<T>();
            cv->FromDom(v[i], d);
            value.push_back(cv);
        }
    }
 
///
///\brief Implementation for a vector with vectors with objects
///
    template<typename T>
    class ISObjVecVec : public ISValue
    {
        std::vector<std::vector<std::shared_ptr<T>>>& value;
 
      public:
        ISObjVecVec(std::vector<std::vector<std::shared_ptr<T>>>& v)
            : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    template<typename T>
    rapidjson::Value
    ISObjVecVec<T>::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value outer;
        outer.SetArray();
        for (auto& outer_element : value) {
            rapidjson::Value inner;
            inner.SetArray();
            for (auto& inner_element : outer_element) {
                rapidjson::Value v = inner_element->ToDom(d);
                inner.PushBack(v, d.GetAllocator());
            }
            outer.PushBack(inner, d.GetAllocator());
        }
        return outer;
    }
 
    template<typename T>
    void
    ISObjVecVec<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        for (rapidjson::SizeType i = 0; i < v.Size(); i++) {
            std::vector<std::shared_ptr<T>> line;
            for (rapidjson::SizeType j = 0; j < v[i].Size(); j++) {
                std::shared_ptr<T> cv = std::make_shared<T>();
                cv->FromDom(v[i][j], d);
                line.push_back(cv);
            }
            value.push_back(line);
        }
    }
 
///
///\brief Implementation for a vector with vectors with members
///
    template<typename T>
    class ISMemVecVec : public ISValue
    {
        std::vector<std::vector<T>>& value;
 
      public:
        ISMemVecVec(std::vector<std::vector<T>>& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    template<typename T>
    rapidjson::Value
    ISMemVecVec<T>::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value outer;
        outer.SetArray();
        for (auto& outer_element : value) {
            rapidjson::Value inner;
            inner.SetArray();
            for (auto& inner_element : outer_element) {
                rapidjson::Value v = inner_element.ToDom(d);
                inner.PushBack(v, d.GetAllocator());
            }
            outer.PushBack(inner, d.GetAllocator());
        }
        return outer;
    }
 
    template<typename T>
    void
    ISMemVecVec<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        for (rapidjson::SizeType i = 0; i < v.Size(); i++) {
            std::vector<T> line;
            for (rapidjson::SizeType j = 0; j < v[i].Size(); j++) {
                T cv;
                cv.FromDom(v[i][j], d);
                line.push_back(cv);
            }
            value.push_back(line);
        }
    }
 
///
///\brief Implementation for Members
///
    template<typename T>
    class ISMember : public ISValue
    {
        T& value;
 
      public:
        ISMember(T& v) : value(v){};
        virtual rapidjson::Value GetName(rapidjson::Document& d);
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
        void CreateObject();
    };
 
    template<typename T>
    rapidjson::Value
    ISMember<T>::ToDom(rapidjson::Document& d)
    {
        return value.ToDom(d);
    };
 
    template<typename T>
    void
    ISMember<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        value.FromDom(v, d);
    };
 
    template<typename T>
    rapidjson::Value
    ISMember<T>::GetName(rapidjson::Document& d)
    {
        rapidjson::Value tid;
        tid.SetString(typeid(T).name(), d.GetAllocator());
        return tid;
    }
 
    template<typename T>
    void
    ISMember<T>::CreateObject()
    {
        assert(false);
    }
 
///
///\brief Implementation for a vector with members
///
    template<typename T>
    class ISMemberVector : public ISValue
    {
        std::vector<T>& value;
 
      public:
        ISMemberVector(const ISMemberVector<T>&) { assert(false); };
 
        ISMemberVector(std::vector<T>& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    template<typename T>
    rapidjson::Value
    ISMemberVector<T>::ToDom(rapidjson::Document& d)
    {
        rapidjson::Value a;
        a.SetArray();
        debug = true;
        for (auto& element : value) {
            rapidjson::Value v = element.ToDom(d);
            a.PushBack(v, d.GetAllocator());
        }
        debug = false;
        return a;
    }
 
    template<typename T>
    void
    ISMemberVector<T>::FromDom(rapidjson::Value& v, rapidjson::Document& d)
    {
        for (rapidjson::SizeType i = 0; i < v.Size();
             i++) { // rapidjson uses SizeType instead of size_t.
            T cv;
            cv.FromDom(v[i], d);
            value.push_back(cv);
        }
    }
 
    using ISIV = std::vector<int>;
 
///
///\brief Implementation for a vector with integers
///
    class ISIntVector : public ISValue
    {
        std::vector<int>& value;
 
      public:
        ISIntVector(ISIV& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    using ISFV = std::vector<float>;
 
///
///\brief Implementation for a vector with floats
///
    class ISFloatVector : public ISValue
    {
        std::vector<float>& value;
 
      public:
        ISFloatVector(ISFV& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    using ISDV = std::vector<double>;
 
///
///\brief Implementation for a vector with doubles
///
    class ISDoubleVector : public ISValue
    {
        std::vector<double>& value;
 
      public:
        ISDoubleVector(ISDV& v) : value(v){};
        virtual rapidjson::Value ToDom(rapidjson::Document& d);
        virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    };
 
    // using ISBV = std::vector<bool>;
    // class ISBoolVector: public ISValue {
    // std::vector<bool> &value;
    // public:
    // ISBoolVector (ISBV &v) : value(v) {};
    // virtual rapidjson::Value ToDom(rapidjson::Document& d);
    // virtual void FromDom(rapidjson::Value& v, rapidjson::Document& d);
    //};
 
///
///\brief Implemented for future expansion
///
    class ISConstructors
    { // OBS OBS this is an implementation of the Singleton design pattern.
      public:
        static ISConstructors&
        GetInstance()
        {
            static ISConstructors instance; // Guaranteed to be destroyed.
                                            // Instantiated on first use.
            return instance;
        }
 
      private:
        ISConstructors(){}; // Constructor? (the {} brackets) are needed here.
 
        std::map<std::string, Json::ISValuePtr (*)()> m_TheRegistry;
 
      public:
        ISConstructors(const ISConstructors&) = delete;
        void operator=(const ISConstructors&) = delete;
 
        int AddConstructor(std::string name, ISValuePtr (*creator)());
        ISValuePtr GetObject(std::string name);
    };
///
///\brief Function to start serializing an onbject.
///
///\param std::string filename
///Name of the file you want to store the application data in.
///
///\param ISValue* p
///A pointer to the object you want to serialize.
///
    void serialize(std::string filename, ISValue* p);
///
///\brief Function to start deserializing a file
///
///\param std::string filename
///Name of the file you want to extract data from.
///
///\param ISValue* p
///A pointer to the top object so it know where to start.
///
    void deserialize(std::string filename, ISValue* p);
///
///\brief Macros
///To serialize an object you need to have the GetProperty() function in the object.
///This is complex for each application programmer to execute so therefore these macros have benn implemented.
///Each macro start with JSONSTART then each of the types you want to serialize and to end the macro you write JSONEND.
///
#define JSON \
  public     \
    Json::ISValue
 
#define JSONSTART                            \
    virtual Json::ISProperties GetProperty() \
    {                                        \
        Json::ISProperties prop = {
#define JSONINT(m)                             \
    {                                          \
#        m, std::make_shared < Json::ISInt>(m) \
    }
#define JSONINTVECTOR(m)                             \
    {                                                \
#        m, std::make_shared < Json::ISIntVector>(m) \
    }
#define JSONFLOAT(m)                             \
    {                                            \
#        m, std::make_shared < Json::ISFloat>(m) \
    }
#define JSONFLOATVECTOR(m)                             \
    {                                                  \
#        m, std::make_shared < Json::ISFloatVector>(m) \
    }
#define JSONDOUBLE(m)                             \
    {                                             \
#        m, std::make_shared < Json::ISDouble>(m) \
    }
#define JSONDOUBLEVECTOR(m)                             \
    {                                                   \
#        m, std::make_shared < Json::ISDoubleVector>(m) \
    }
#define JSONBOOL(m)                             \
    {                                           \
#        m, std::make_shared < Json::ISBool>(m) \
    }
#define JSONSTRING(m)                             \
    {                                             \
#        m, std::make_shared < Json::ISString>(m) \
    }
#define JSONOBJECT(T, m)                               \
    {                                                  \
#        m, std::make_shared < Json::ISObject < T>>(m) \
    }
#define JSONOBJECTVECTOR(T, m)                               \
    {                                                        \
#        m, std::make_shared < Json::ISObjectVector < T>>(m) \
    }
#define JSONOBJVECVEC(T, m)                               \
    {                                                     \
#        m, std::make_shared < Json::ISObjVecVec < T>>(m) \
    }
#define JSONMEMBER(T, m)                               \
    {                                                  \
#        m, std::make_shared < Json::ISMember < T>>(m) \
    }
#define JSONMEMBERVECTOR(T, m)                               \
    {                                                        \
#        m, std::make_shared < Json::ISMemberVector < T>>(m) \
    }
#define JSONMEMVECVEC(T, m)                               \
    {                                                     \
#        m, std::make_shared < Json::ISMemVecVec < T>>(m) \
    }
 
#define JSONEND  \
    }            \
    ;            \
    return prop; \
    }            \
    ;
 
} // namespace Json