VRS - The Virtual Rendering System

version 3.3

indexediterator.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: $

#ifndef VRS_CONTAINER_INDEXEDITERATOR_H
#define VRS_CONTAINER_INDEXEDITERATOR_H

#include <vrs/container/iterator.h>

namespace VRS {

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

    public:
        IndexedIterator(
            const SO<Iterator<T> >& sourceIter,
            const SO<Iterator<INDEX> >& indexIter
        ) :
            Iterator<T>(),
            m_sourceIter(sourceIter),
            m_indexIter(indexIter)
        {
            VRS_CheckArg(sourceIter, "no source iterator");
            VRS_CheckArg(indexIter, "no index iterator");
        }

        virtual unsigned int size() const { return m_indexIter->size(); }
        virtual T get(unsigned int index) const { return m_sourceIter->get(m_indexIter->get(index)); }

        virtual const TransactionNo& lastTransactionNo() const {
            return std::max(m_sourceIter->lastTransactionNo(), m_indexIter->lastTransactionNo());
        }

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

    private:
        SO<Iterator<T> > m_sourceIter;
        SO<Iterator<INDEX> > m_indexIter;
    }; // class IndexedIterator<T, INDEX>

    template<typename T, typename INDEX>
    void IndexedIterator<T, INDEX>::serialize(
        SerializationManager& doc
    ) {
        UINT8 version = 0;
            doc.classVersion(version);

            VRS_SERIALIZATION_PARENT_CLASS(doc, Iterator<T>);
        serialization(doc, "sourceIterator", m_sourceIter);
        serialization(doc, "indexIterator", m_indexIter);
    }

    VRS_SERIALIZATION_REGISTRATION_TEMPLATE_2(IndexedIterator);

} // namespace VRS

#endif // VRS_CONTAINER_INDEXEDITERATOR_H

---

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

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