VRS - The Virtual Rendering System

version 3.3

serializationmanager.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 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.
 ******************************************************************************/

// $Id: serializationmanager.h 4633 2005-01-03 01:43:11Z klimetschek $
// $Date: 2005-01-03 02:43:11 +0100 (Mon, 03 Jan 2005) $
// $Revision: 4633 $
// $State$
// $Author: klimetschek $
//
// $Log$
// Revision 1.22  2005/01/03 01:43:08  klimetschek
// - modified win32 project layout, splitted vrs.vcproj into vrs_container, vrs_core, vrs_sg, vrs_image, vrs_opengl and vrs_io
// - removed vrs.vcproj
// minor things:
// - added all glutexamples to vrs4glut.sln
// - fixed some problems in glutexamples
// - removed all project references from all VS projects (using solution wide project dependencies instead)
//
// Revision 1.21  2004/12/10 14:40:49  baumann
// added method canHandleRawData()
//
// Revision 1.20  2004/11/11 16:03:32  kirsch
// removed legacy operator-() formerly used for serialization
//
// Revision 1.19  2004/10/04 06:07:22  baumann
// moved serialization of VRS::Color and VRS::Vector into VRS::SerializationManager
//
// Revision 1.18  2004/03/16 15:58:26  kirsch
// fix for VC6 due to recent changes in errorhandler
//
// Revision 1.17  2004/03/12 16:28:39  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.16  2004/02/26 16:23:26  gerber
// added methods startParentClass(...) and endParentClass(...)
//
// Revision 1.15  2004/02/06 09:56:26  wendland
// added method serializeParent(const std::string&)
//
// Revision 1.14  2004/01/29 13:36:44  wendland
// added method isWriting()
//
// Revision 1.13  2004/01/29 10:36:39  wendland
// - added parameter const std::string& knownType to method serialize(SharedObj)
// - added method getRegisteredClasses()
//
// Revision 1.12  2004/01/22 21:11:14  baumann
// added function serializationRawData()
//
// Revision 1.11  2004/01/19 11:43:57  baumann
// serialization mechanism improved
//
// Revision 1.10  2004/01/19 07:28:03  baumann
// serialization mechanism improved
//
// Revision 1.9  2004/01/15 15:46:23  baumann
// using ::VRS:: prefix for SerializationManager in macros
//
// Revision 1.8  2004/01/15 14:16:53  baumann
// serialization mechanism improved
//
// Revision 1.7  2004/01/14 07:32:19  baumann
// - skipping of default values added
// - typo fixed for enum serialization
//
// Revision 1.6  2004/01/13 16:51:31  baumann
// bug fixed
//
// Revision 1.5  2004/01/13 15:48:31  baumann
// VRS_SERIALIZATION_START_CLASS()/*_END_CLASS() macros changed
//
// Revision 1.4  2004/01/13 11:37:05  baumann
// #include <vector> removed
//
// Revision 1.3  2004/01/13 11:19:45  baumann
// added startClass() and endClass() to SerializationManager
//
// Revision 1.2  2004/01/13 10:05:21  baumann
// renamed global function serialize() to serialization()
//
// Revision 1.1  2004/01/13 09:04:29  baumann
// DocumentHandler renamed to SerializationManager
//
// Revision 1.1  2004/01/12 15:15:50  baumann
// new class VRS::DocumentHandler is now base class of class VRS::Document
//

#ifndef VRS_SERIALIZATIONMANAGER_H
#define VRS_SERIALIZATIONMANAGER_H

#include <vrs/sharedobj.h>
#include <vrs/serializationmacros.h>

namespace VRS {

class Color;
template<typename TYPE> class Vector3Base;
typedef Vector3Base<double> Vector;

class VRS_CORE_API SerializationManager : public SharedObj {
public:

    virtual bool isReading() const = 0;
        virtual bool isWriting() const  { return !isReading(); }

    virtual bool skipDefaultValues() const = 0;

    virtual void startClass(const std::string& classID, const std::string& attributeName) = 0;
    virtual void endClass(  const std::string& classID, const std::string& attributeName) = 0;
    virtual void classVersion(UINT8& version) = 0;

    virtual void serialize(const std::string& attributeName, bool&         attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, UINT8&        attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, INT8&         attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, UINT16&       attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, INT16&        attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, UINT32&       attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, INT32&        attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, UINT64&       attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, INT64&        attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, float&        attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, double&       attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, std::string&  attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, ID&           attributeValue) = 0;

    virtual void serialize(const std::string& attributeName, Vector&       attributeValue) = 0;
    virtual void serialize(const std::string& attributeName, Color&        attributeValue) = 0;

    virtual void serialize(const std::string& attributeName, SharedObj*&   attributeValue,
                                                                                                                         const std::string& knownType) = 0;
#ifdef VRS_HAS_WSTRING
    virtual void serialize(const std::string& attributeName, std::wstring& attributeValue) = 0;
#endif // VRS_HAS_WSTRING

    virtual void serialize(const std::string& attributeName, void* pointer, unsigned int bytes) = 0;

    virtual bool canHandleRawData() const { return false; }

        virtual void serializeParent(const std::string& parentName) {}
        virtual void startParentClass(const std::string& classID) {}
        virtual void endParentClass(const std::string& classID) {}

    typedef SharedObj* (*DefaultConstructor)();
    static bool registerClass(const ID& classID, DefaultConstructor defaultCtor);
    static bool unregisterClass(const ID& classID);
    static bool isRegistered(const ID& classID);
    static void unregisterAllClasses();
        static Iterator<ID>* getRegisteredClasses();
    static SharedObj* createDefaultObject(const ID& classID);

    VRS_TYPEINFO(SerializationManager, SharedObj);
}; // class SerializationManager


// this function allows to read/write raw memory content
inline void
serializationRawData(
    SerializationManager& manager,
    const std::string& attributeName,
    void* pointer,
    unsigned int bytes
) {
    manager.serialize(attributeName, pointer, bytes);
}


// this overloaded function allows to define default values for
// the serialized elements
template<typename T>
void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    T& attributeValue,
    const T& defaultValue
) {
        // For VC6: use VRS_Error instead of VRS_CheckArg here, so that the macro 
        // is expended also in release-mode. This circumvents strange linking errors.
    VRS_Error(
        !attributeName.empty(),
        "cannot use default values for unnamed attributes"
    );

    if(manager.isReading()) {
        try {
            serialization(manager, attributeName, attributeValue);
        } catch(...) {
            // no such attribute
            attributeValue = defaultValue;
        }
    } else {
        if(!manager.skipDefaultValues() || (attributeValue != defaultValue)) {
            serialization(manager, attributeName, attributeValue);
        }
    }
}

#define VRS_DEFINE_SERIALIZE_FOR_BUILTIN(BUILTIN) \
    inline void \
    serialization( \
        SerializationManager& manager, \
        const std::string& attributeName, \
        BUILTIN& attributeValue \
    ) { \
        manager.serialize(attributeName, attributeValue); \
    }

VRS_DEFINE_SERIALIZE_FOR_BUILTIN(bool);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(UINT8);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(INT8);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(UINT16);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(INT16);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(UINT32);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(INT32);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(UINT64);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(INT64);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(float);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(double);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(std::string);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(ID);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(Vector);
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(Color);
#ifdef VRS_HAS_WSTRING
VRS_DEFINE_SERIALIZE_FOR_BUILTIN(std::wstring);
#endif // VRS_HAS_WSTRING

#undef VRS_DEFINE_SERIALIZE_FOR_BUILTIN

} // namespace VRS

#endif // VRS_SERIALIZATIONMANAGER_H

---

Generated on Wed May 22 06:00:18 2013 by Doxygen 1.5.6

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