VRS - The Virtual Rendering System

version 3.3

fixedsizeiterator.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2006 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: fixedsizeiterator.h 6580 2008-12-17 14:06:53Z Konstantin_Baumann $
//
// $Log$
// Revision 1.3  2006/05/02 06:58:11  baumann
// fixed impl of CanWriteAsRawData()
//
// Revision 1.2  2006/03/01 16:15:45  baumann
// added methods pointer() for direct access
//
// Revision 1.1  2006/02/22 11:53:15  baumann
// initial checkin
//
// Revision 1.2  2006/02/22 08:27:22  baumann
// added operator[]
//
// Revision 1.1  2006/02/22 08:22:49  baumann
// initial version
//

#ifndef VRS_CONTAINER_FIXEDSIZEITERATOR_H
#define VRS_CONTAINER_FIXEDSIZEITERATOR_H

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

namespace VRS {

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

    public:
        FixedSizeIterator(unsigned int size) :
            m_size(size),
            m_data((size > 0) ? new T[size] : NULL)
        { }

        FixedSizeIterator(unsigned int size, const T& init) :
            m_size(size),
            m_data((size > 0) ? new T[size] : NULL)
        {
            if(size > 0) { std::fill(m_data, m_data + size, init); }
        }

        FixedSizeIterator(SO<Iterator<T> > iter) :
            m_size(0),
            m_data(NULL)
        {
            if(iter) {
                m_size = iter->size();
                m_data = new T[m_size];
                std::copy(iter->beginSTL(), iter->endSTL(), m_data);
            }
        }

        template<typename S>
        FixedSizeIterator(const std::vector<S>& other) :
            m_size(static_cast<unsigned int>(other.size())),
            m_data((m_size > 0) ? new T[other.size()] : NULL)
        {
            std::copy(other.begin(), other.end(), m_data);
        }

        template<class FORWARD_ITERATOR>
        FixedSizeIterator(FORWARD_ITERATOR begin, FORWARD_ITERATOR end) :
            m_size(static_cast<unsigned int>(std::distance(begin, end))),
            m_data((m_size > 0) ? new T[m_size] : NULL)
        {
            std::copy(begin, end, m_data);
        }

        virtual ~FixedSizeIterator() {
            delete [] m_data;
        }

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

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

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

    public: // added indexed access methods
        const T& operator[](unsigned int index) const {
            VRS_CheckArg(index < m_size, "index out of range");
            return m_data[index];
        }

        T& operator[](unsigned int index) {
            VRS_CheckArg(index < m_size, "index out of range");
            return m_data[index];
        }

    public: // added access via C pointer
        const T* pointer() const { return m_data; }
        T* pointer() { return m_data; }

    protected:
        FixedSizeIterator() : m_size(0), m_data(NULL) { } // for serialization only

    private:
        unsigned int m_size;
        T* m_data;
    }; // FixedSizeIterator<T>

    template<typename T>
    inline void FixedSizeIterator<T>::serialize(
        SerializationManager& manager
    ) {
        VRS_SERIALIZATION_PARENT_CLASS(manager, Iterator<T>);

        serialization(manager, "size", m_size, 0u);

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

        if(manager.isReading()) {
            delete [] m_data;
            m_data = (m_size > 0) ? new T[m_size] : NULL;
        }

        if(asRaw) {
            serializationRawData(manager, "raw", m_data, m_size * sizeof(T));
        } else {
            for(unsigned int i = 0; i < m_size; ++i) {
                serialization(manager, "value", m_data[i]);
            }
        }
    }

    VRS_SERIALIZATION_REGISTRATION_TEMPLATE(FixedSizeIterator);



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

    public:
        NonPersistentFixedSizeIterator(unsigned int size) :
            m_size(size),
            m_data((size > 0) ? new T[size] : NULL)
        { }

        NonPersistentFixedSizeIterator(unsigned int size, const T& init) :
            m_size(size),
            m_data((size > 0) ? new T[size] : NULL)
        {
            if(size > 0) { std::fill(m_data, m_data + size, init); }
        }

        template<typename S>
        NonPersistentFixedSizeIterator(const std::vector<S>& other) :
            m_size(other.size()),
            m_data((m_size > 0) ? new T[other.size()] : NULL)
        {
            std::copy(other.begin(), other.end(), m_data);
        }

        template<class FORWARD_ITERATOR>
        NonPersistentFixedSizeIterator(FORWARD_ITERATOR begin, FORWARD_ITERATOR end) :
            m_size(std::distance(begin, end)),
            m_data((m_size > 0) ? new T[m_size] : NULL)
        {
            std::copy(begin, end, m_data);
        }

        NonPersistentFixedSizeIterator(SO<Iterator<T> > iter) :
            m_size(0),
            m_data(NULL)
        {
            if(iter) {
                m_size = iter->size();
                m_data = new T[m_size];
                std::copy(iter->begin(), iter->end(), m_data);
            }
        }

        virtual ~NonPersistentFixedSizeIterator() {
            delete [] m_data;
        }

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

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

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

    public: // added indexed access methods
        const T& operator[](unsigned int index) const {
            VRS_CheckArg(index < m_size, "index out of range");
            return m_data[index];
        }

        T& operator[](unsigned int index) {
            VRS_CheckArg(index < m_size, "index out of range");
            return m_data[index];
        }

    private:
        unsigned int m_size;
        T* m_data;
    }; // NonPersistentFixedSizeIterator<T>

} // namespace VRS

#endif // VRS_CONTAINER_FIXEDSIZEITERATOR_H

---

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

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