VRS - The Virtual Rendering System

version 3.3

sequencecontainerstl.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2003 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: sequencecontainerstl.h 4455 2004-11-03 10:58:29Z saar $
// $Date: 2004-11-03 11:58:29 +0100 (Wed, 03 Nov 2004) $
// $Revision: 4455 $
// $State$
// $Author: saar $
//
// $Log$
// Revision 1.24  2004/11/03 10:58:28  saar
// Class comment changed (Doxygen style)
//
// Revision 1.23  2004/06/03 12:48:01  kirsch
// replaced vrs assertions with check args and internal error macros
//
// Revision 1.22  2004/03/12 16:28:39  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.21  2004/03/05 14:48:36  kirsch
// removed VC6 include workarround which appears to be unnecessary
//
// Revision 1.20  2004/01/19 17:07:21  baumann
// moved VRS::Document from vrs/ to vrs/io/
//
// Revision 1.19  2004/01/19 13:14:41  baumann
// #include <vrs/io/document.h> added or removed
//
// Revision 1.18  2004/01/19 11:43:57  baumann
// serialization mechanism improved
//
// Revision 1.17  2003/05/15 10:03:57  baumann
// - new class VertexData<DIM, T> added
// - class Color is now derived from VertexData<4, double>
// - renamed method Color::rep() to Color::pointer()
// - class Vector is now derived from VertexData<3, double>
// - renamed method Vector::rep() to Vector::pointer()
// - class VertexAttributeGL<DIM, T> removed
//
// Revision 1.16  2003/02/05 15:00:34  baumann
// "SharedObj* Iterator<T>::container() const" added
//
// Revision 1.15  2003/01/17 06:47:04  kirsch
// repeat typename in operator[]-declarations
//
// Revision 1.14  2003/01/08 20:48:42  baumann
// changes for iVRS
//
// Revision 1.13  2003/01/08 13:04:52  baumann
// changed reference types to STL_CONTAINER::reference types
//
// Revision 1.12  2002/11/06 07:53:50  baumann
// cleanup of class registration for serialization
//
// Revision 1.11  2002/10/22 10:25:40  skirsch
// fixed some warnings by making casts explicit
//
// Revision 1.10  2002/10/16 15:21:06  kersting
// added modied method
//
// Revision 1.9  2002/08/06 16:24:02  baumann
// VRS_API removed for template classes
//
// Revision 1.8  2002/08/06 10:32:38  baumann
// added explicit casts for double to float or int conversions
//
// Revision 1.7  2002/07/05 05:55:27  baumann
// changed return type of get()-method from "const T&" to "T"
//
// Revision 1.6  2002/07/03 15:52:50  baumann
// several changes for iterator code
// most iterators are now serializable again
//
// Revision 1.5  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.4  2002/07/02 10:12:58  kersting
// moved some parts to header
//
// Revision 1.3  2002/07/02 06:12:34  baumann
// VRS::Iterator<T> completely rewritten
//
// Revision 1.2  2002/06/30 20:27:05  baumann
// typedefs iterator and const_iterator for a better STL-support added
//
// Revision 1.1  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.3  2002/03/08 13:01:44  kosta
// performance bug fix for ListIterator
//
// Revision 1.2  2002/03/07 14:20:46  kosta
// VRS_API added for the iterator
//
// Revision 1.1  2002/03/04 12:03:54  kersting
// directory structure changes
//
// Revision 1.8  2002/03/03 21:44:25  kosta
// VRS_TYPEINFO-macro rewritten
//
// Revision 1.7  2002/02/26 09:17:18  kirsch
// gcc fix: added typename specifier for template parameter
//
// Revision 1.6  2002/02/19 10:34:11  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 11:55:19  kosta
// problems with Qt resolved
//
// Revision 1.1  2002/02/12 15:04:34  kosta
// VRS container classes completely rewritten using STL
//

#ifndef VRS_CONTAINER_SEQUENCECONTAINERSTL_H
#define VRS_CONTAINER_SEQUENCECONTAINERSTL_H

#include <vrs/container/iterator.h>

namespace VRS {

template<typename T, class STL_CONTAINER>
class SequenceContainerIteratorSTL;

template<typename T, class STL_CONTAINER>
class SequenceContainerSTL : public SharedObj {
protected:
    SequenceContainerSTL();
    SequenceContainerSTL(unsigned int size);
    SequenceContainerSTL(unsigned int size, const T& initValue);
    SequenceContainerSTL(const Iterator<T>* sourceItr);

public:
    typedef typename STL_CONTAINER::iterator        iterator;
    typedef typename STL_CONTAINER::const_iterator  const_iterator;
    typedef typename STL_CONTAINER::reference       reference;
    typedef typename STL_CONTAINER::const_reference const_reference;

    unsigned int size() const { return (unsigned int)container_.size(); }

    bool isEmpty() const { return container_.empty(); }

    void clear() { container_.clear(); }
        // Delete all elements of the container.

    void setElement(unsigned int index, const T& obj);
    T getElement(unsigned int index) const { return operator[](index); }
    
    void prepend(const T& obj);
    void prepend(const T& obj, unsigned int count);
    void prepend(const Iterator<T>* iter);
    void append(const T& obj);
    void append(const T& obj, unsigned int count);
    void append(const Iterator<T>* iter);
    void insert(unsigned int pos, const T& obj);
    void insert(unsigned int pos, const T& obj, unsigned int count);
    void insert(unsigned int pos, const Iterator<T>* iter);
    void removeFirst();
    void removeFirst(unsigned int count);
    void removeLast();
    void removeLast(unsigned int count);
    void remove(unsigned int pos);
    void remove(unsigned int pos, unsigned int count);
    int find(const T& obj) const;
    bool contains(const T& obj) const;
    bool erase(const T& obj, bool eraseAll = false);
    void resize(unsigned int newSize, const T& initValue = T());
    virtual Iterator<T>* newIterator() const;

    virtual void modified();

    VRS_TYPEINFO(SequenceContainerSTL, SharedObj);

public:
    // misc stuff for usage of the STL

    typename SequenceContainerSTL<T, STL_CONTAINER>::reference
        operator[](unsigned int index) { VRS_CheckArg(index < size(), "index out of range"); return *seek(index); }
    typename SequenceContainerSTL<T, STL_CONTAINER>::const_reference
        operator[](unsigned int index) const { VRS_CheckArg(index < size(), "index out of range"); return *seek(index); }

    iterator       beginSTL()       { return container_.begin(); }
    const_iterator beginSTL() const { return container_.begin(); }
    iterator       endSTL()         { return container_.end();   }
    const_iterator endSTL()   const { return container_.end();   }

    STL_CONTAINER&       containerSTL()       { return container_; }
    const STL_CONTAINER& containerSTL() const { return container_; }

protected:
    friend class SequenceContainerIteratorSTL<T, STL_CONTAINER>;
    mutable Iterator<T>* iterator_; // no SO-ptr!!!

private:
    iterator seek(unsigned int pos) const {
        // implemented here, since VC++ 6.0 does not like the definition outside of this class!!!
        VRS_CheckArg(pos <= size(), "pos out of range");

        SequenceContainerSTL* const nonconstThis = const_cast<SequenceContainerSTL*>(this);

        if(pos == 0) {
            return nonconstThis->beginSTL();
        } else if(pos == size()) {
            return nonconstThis->endSTL();
        } else if(pos < size() - pos) {
            // seek forward
            iterator iter = nonconstThis->beginSTL();
            std::advance(iter, pos);
            return iter;
        } else {
            // seek backward
            iterator iter = nonconstThis->endSTL();
            std::advance(iter, int(pos) - int(size()));
            return iter;
        }
    }

    STL_CONTAINER container_;
};


template<typename T, class STL_CONTAINER>
class SequenceContainerIteratorSTL : public Iterator<T> {
public:
    SequenceContainerIteratorSTL(const SequenceContainerSTL<T, STL_CONTAINER>* container)
        : container_(const_cast<SequenceContainerSTL<T, STL_CONTAINER>*>(container)) {
        VRS_CheckArg(container, "no container");
        container_->iterator_ = this;
    }
    virtual ~SequenceContainerIteratorSTL() {  container_->iterator_ = NULL; }

    virtual unsigned int size() const { return container_->size(); }
    virtual T get(unsigned int i) const { return (*container_)[i]; }
    
    virtual SharedObj* container() const { return container_; }
    
    VRS_TYPEINFO(SequenceContainerIteratorSTL, Iterator<T>);
    VRS_SERIALIZABLE_ABSTRACT_CLASS(SequenceContainerIteratorSTL);

protected:
    SequenceContainerIteratorSTL() { } // only for serialization

private:
    SO<SequenceContainerSTL<T, STL_CONTAINER> > container_;
};

} // namespace VRS

#include <vrs/container/sequencecontainerstl.tli>

#endif // VRS_CONTAINER_SEQUENCECONTAINERSTL_H

---

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

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