VRS - The Virtual Rendering System

version 3.3

dataiterator.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.
 ******************************************************************************/

// $Id: dataiterator.h 6580 2008-12-17 14:06:53Z Konstantin_Baumann $

#ifndef VRS_CONTAINER_DATAITERATOR_H
#define VRS_CONTAINER_DATAITERATOR_H

#include <vrs/container/iterator.h>
#include <vrs/container/stl_serialization.h>

namespace VRS {

    template<typename T>
    inline const T* DataIterator_pointer_impl(
        const std::vector<T>& data
    ) {
        return (data.empty() ? NULL : &data[0]);
    }

    // specialization for std::vector<bool>
    inline const bool* DataIterator_pointer_impl(
        const std::vector<bool>& data
    ) {
        return NULL;
    }

    template<typename T>
    class DataIterator :
        public Iterator<T>
    {
    public:
        VRS_TYPEINFO(DataIterator, Iterator<T>);
        VRS_SERIALIZABLE(DataIterator);

    public:
        DataIterator() :
            data()
        { }

        DataIterator(unsigned int size) :
            data(size)
        { }

        DataIterator(unsigned int size, const T& init) :
            data(size, init)
        { }

        DataIterator(SO<Iterator<T> > iter) :
            data()
        {
            if(iter) { data.assign(iter->beginSTL(), iter->endSTL()); }
        }

        template<typename S>
        DataIterator(const std::vector<S>& other) :
            data(other)
        { }

        template<class FORWARD_ITERATOR>
        DataIterator(FORWARD_ITERATOR begin, FORWARD_ITERATOR end) :
            data(begin, end)
        { }

    public: // implement the VRS::Iterator<T> interface
        virtual unsigned int size() const { return static_cast<unsigned int>(data.size()); }

        virtual T get(unsigned int index) const {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

        virtual const T* pointer() const {
            return DataIterator_pointer_impl(data);
        }

    public: // add some additional access methods
        void set(unsigned int index, const T& obj) {
            VRS_CheckArg(index < size(), "index out of range");
            data[index] = obj;
        }

        void append(const T& obj) {
            data.push_back(obj);
        }

        void append(SO<Iterator<T> > iter) {
            if (iter) {
                data.insert(data.end(), iter->beginSTL(), iter->endSTL());
            }
        }

        void clear() {
            data.clear();
        }

    public: // added indexed access methods
        typename std::vector<T>::const_reference operator[](unsigned int index) const {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

        typename std::vector<T>::reference operator[](unsigned int index) {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

    public: // provide direct access to the underlying std::vector
        std::vector<T> data;
    }; // DataIterator<T>

    template<typename T>
    inline void DataIterator<T>::serialize(
        SerializationManager& manager
    ) {
        VRS_SERIALIZATION_PARENT_CLASS(manager, Iterator<T>);
        serialization(manager, "data", data);
    }

    VRS_SERIALIZATION_REGISTRATION_TEMPLATE(DataIterator);



    template<typename T>
    class NonPersistentDataIterator :
        public Iterator<T>
    {
    public:
        VRS_TYPEINFO(NonPersistentDataIterator, Iterator<T>);

    public:
        NonPersistentDataIterator() :
            data()
        { }

        NonPersistentDataIterator(unsigned int size) :
            data(size)
        { }

        NonPersistentDataIterator(unsigned int size, const T& init) :
            data(size, init)
        { }

        NonPersistentDataIterator(SO<Iterator<T> > iter) :
            data()
        {
            if(iter) { data.assign(iter->begin(), iter->end()); }
        }

        template<typename S>
        NonPersistentDataIterator(const std::vector<S>& other) :
            data(other)
        { }

        template<class FORWARD_ITERATOR>
        NonPersistentDataIterator(FORWARD_ITERATOR begin, FORWARD_ITERATOR end) :
            data(begin, end)
        { }

    public: // implement the VRS::Iterator<T> interface
        virtual unsigned int size() const { return static_cast<unsigned int>(data.size()); }

        virtual T get(unsigned int index) const {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

    public: // add some additional access methods
        void set(unsigned int index, const T& obj) {
            VRS_CheckArg(index < size(), "index out of range");
            data[index] = obj;
        }

        void append(const T& obj) {
            data.push_back(obj);
        }

        void append(SO<Iterator<T> > iter) {
            if (iter) {
                data.insert(data.end(), iter->beginSTL(), iter->endSTL());
            }
        }

        void clear() {
            data.clear();
        }

    public: // added indexed access methods
        typename std::vector<T>::const_reference operator[](unsigned int index) const {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

        typename std::vector<T>::reference operator[](unsigned int index) {
            VRS_CheckArg(index < size(), "index out of range");
            return data[index];
        }

    public: // provide direct access to the underlying std::vector
        std::vector<T> data;
    }; // NonPersistentDataIterator<T>

} // namespace VRS

#endif // VRS_CONTAINER_DATAITERATOR_H

---

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

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