VRS - The Virtual Rendering System

version 3.3

serializationmacros.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * 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. 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 FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

#ifndef VRS_SERIALIZATIONMACROS_H
#define VRS_SERIALIZATIONMACROS_H

#include <vrs/config.h>

namespace VRS {

class SharedObj;
class SerializationManager;

// this macro must be used for serializable (non-abstract) classes
// derived from VRS::SharedObj
#define VRS_SERIALIZABLE(SO_CLASS) \
    static ::VRS::SharedObj* newInstance() { return new SO_CLASS; } \
    virtual void serialize(::VRS::SerializationManager& manager); \
    virtual bool isRegisteredForSerialization() const { return isRegisteredForSerialization_; } \
    static const bool isRegisteredForSerialization_;

// this macro must be used for serializable abstract classes
// derived from VRS::SharedObj
#define VRS_SERIALIZABLE_ABSTRACT_CLASS(ABSTRACT_SO_CLASS) \
    virtual void serialize(::VRS::SerializationManager& manager);

// this macro must be used for serializable classes
// not derived from VRS::SharedObj
#define VRS_SERIALIZABLE_NO_SO_CLASS(NO_SO_CLASS) \
    void serialize(::VRS::SerializationManager& manager); \
    friend void \
    serialization( \
        ::VRS::SerializationManager& manager, \
        const std::string& attributeName, \
        NO_SO_CLASS& object \
    ) { \
        VRS_SERIALIZATION_START_CLASS(manager, attributeName, object); \
        object.serialize(manager); \
        VRS_SERIALIZATION_END_CLASS(manager, attributeName, object); \
    }

// this macro must be used for serializable enums defined
// outside of a class
#define VRS_SERIALIZABLE_ENUM(ENUM) \
    inline void \
    serialization( \
        ::VRS::SerializationManager& manager, \
        const std::string& attributeName, \
        ENUM& attributeValue \
    ) { \
        serialization(manager, attributeName, reinterpret_cast<int&>(attributeValue)); \
    }

// this macro must be used for serializable enums defined
// inside of a class
#define VRS_SERIALIZABLE_CLASS_ENUM(ENUM) \
    friend inline void \
    serialization( \
        ::VRS::SerializationManager& manager, \
        const std::string& attributeName, \
        ENUM& attributeValue \
    ) { \
        serialization(manager, attributeName, reinterpret_cast<int&>(attributeValue)); \
    }


#define VRS_SERIALIZATION_REGISTRATION(A) \
    const bool A::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A::ClassNameVRS(), A::newInstance);

#define VRS_SERIALIZATION_REGISTRATION_TEMPLATE(A) \
    template<class T> \
    const bool A<T>::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A<T>::ClassNameVRS(), A<T>::newInstance);

#define VRS_SERIALIZATION_REGISTRATION_TEMPLATE_2(A) \
    template<class T1, class T2> \
    const bool A<T1, T2>::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A<T1, T2>::ClassNameVRS(), A<T1, T2>::newInstance);

#define VRS_SERIALIZATION_REGISTRATION_TEMPLATE_3(A) \
    template<class T1, class T2, class T3> \
    const bool A<T1, T2, T3>::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A<T1, T2, T3>::ClassNameVRS(), A<T1, T2, T3>::newInstance);

#define VRS_SERIALIZATION_REGISTRATION_TEMPLATE_4(A) \
    template<class T1, class T2, class T3, class T4> \
    const bool A<T1, T2, T3, T4>::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A<T1, T2, T3, T4>::ClassNameVRS(), A<T1, T2, T3, T4>::newInstance);

#define VRS_SERIALIZATION_REGISTRATION_TEMPLATE_5(A) \
    template<class T1, class T2, class T3, class T4, class T5> \
    const bool A<T1, T2, T3, T4, T5>::isRegisteredForSerialization_ = \
        ::VRS::SerializationManager::registerClass(A<T1, T2, T3, T4, T5>::ClassNameVRS(), A<T1, T2, T3, T4, T5>::newInstance);

#define VRS_SERIALIZATION_PARENT_CLASS(MANAGER, PARENT) \
        MANAGER.startParentClass(typeid(PARENT).name()); \
        if(MANAGER.isReading() || MANAGER.isWriting()) { \
        PARENT::serialize(MANAGER); \
    } else { \
            static const VRS::ID classID = VRS::ID(typeid(PARENT).name()); \
        if(MANAGER.isRegistered(classID) || (classID == typeid(::VRS::SharedObj).name()) ) { \
                        MANAGER.serializeParent(classID.text()); \
                } else { \
                        PARENT::serialize(MANAGER); \
                } \
        } \
        MANAGER.endParentClass(typeid(PARENT).name());

#define VRS_SERIALIZATION_START_CLASS(MANAGER, ATTRIBUTE_NAME, OBJECT) \
    MANAGER.startClass(typeid(OBJECT).name(), ATTRIBUTE_NAME)

#define VRS_SERIALIZATION_END_CLASS(MANAGER, ATTRIBUTE_NAME, OBJECT) \
    MANAGER.endClass(typeid(OBJECT).name(), ATTRIBUTE_NAME)

} // namespace VRS

#endif // VRS_SERIALIZATIONMACROS_H

---

Generated on Wed May 23 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact