VRS - The Virtual Rendering System

version 3.3

makeiterator.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: makeiterator.h 5213 2006-02-22 11:54:10Z baumann $
//
// $Log$
// Revision 1.9  2006/02/22 11:54:10  baumann
// changed to use VRS::FixedSizeIterator<T> instead of StaticArray<T>
//
// Revision 1.8  2005/09/26 11:22:40  baumann
// impl added for std::set<T> and std::list<T>
//
// Revision 1.7  2004/10/30 15:19:35  baumann
// bug fix: cannot return SO<Iterator<T> >; must return Iterator<T>* in order to not break existing code :-(
//
// Revision 1.6  2004/10/29 16:34:49  baumann
// - code cleanup
// - makeIterator() for std::vector<> added
//
// Revision 1.5  2004/03/12 16:28:39  baumann
// macros VRS_NAMESPACE_BEGIN/_END expanded and removed
//
// Revision 1.4  2003/11/07 14:19:24  kirsch
// removed leading underscore from include guards
//
// Revision 1.3  2002/09/26 09:11:42  baumann
// new functions makeNonPersistentIterator() added
//
// Revision 1.2  2002/03/07 16:17:59  kosta
// uses StaticArray<T> internally
//
// Revision 1.1  2002/03/04 12:03:54  kersting
// directory structure changes
//
// Revision 1.5  2002/02/19 10:34:09  kosta
// undone all changes since 2002-02-15
//
// Revision 1.2  2002/01/15 16:25:54  kosta
// macros rewritten for a better namespace support
//
// Revision 1.1  2001/11/26 14:32:15  kersting
// intitial version
//

#ifndef VRS_CONTAINER_MAKEITERATOR_H
#define VRS_CONTAINER_MAKEITERATOR_H

#include <vrs/container/fixedsizeiterator.h>

namespace VRS {

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(1);
    (*data)[0] = t0;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(2);
    (*data)[0] = t0;
    (*data)[1] = t1;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(3);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(4);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(5);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(6);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(7);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6,
    const T& t7
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(8);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    (*data)[7] = t7;
    return data;
}

template<class T>
inline Iterator<T>* makeIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6,
    const T& t7,
    const T& t8
) {
    FixedSizeIterator<T>* data = new FixedSizeIterator<T>(9);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    (*data)[7] = t7;
    (*data)[8] = t8;
    return data;
}



template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(1);
    (*data)[0] = t0;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(2);
    (*data)[0] = t0;
    (*data)[1] = t1;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(3);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(4);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(5);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(6);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(7);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6,
    const T& t7
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(8);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    (*data)[7] = t7;
    return data;
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const T& t0,
    const T& t1,
    const T& t2,
    const T& t3,
    const T& t4,
    const T& t5,
    const T& t6,
    const T& t7,
    const T& t8
) {
    NonPersistentFixedSizeIterator<T>* data = new NonPersistentFixedSizeIterator<T>(9);
    (*data)[0] = t0;
    (*data)[1] = t1;
    (*data)[2] = t2;
    (*data)[3] = t3;
    (*data)[4] = t4;
    (*data)[5] = t5;
    (*data)[6] = t6;
    (*data)[7] = t7;
    (*data)[8] = t8;
    return data;
}



template<class T>
inline Iterator<T>* makeIterator(
    const std::vector<T>& elements
) {
    return new FixedSizeIterator<T>(elements);
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const std::vector<T>& elements
) {
    return new NonPersistentFixedSizeIterator<T>(elements);
}


template<class T>
inline Iterator<T>* makeIterator(
    const std::list<T>& elements
) {
    return new FixedSizeIterator<T>(elements.begin(), elements.end());
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const std::list<T>& elements
) {
    return new NonPersistentFixedSizeIterator<T>(elements.begin(), elements.end());
}


template<class T>
inline Iterator<T>* makeIterator(
    const std::set<T>& elements
) {
    return new FixedSizeIterator<T>(elements.begin(), elements.end());
}

template<class T>
inline Iterator<T>* makeNonPersistentIterator(
    const std::set<T>& elements
) {
    return new NonPersistentFixedSizeIterator<T>(elements.begin(), elements.end());
}

} // namespace VRS

#endif // VRS_CONTAINER_MAKEITERATOR_H

---

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

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