Iterator.cpp

Go to the documentation of this file.

/** @file Iterator.cpp
* @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.
* =================================================================
*/

#ifndef DREAM_ITERATORCPP
#define DREAM_ITERATORCPP

#include "Iterator.h"

namespace DREAM
{

/////////////////////////////////////////////////////////////////////////////
//
// Iterator
//
/////////////////////////////////////////////////////////////////////////////

template <class item_type>
Iterator <item_type>::Iterator (item_type* node_ptr)
: node_ptr_ (node_ptr) 
{
};

template <class item_type>
Iterator <item_type>::Iterator (Iterator <item_type>& iter)
: node_ptr_ (*iter)
{
}

template <class item_type>
inline bool Iterator <item_type>::operator== (const item_type* node_ptr)
{
        return (node_ptr_ == node_ptr) ? true : false;
}

template <class item_type>
inline bool Iterator <item_type>::operator== (Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? true : false;
}

template <class item_type>
inline bool Iterator <item_type>::operator== (Const_Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? true : false;
}

template <class item_type>
inline bool Iterator <item_type>::operator!= (const item_type* node_ptr)
{
        return (node_ptr_ == node_ptr) ? false : true;
}

template <class item_type>
inline bool Iterator <item_type>::operator!= (Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? false : true;
}

template <class item_type>
inline bool Iterator <item_type>::operator!= (Const_Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? false : true;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator= (item_type* node_ptr)
{
        node_ptr_ = node_ptr;
        return *this;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator= (Iterator <item_type>& iter)
{
        node_ptr_ = *iter;
        return *this;
}

template <class item_type>
inline item_type* Iterator <item_type>::operator* ()
{
        return node_ptr_;
}

template <class item_type>
inline item_type* Iterator <item_type>::operator-> ()
{
        return node_ptr_;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator++ ()
{
        if (node_ptr_)
        {
                node_ptr_ = node_ptr_->iter_next ();
                return *this;
        }
        else
                return *this;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator-- ()
{
        if (node_ptr_)
        {
                node_ptr_ = node_ptr_->iter_previous ();
                return *this;
        }
        else
                return *this;
}

template <class item_type>
Iterator <item_type> Iterator <item_type>::operator++ (int)
{
        if (node_ptr_)
        {
                item_type* return_pointer = node_ptr_;
                node_ptr_ = node_ptr_->iter_next ();
                // Need to create a temporary Iterator because the g++ compiler cannot figure out that it needs to call the constructor when we return the pointer...
                Iterator <item_type> return_iterator (return_pointer);
                return return_iterator;
        }
        else
                return *this;
}

template <class item_type>
Iterator <item_type> Iterator <item_type>::operator-- (int)
{
        if (node_ptr_)
        {
                item_type* return_pointer = node_ptr_;
                node_ptr_ = node_ptr_->iter_previous ();
                // Need to create a temporary Iterator because the g++ compiler cannot figure out that it needs to call the constructor when we return the pointer...
                Iterator <item_type> return_iterator (return_pointer);
                return return_iterator;
        }
        else
                return *this;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator& ()
{
        return this;
}

template <class item_type>
inline Iterator <item_type>& Iterator <item_type>::operator& (int)
{
        return this;
}

/////////////////////////////////////////////////////////////////////////////
//
// Const_Iterator
//
/////////////////////////////////////////////////////////////////////////////

template <class item_type>
Const_Iterator <item_type>::Const_Iterator (const item_type* node_ptr)
: node_ptr_ (node_ptr) 
{
};

template <class item_type>
Const_Iterator <item_type>::Const_Iterator (Const_Iterator <item_type>& iter)
: node_ptr_ (*iter)
{
}

template <class item_type>
Const_Iterator <item_type>::Const_Iterator (Iterator <item_type>& iter)
: node_ptr_ (*iter)
{
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator== (const item_type* node_ptr)
{
        return (node_ptr_ == node_ptr) ? true : false;
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator== (Const_Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? true : false;
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator== (Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? true : false;
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator!= (const item_type* node_ptr)
{
        return (node_ptr_ == node_ptr) ? false : true;
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator!= (Const_Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? false : true;
}

template <class item_type>
inline bool Const_Iterator <item_type>::operator!= (Iterator <item_type>& iter)
{
        return (node_ptr_ == *iter) ? false : true;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator= (const item_type* node_ptr)
{
        node_ptr_ = node_ptr;
        return *this;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator= (Const_Iterator <item_type>& iter)
{
        node_ptr_ = *iter;
        return *this;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator= (Iterator <item_type>& iter)
{
        node_ptr_ = *iter;
        return *this;
}

template <class item_type>
inline const item_type* Const_Iterator <item_type>::operator* () const
{
        return node_ptr_;
}

template <class item_type>
inline const item_type* Const_Iterator <item_type>::operator-> () const
{
        return node_ptr_;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator++ ()
{
        if (node_ptr_)
        {
                node_ptr_ = node_ptr_->iter_next ();
                return *this;
        }
        else
                return *this;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator-- ()
{
        if (node_ptr_)
        {
                node_ptr_ = node_ptr_->iter_previous ();
                return *this;
        }
        else
                return *this;
}

template <class item_type>
Const_Iterator <item_type> Const_Iterator <item_type>::operator++ (int)
{
        if (node_ptr_)
        {
                const item_type* return_pointer = node_ptr_;
                node_ptr_ = node_ptr_->iter_next ();
                // Need to create a temporary Const_Iterator because the g++ compiler cannot figure out that it needs to call the constructor when we return the pointer...
                Const_Iterator <item_type> return_iterator (return_pointer);
                return return_iterator;
        }
        else
                return *this;
}

template <class item_type>
Const_Iterator <item_type> Const_Iterator <item_type>::operator-- (int)
{
        if (node_ptr_ == NULL)
        {
                const item_type* return_pointer = node_ptr_;
                node_ptr_ = node_ptr_->iter_previous ();
                // Need to create a temporary Const_Iterator because the g++ compiler cannot figure out that it needs to call the constructor when we return the pointer...
                Const_Iterator <item_type> return_iterator (return_pointer);
                return return_iterator;
        }
        else
                return *this;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator& ()
{
        return this;
}

template <class item_type>
inline Const_Iterator <item_type>& Const_Iterator <item_type>::operator& (int)
{
        return this;
}

};

#endif

---