VRS - The Virtual Rendering System

version 3.3

stl_serialization.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: stl_serialization.h 6709 2009-10-08 14:26:18Z Tassilo_Glander $
//
// $Log$
// Revision 1.9  2006/05/02 06:58:11  baumann
// fixed impl of CanWriteAsRawData()
//
// Revision 1.8  2006/03/09 14:17:38  baumann
// serialization of std::vector<bool> fixed again :-(
//
// Revision 1.7  2006/03/07 12:31:02  baumann
// added missing "inline" keyword for std::vector<bool> specialization
//
// Revision 1.6  2006/03/07 12:25:54  baumann
// "raw" serialization of std::vector<bool> fixed
//
// Revision 1.5  2006/03/01 14:52:43  maass
// gcc fix: double defined canWriteAsRawData templates
//
// Revision 1.4  2006/02/22 11:52:28  baumann
// added canWriteAsRawData(9 for bool and signed data types
//
// Revision 1.3  2006/02/06 15:41:12  baumann
// missing include added
//
// Revision 1.2  2004/12/10 14:40:30  baumann
// moved serialization of std::vector<T> into stl_serialization.h
//
// Revision 1.1  2004/11/20 17:10:27  baumann
// stl_serialization.h added
//

#ifndef VRS_CONTAINER_STLSERIALIZATION_H
#define VRS_CONTAINER_STLSERIALIZATION_H

#include <vrs/serializationmacros.h>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <vector>

#include <vrs/vertexdata.h>

namespace VRS {

    template<typename T> struct CanWriteAsRawData { enum { value = false }; };

    template<> struct CanWriteAsRawData<char>           { enum { value = true }; };
    template<> struct CanWriteAsRawData<unsigned char>  { enum { value = true }; };
    template<> struct CanWriteAsRawData<signed char>    { enum { value = true }; };
    template<> struct CanWriteAsRawData<short>          { enum { value = true }; };
    template<> struct CanWriteAsRawData<unsigned short> { enum { value = true }; };
    template<> struct CanWriteAsRawData<int>            { enum { value = true }; };
    template<> struct CanWriteAsRawData<unsigned int>   { enum { value = true }; };
    template<> struct CanWriteAsRawData<long>           { enum { value = true }; };
    template<> struct CanWriteAsRawData<unsigned long>  { enum { value = true }; };
    template<> struct CanWriteAsRawData<float>          { enum { value = true }; };
    template<> struct CanWriteAsRawData<double>         { enum { value = true }; };

    template<unsigned int DIM, typename T>
    struct CanWriteAsRawData<VertexData<DIM, T> > {
        enum { value = CanWriteAsRawData<T>::value };
    };

    template<typename T1, typename T2>
    struct CanWriteAsRawData<std::pair<T1, T2> > {
        enum { value = (CanWriteAsRawData<T1>::value && CanWriteAsRawData<T2>::value) };
    };

    template<typename T>
    void serialization(
        SerializationManager& manager,
        const std::string& attributeName,
        std::vector<T>& attributeValue
    ) {
        VRS_SERIALIZATION_START_CLASS(manager, attributeName, attributeValue);

        unsigned int size = static_cast<unsigned int>(attributeValue.size());
        serialization(manager, "Size", size);
        attributeValue.resize(size);

        bool asRaw = manager.canHandleRawData() && CanWriteAsRawData<T>::value;
        serialization(manager, "asRaw", asRaw, false);

        if(asRaw) {
                        serializationRawData(manager, "raw", (size > 0) ? &attributeValue[0] : NULL, size * sizeof(T));
        } else {
            for(unsigned int i = 0; i < size; ++i) {
                T obj = attributeValue[i];
                serialization(manager, "Value", obj);
                attributeValue[i] = obj;
            }
        }

        VRS_SERIALIZATION_END_CLASS(manager, attributeName, attributeValue);
    }

    inline void serialization(
        SerializationManager& manager,
        const std::string& attributeName,
        std::vector<bool>& attributeValue
    ) {
        VRS_SERIALIZATION_START_CLASS(manager, attributeName, attributeValue);

        unsigned int size = static_cast<unsigned int>(attributeValue.size());
        serialization(manager, "Size", size);
        attributeValue.resize(size);

        bool asRaw = manager.canHandleRawData();
        serialization(manager, "asRaw", asRaw, false);

        if(asRaw) {
            std::vector<char> temp(attributeValue.size(), 0);
            if(manager.isWriting()) {
                for(size_t i = 0, iEnd = temp.size(); i < iEnd; ++i) {
                    if(attributeValue[i]) { temp[i] = 1; }
                }
            }
            serializationRawData(manager, "raw", &temp[0], size);
            if(manager.isReading()) {
                for(size_t i = 0, iEnd = temp.size(); i < iEnd; ++i) {
                    attributeValue[i] = (temp[i] == 1);
                }
            }
        } else {
            for(unsigned int i = 0; i < size; ++i) {
                bool obj = attributeValue[i];
                serialization(manager, "Value", obj);
                attributeValue[i] = obj;
            }
        }

        VRS_SERIALIZATION_END_CLASS(manager, attributeName, attributeValue);
    }

    template<typename T1, typename T2>
    void serialization(
        VRS::SerializationManager& manager,
        const std::string& attributeName,
        std::pair<T1, T2>& attributeValue
    ) {
        VRS_SERIALIZATION_START_CLASS(manager, attributeName, attributeValue);
        serialization(manager, "first",  attributeValue.first);
        serialization(manager, "second", attributeValue.second);
        VRS_SERIALIZATION_END_CLASS(manager, attributeName, attributeValue);
    }

    template<typename T>
    void serialization(
        VRS::SerializationManager& manager,
        const std::string& attributeName,
        std::list<T>& attributeValue
    ) {
        std::vector<T> vec(attributeValue.begin(), attributeValue.end());
        serialization(manager, attributeName, vec);
        if(manager.isReading()) {
            attributeValue.clear();
            attributeValue.insert(attributeValue.end(), vec.begin(), vec.end());
        }
    }

    template<typename T>
    void serialization(
        VRS::SerializationManager& manager,
        const std::string& attributeName,
        std::set<T>& attributeValue
    ) {
        std::vector<T> vec(attributeValue.begin(), attributeValue.end());
        serialization(manager, attributeName, vec);
        if(manager.isReading()) {
            attributeValue.clear();
            attributeValue.insert(vec.begin(), vec.end());
        }
    }

    template<typename T1, typename T2>
    void serialization(
        VRS::SerializationManager& manager,
        const std::string& attributeName,
        std::map<T1, T2>& attributeValue
    ) {
        std::vector<std::pair<T1, T2> > vec(attributeValue.begin(), attributeValue.end());
        serialization(manager, attributeName, vec);
        if(manager.isReading()) {
            attributeValue.clear();
            attributeValue.insert(vec.begin(), vec.end());
        }
    }

} // namespace VRS

#endif // VRS_CONTAINER_STLSERIALIZATION_H

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

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