SerializationContext.h

/*
 * Copyright (C) 2008 by Marc Boris Duerner
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef Pt_SerializationContext_h
#define Pt_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 SerializationInfo
{
    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;

        template <typename T>
        friend const BasicSerializationSurrogate<T>* getSurrogate(SerializationContext*);
 
        const SerializationSurrogate* getSurrogate(const std::type_info& ti) 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& );
 
        SerializationContext& operator=(const SerializationContext& );
 
    private:
        SerializationContextImpl* _cache;
        bool _refsEnabled;
};

 
template <typename T>
inline bool SerializationContext::compose(const SerializationInfo& si, T& type) const
{
    const BasicSerializationSurrogate<T>* surr = this->getSurrogate<T>();
    if( ! surr )
        return false;
 
    surr->compose(si, type);
    return true;
}
 
 
template <typename T>
inline bool SerializationContext::decompose(SerializationInfo& si, const T& type)
{
    const BasicSerializationSurrogate<T>* surr = this->getSurrogate<T>();
    if( ! surr )
        return false;
 
    surr->decompose(si, type);
    si.setTypeName( surr->typeName() );
    return true;
}
 
 
template <typename T>
inline const BasicSerializationSurrogate<T>* SerializationContext::getSurrogate() const
{
    const SerializationSurrogate* surr = this->getSurrogate( typeid(T) );
    if( ! surr )
        return 0;
 
    return static_cast<const BasicSerializationSurrogate<T>*>(surr);
}
 
 
template <typename T>
inline void SerializationContext::registerSurrogate( const std::string& typeName,
                                                     void (*compose)(const Pt::SerializationInfo& si, T& type),
                                                     void (*decompose)(Pt::SerializationInfo& si, const T& type) )
{
    SerializationSurrogate* surr = new BasicSerializationSurrogate<T>(typeName, compose, decompose);
    registerSurrogate(typeid(T), surr);
}
 
 
template <typename T>
inline void SerializationContext::registerSurrogate( const char* typeName,
                                                     void (*compose)(const Pt::SerializationInfo& si, T& type),
                                                     void (*decompose)(Pt::SerializationInfo& si, const T& type) )
{
    SerializationSurrogate* surr = new BasicSerializationSurrogate<T>(typeName, compose, decompose);
    registerSurrogate(typeid(T), surr);
}
 
} // namespace Pt
 
#endif // Pt_SerializationContext_h