cel_serializable.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_serializable_h_
#define _cel_serializable_h_

#include "cel_memory.h"
#include "cel_autoptr.h"
#include "cel_string.h"
#include "cel_guid.h"
#include <vector>
#include <typeinfo>

namespace Celartem
{
    class Serializable;
    class Stream;
    struct SerializableTable;

    //------------------------------------------------------------------------
    typedef AutoPtr<Serializable> (* DeserializeFunc)(
        Stream *inStream, size_t inLevel, Endian inEndian);

    //------------------------------------------------------------------------
    class Serializable : public Referable
    {
    public:
        //--------------------------------------------------------------------
        virtual void serialize(
            Stream *inStream,
            size_t inLevel = 0,
            Endian inEndian = endianBig) = 0;

        //--------------------------------------------------------------------
        virtual AutoPtr<Serializable> duplicate() const = 0;

        //--------------------------------------------------------------------
        const Guid& getClassId() const;

        String getClassName() const;

        //--------------------------------------------------------------------
        // the functions below are generating class instances and usually you
        // do not have to know about them.
        //--------------------------------------------------------------------
        static AutoPtr<Serializable> deserializeClassInstance(
            const Guid& guid,
            Stream *inStream,
            size_t inLevel,
            Endian inEndian);

        static void registerClass(
            const Guid& guid, const char *inClassName, const char *inRttiName,
            DeserializeFunc inDeserializeFunc);

        static void registerClass(
            SerializableTable *inTable,
            const Guid& guid, const char *inClassName, const char *inRttiName,
            DeserializeFunc inDeserializeFunc);

        static void unregisterClass(
            const Guid& guid);

        static bool isRegistered(const Guid& guid);
        static const Guid& getClassId(const char *RttiName);
        static String getClassName(const Guid& guid);
        static String getClassName(const char *RttiName);
    };

    //------------------------------------------------------------------------
    template<typename T, bool IS_POD> struct SerializableDataHelper
    {
        static void serialize(
            T& t, Stream *inStream, size_t inLevel, Endian inEndian)
        {
            t.serialize(inStream, inLevel, inEndian);
        }
        
        static T deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            T t;
            t.deserialize(inStream, inLevel, inEndian);
            return t;
        }
    
    private:
        SerializableDataHelper();
        SerializableDataHelper(const SerializableDataHelper&);
        SerializableDataHelper& operator=(const SerializableDataHelper&);
    };

    //------------------------------------------------------------------------
    template<typename T> struct SerializableDataHelper<T, true>
    {
        static void serialize(
            T& t, Stream *inStream, size_t inLevel, Endian inEndian)
        {
            write<T>(inStream, t, inEndian);
        }
        
        static T deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            return read<T>(inStream, inEndian);
        }
    
    private:
        SerializableDataHelper();
        SerializableDataHelper(const SerializableDataHelper&);
        SerializableDataHelper& operator=(const SerializableDataHelper&);
    };

    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    template<class T> class SerializableData : public Serializable
    {
    public:
        //--------------------------------------------------------------------
        static Serializable *create(const T& t)
        {
            return new SerializableData(t);
        }

        //--------------------------------------------------------------------
        virtual void serialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            SerializableDataHelper<T, DataTraits<T>::isPOD>::serialize(
                m_obj, inStream, inLevel, inEndian);
        }

        //--------------------------------------------------------------------
        virtual AutoPtr<Serializable> duplicate() const
        {
            return new SerializableData(m_obj);
        }

        //--------------------------------------------------------------------
        static AutoPtr<Serializable> deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian)
        {
            return new SerializableData<T>(
                SerializableDataHelper<T, DataTraits<T>::isPOD>::deserialize(
                    inStream, inLevel, inEndian));
        }

        //--------------------------------------------------------------------
        T& getValue() {return m_obj;}

        const T& getValue() const {return m_obj;}

    private:
        T m_obj;

        // end-user should not call these functions
        SerializableData(const T& t) : m_obj(t) {}
        SerializableData(const SerializableData&);
        SerializableData& operator=(const SerializableData&);
    };
    
    typedef SerializableData<int> SerializableInt;
    typedef SerializableData<unsigned int> SerializableUInt;
    typedef SerializableData<int64_t> SerializableInt64;
    typedef SerializableData<uint64_t> SerializableUInt64;
    
} // namespace Celartem

//----------------------------------------------------------------------------
#define REGISTER_SERIALIZABLECLASS(ID,CLASSNAME) \
    ::Celartem::Serializable::registerClass( \
        ID,#CLASSNAME, typeid(CLASSNAME).name(), CLASSNAME::deserialize)

//----------------------------------------------------------------------------
#define REGISTER_SERIALIZABLECLASS2(ID,CLASSNAME,DISPNAME) \
    ::Celartem::Serializable::registerClass( \
        ID,DISPNAME, typeid(CLASSNAME).name(), CLASSNAME::deserialize)

#endif // _cel_serializable_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.