Iterator.h

Go to the documentation of this file.

/** @file Iterator.h
* @author Gabor Madl
* @date Created 10/2006
* @brief Iterator template class.
*
*
* =================================================================
* DREAM License v2.0
* 
* DREAM - Distributed Real-time Embedded Analysis Method
* http://dre.sourceforge.net.
* Copyright (c) 2005-2007 Gabor Madl, All Rights Reserved.
* 
* This file is part of DREAM.
* 
* DREAM is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation. No future versions of
* the GPL license may be automatically applied to DREAM. It is in
* the sole discretion of the copyright holder to determine whether
* DREAM may be released under a different license or terms. There
* are no restrictions on the use of DREAM for any purpose.
* 
* DREAM 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 General Public License for more details.
* 
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
* 
* By submitting comments, suggestions, code, code snippets,
* techniques (including that of usage), and algorithms, submitters
* acknowledge that they have the right to do so, that any such
* submissions are given freely and unreservedly, and that they
* waive any claims to copyright or ownership. In addition,
* submitters acknowledge that any such submission might become
* part of the copyright maintained on the overall body of code,
* which comprises DREAM. By making a submission, submitter agrees
* to these terms. Furthermore, submitters acknowledge that the
* incorporation or modification of such submissions is entirely
* at the discretion of the moderators of the DREAM project.
* 
* DREAM links to the Libxml2 third party library. Please see 
* COPYING-libxml for the copyright information of Libxml2.
* =================================================================
*/

#if (_MSC_VER >= 1400)                          // VC8+
#pragma warning (disable:4996)          // Disable all deprecation warnings
#endif 

#ifndef DREAM_ITERATOR
#define DREAM_ITERATOR

#include<iostream>

namespace DREAM
{

template <class item_type>
class Const_Iterator;

/** Iterator class for DREAM::AVLTree. */
template <class item_type>
class Iterator
{
public:
        /** Constructor. */
        Iterator () {};

        /** Constructor. */
        Iterator (item_type* node_ptr);

        /** Constructor. */
        Iterator (Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator== (const item_type* node_ptr);

        /** Equivalence operator. */
        bool operator== (Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator== (Const_Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator!= (const item_type* node_ptr);

        /** Equivalence operator. */
        bool operator!= (Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator!= (Const_Iterator <item_type>& iter);

        /** Assignment operator. */
        Iterator <item_type>& operator= (item_type* node_ptr);

        /** Assignment operator. */
        Iterator <item_type>& operator= (Iterator <item_type>& iter);

        /** * operator. */
        item_type* operator* ();

        /**->operator. */
        item_type* operator-> ();

        /** prefix ++ operator. */
        Iterator <item_type>& operator++ ();

        /** prefix -- operator. */
        Iterator <item_type>& operator-- ();

        /** postfix ++ operator. */
        Iterator <item_type> operator++ (int);

        /** postfix -- operator. */
        Iterator <item_type> operator-- (int);

        /** & operator. */
        Iterator <item_type>& operator& ();

        /** & operator. */
        Iterator <item_type>& operator& (int);

protected:

        /** Pointer to the current node in the AVLTree. */
        item_type* node_ptr_;
};



/** Iterator class for DREAM::AVLTree. */
template <class item_type>
class Const_Iterator
{
public:
        /** Constructor. */
        Const_Iterator () {};

        /** Constructor. */
        Const_Iterator (const item_type* node_ptr);

        /** Constructor. */
        Const_Iterator (Const_Iterator <item_type>& iter);

        /** Constructor. */
        Const_Iterator (Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator== (const item_type* node_ptr);

        /** Equivalence operator. */
        bool operator== (Const_Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator== (Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator!= (const item_type* node_ptr);

        /** Equivalence operator. */
        bool operator!= (Const_Iterator <item_type>& iter);

        /** Equivalence operator. */
        bool operator!= (Iterator <item_type>& iter);

        /** Assignment operator. */
        Const_Iterator <item_type>& operator= (const item_type* node_ptr);

        /** Assignment operator. */
        Const_Iterator <item_type>& operator= (Const_Iterator <item_type>& iter);

        /** Assignment operator. */
        Const_Iterator <item_type>& operator= (Iterator <item_type>& iter);

        /** * operator. */
        const item_type* operator* () const;

        /**->operator. */
        const item_type* operator-> () const;

        /** ++ operator. */
        Const_Iterator <item_type>& operator++ ();

        /** -- operator. */
        Const_Iterator <item_type>& operator-- ();

        /** postfix ++ operator. */
        Const_Iterator <item_type> operator++ (int);

        /** postfix -- operator. */
        Const_Iterator <item_type> operator-- (int);

        /** & operator. */
        Const_Iterator <item_type>& operator& ();

        /** & operator. */
        Const_Iterator <item_type>& operator& (int);

protected:

        /** Pointer to the current node in the AVLTree. */
        const item_type* node_ptr_;
};

template <class item_type, class operation>
void for_each (item_type begin_iter, item_type end_iter, operation op)
{
        item_type iter;
        for (iter = begin_iter; iter != end_iter; iter++)
        {
                op (**iter);
        }
}

};

#endif

---