Api-SerializationContext.h

/* Copyright (C) 2008 Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_API_SERIALIZATIONCONTEXT_H
#define PT_API_SERIALIZATIONCONTEXT_H
 
#include <Pt/Api.h>
#include <Pt/TypeInfo.h>
#include <Pt/FixupInfo.h>
#include <Pt/SerializationInfo.h>
#include <Pt/SerializationSurrogate.h>
#include <typeinfo>
#include <string>
 
namespace Pt {
 
class SerializationContextImpl;

class PT_API SerializationContext
{
    public:
        SerializationContext();

        virtual ~SerializationContext();

        inline void enableReferencing(bool enabled)
        { _refsEnabled = enabled; }

        inline bool isReferencing() const
        { return _refsEnabled; }

        SerializationInfo* get();

        void push(SerializationInfo* si);

        template <typename T>
        void registerSurrogate( const std::string& typeName,
                                void (*compose)(const Pt::SerializationInfo& si, T& type),
                                void (*decompose)(Pt::SerializationInfo& si, const T& type) );

        template <typename T>
        void registerSurrogate( const char* typeName,
                                void (*compose)(const Pt::SerializationInfo& si, T& type),
                                void (*decompose)(Pt::SerializationInfo& si, const T& type) );

        template <typename T>
        bool compose(const SerializationInfo& si, T& type) const;

        template <typename T>
        bool decompose(SerializationInfo& si, const T& type);

        template <typename T>
        const BasicSerializationSurrogate<T>* getSurrogate() const;
 
    public:
        void clear()
        { onClear(); }

        bool beginSave(const void* p, const char* name)
        { return onBeginSave(p, name); }

        void finishSave()
        { onFinishSave(); }

        void prepareId(const void* p)
        { onPrepareId(p); }

        const char* getId(const void* p)
        { return onGetId(p); }

        const char* makeId(const void* p)
        { return onMakeId(p); }
 
    public:     
        void beginLoad(void* obj, const std::type_info& ti,
                       const char* name, const char* id)
        { onBeginLoad(obj, ti, name, id); }
        
        void finishLoad()
        { onFinishLoad(); }

        void rebindTarget(const char* id, void* obj)
        { onRebindTarget(id, obj); }

        void rebindFixup(const char* id, void* obj, void* prev)
        { onRebindFixup(id, obj, prev); }

        void prepareFixup(void* obj, const char* id, FixupInfo::FixupHandler fh, unsigned mid)
        { onPrepareFixup(obj, id, fh, mid); }

        void fixup()
        { onFixup(); }
 
    protected:
        virtual void onClear();

        virtual bool onBeginSave(const void* p, const char* name);

        virtual void onFinishSave();

        virtual void onPrepareId(const void* p);

        virtual const char* onGetId(const void* p);

        virtual const char* onMakeId(const void* p);

        virtual void onBeginLoad(void* obj, const std::type_info& fixupInfo,
                                 const char* name, const char* id);

        virtual void onFinishLoad();

        virtual void onRebindTarget(const char* id, void* obj);

        virtual void onRebindFixup(const char* id, void* obj, void* prev);

        virtual void onPrepareFixup(void* obj, const char* id, FixupInfo::FixupHandler fh, unsigned mid);

        virtual void onFixup();
 
    private:
        void registerSurrogate(const std::type_info& ti, SerializationSurrogate* surrogate);

        SerializationContext(const SerializationContext& si)
        {}

        SerializationContext& operator=(const SerializationContext& si)
        { return *this; }
 
    private:
        SerializationContextImpl* _cache;
        bool _refsEnabled;
};
 
} // namespace Pt
 
#endif