VRS - The Virtual Rendering System

version 3.3

deque.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: deque.h 6014 2007-08-09 07:51:16Z Konstantin_Baumann $
// $Date: 2007-08-09 09:51:16 +0200 (Thu, 09 Aug 2007) $
// $Revision: 6014 $
// $State$
// $Author: Konstantin_Baumann $
//
// $Log$
// Revision 1.26  2004/03/12 16:28:39  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.25  2004/03/10 15:17:42  kirsch
// changes due to two-stage name lookup in non-dependent templates (gcc 3.4)
//
// Revision 1.24  2004/02/12 08:29:07  gerber
// added macro VRS_SERIALIZATION_PARENT_CLASS for parent serialization
//
// Revision 1.23  2004/02/10 10:50:50  wendland
// added VRS_SERIALIZATION_PARENT_CLASS
//
// Revision 1.22  2004/01/28 11:36:05  gerber
// adjusted method serialize to the new serializationmanager
//
// Revision 1.21  2004/01/19 11:43:57  baumann
// serialization mechanism improved
//
// Revision 1.20  2004/01/19 07:28:03  baumann
// serialization mechanism improved
//
// Revision 1.19  2004/01/15 14:21:45  baumann
// serialization mechanism improved
//
// Revision 1.18  2004/01/15 14:16:54  baumann
// serialization mechanism improved
//
// Revision 1.17  2003/11/07 14:19:24  kirsch
// removed leading underscore from include guards
//
// Revision 1.16  2003/02/27 13:25:15  kirsch
// removed unused parameter
//
// Revision 1.15  2002/11/06 08:16:05  baumann
// moved implementation of serialize operator from namespace std to namespace VRS
//
// Revision 1.14  2002/11/06 07:53:50  baumann
// cleanup of class registration for serialization
//
// Revision 1.13  2002/10/24 06:56:00  skirsch
// fixed some warnings by making casts explicit
//
// Revision 1.12  2002/08/06 16:24:01  baumann
// VRS_API removed for template classes
//
// Revision 1.11  2002/07/11 14:21:52  kersting
// added version for serialize method
//
// Revision 1.10  2002/07/03 15:52:50  baumann
// several changes for iterator code
// most iterators are now serializable again
//
// Revision 1.9  2002/07/03 07:45:32  kersting
// changed broken comment
//
// Revision 1.8  2002/07/02 15:23:48  baumann
// non-persistent containers now have the prefix NonPersistent, e.g. NonPersistentArray<T>
// persistent containers now have no prefix, e.g. Array<T>
//
// Revision 1.7  2002/07/02 06:12:34  baumann
// VRS::Iterator<T> completely rewritten
//
// Revision 1.6  2002/06/25 10:51:55  baumann
// added some method for supporting STL algorithms
// to Array<T>, List<T>, Deque<T> and StaticArray<T>:
//     beginSTL(), endSTL(), containerSTL()
//
// Revision 1.5  2002/05/09 12:36:37  kirsch
// added typename
//
// Revision 1.4  2002/04/02 08:33:06  baumann
// bug fix for serialization of iterators
//
// Revision 1.3  2002/04/02 08:13:43  baumann
// made iterator persistent
//
// Revision 1.2  2002/03/07 14:20:37  kosta
// VRS_API added for the iterator
//
// Revision 1.1  2002/03/04 12:03:54  kersting
// directory structure changes
//
// Revision 1.10  2002/03/03 21:44:24  kosta
// VRS_TYPEINFO-macro rewritten
//
// Revision 1.9  2002/03/03 16:37:59  kosta
// changed VRS-typeinfo to C++-typeid
//
// Revision 1.8  2002/02/25 09:56:08  kosta
// debug output improved
//
// Revision 1.7  2002/02/24 16:39:16  kosta
// VRS_CLASSNAME macros now consider namespace prefixes
//
// Revision 1.6  2002/02/19 10:34:07  kosta
// undone all changes since 2002-02-15
//
// Revision 1.3  2002/02/14 09:37:20  kosta
// automatic serialization registration for template classes implemented
//
// Revision 1.2  2002/02/13 16:28:11  kosta
// implementation of the serialize()-method moved outside the class declaration
//
// Revision 1.1  2002/02/12 15:04:34  kosta
// VRS container classes completely rewritten using STL
//

#ifndef VRS_CONTAINER_DEQUE_H
#define VRS_CONTAINER_DEQUE_H

#include <vrs/container/sequencecontainerstl.h>
#include <deque>

namespace VRS {

template<typename T> class DequeIterator;

template<typename T>
class NonPersistentDeque : public SequenceContainerSTL<T, std::deque<T> > {
public:
    NonPersistentDeque() : SequenceContainerSTL<T, std::deque<T> >() { }
    NonPersistentDeque(unsigned int size) : SequenceContainerSTL<T, std::deque<T> >(size) { }
    NonPersistentDeque(unsigned int size, const T& initValue) : SequenceContainerSTL<T, std::deque<T> >(size, initValue) { }
    NonPersistentDeque(const Iterator<T>* sourceItr) : SequenceContainerSTL<T, std::deque<T> >(sourceItr) { }

    virtual Iterator<T>* newIterator() const { return (this->iterator_ ? this->iterator_ : new DequeIterator<T>(this)); }

    void reserve(unsigned int value) { this->containerSTL().reserve(value); }
    
    VRS_TYPEINFO(NonPersistentDeque, VRS_TEMPLATE_ARGS_2(T, std::deque<T>, SequenceContainerSTL));
    VRS_SERIALIZABLE_ABSTRACT_CLASS(NonPersistentDeque);
};

template<typename T>
void NonPersistentDeque<T>::serialize(SerializationManager&) {
    VRS_NoImpl(NonPersistentDeque<T>::ClassNameVRS() << "::serialize() not supported: use "
               "Deque<T> for serialization instead!");
}

template<typename T>
class Deque : public NonPersistentDeque<T> {
public:
    Deque() : NonPersistentDeque<T>() { }
    Deque(unsigned int size) : NonPersistentDeque<T>(size) { }
    Deque(unsigned int size, const T& initValue) : NonPersistentDeque<T>(size, initValue) { }
    Deque(const Iterator<T>* sourceItr) : NonPersistentDeque<T>(sourceItr) { }

    VRS_TYPEINFO(Deque, NonPersistentDeque<T>);
    VRS_SERIALIZABLE(Deque);
};

template<typename T>
void Deque<T>::serialize(SerializationManager& doc) {
    VRS_SERIALIZATION_PARENT_CLASS(doc, SharedObj); // skip some super-classes!!!
    serialization(doc, "Container", this->containerSTL());
}

VRS_SERIALIZATION_REGISTRATION_TEMPLATE(Deque)

template<typename T>
class DequeIterator : public SequenceContainerIteratorSTL<T, std::deque<T> > {
public:
    DequeIterator(const NonPersistentDeque<T>* container)
        : SequenceContainerIteratorSTL<T, std::deque<T> >(container) { }

    VRS_TYPEINFO(DequeIterator, VRS_TEMPLATE_ARGS_2(T, std::deque<T>, SequenceContainerIteratorSTL));
    VRS_SERIALIZABLE(DequeIterator);

protected:
    DequeIterator() { } // only for serialization
};

template<typename T>
void DequeIterator<T>::serialize(SerializationManager& doc) {
        // typedef, because the serialization macro doesn't like templates with 2 template parameter
        typedef SequenceContainerIteratorSTL<T, std::deque<T> > Parent;
        VRS_SERIALIZATION_PARENT_CLASS(doc, Parent);
}

VRS_SERIALIZATION_REGISTRATION_TEMPLATE(DequeIterator);

template<typename T>
inline void
serialization(
    SerializationManager& manager,
    const std::string& attributeName,
    std::deque<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);
    for(typename std::deque<T>::iterator i = attributeValue.begin(), iEnd = attributeValue.end(); i != iEnd; ++i) {
        T obj = *i;
        serialization(manager, "Value", obj);
        *i = obj;
    }
    VRS_SERIALIZATION_END_CLASS(manager, attributeName, attributeValue);
}

} // namespace VRS

#endif // VRS_CONTAINER_DEQUE_H

---

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

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