eC_TList_Iterators.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#if !defined(ECTLISTITERATORS_H)
#define ECTLISTITERATORS_H
 
#include "eC_Types.h"
#include <cassert>
 
template <class T> class eC_TListDoubleLinked;
template <class T> class ListNode;
template <class T> class eC_TSafeIterator;
 
 
 
template <class T>
 
class eC_TIterator
{
    friend class eC_TListDoubleLinked<T>; 
    friend class eC_TSafeIterator<T>; 
 
protected:
    typedef ListNode<T> Node; 
 
    Node* m_pNode; 
 
public:
 
    //-------------------------------------
    eC_TIterator() : m_pNode(NULL) {}
 
    eC_TIterator(Node* pNode) : m_pNode(pNode) {}
 
    virtual ~eC_TIterator() {}
 
    eC_TIterator(const eC_TIterator<T>& x) : m_pNode(x.m_pNode) {}
 
    //-------------------------------------
    eC_TIterator& operator=(const eC_TIterator& kIter)
    {
        m_pNode = kIter.m_pNode;
        return *this;
    }
 
    //-------------------------------------
    eC_Bool operator==(const eC_TIterator& kIter) const
    {
        return m_pNode == kIter.m_pNode;
    }
 
    eC_Bool operator==(const Node* const ptrNode) const
    {
        return m_pNode == ptrNode;
    }
 
    //-------------------------------------
    eC_Bool operator!=(const eC_TIterator& kIter) const
    {
        return m_pNode != kIter.m_pNode;
    }
 
    //------------------------------
    eC_Bool IsValid() const
    {
        return m_pNode != NULL;
    }
 
    //-------------------------------------
    virtual eC_Bool IsInsideList() const
    {
        return m_pNode != NULL;
    }
 
    //-------------------------------------
    eC_TIterator operator++(int)
    {
        eC_TIterator tmpIter = *this; // save old iterator
        if (m_pNode)
        {
            m_pNode = m_pNode->m_pkNext; // next may be NULL if at end
        }
        return tmpIter; // return old iterator
    }
 
    //-------------------------------------
    eC_TIterator& operator++()
    {
        if (m_pNode != NULL)
        {
            m_pNode = m_pNode->m_pkNext; // next may be NULL if at end
        }
 
        return *this; // return new iterator (uses copy contructor)
    }
 
    //-------------------------------------
    eC_TIterator operator--(int)
    {
        eC_TIterator tmpIter = *this;
        if (m_pNode)
        {
            m_pNode = m_pNode->m_pkPrevious;
        }
        return tmpIter;
    }
 
    //-------------------------------------
    eC_TIterator& operator--()
    {
        if (m_pNode)
        {
            m_pNode = m_pNode->m_pkPrevious;
        }
 
        return *this;
    }
 
    //-------------------------------------
    T & operator*()
    {
        if (m_pNode)
        {
            return m_pNode->m_tValue;
        }
 
#ifdef GUILIANI_USE_EXCEPTIONS
        throw 0; // referencing deleted node
#endif
    }
 
protected:
    Node* GetNode() const
    {
        return m_pNode;
    }
};
 
//----------------------------------------------------------------------------
//----------------------safe Iterators----------------------------------------
//----------------------------------------------------------------------------
enum Update_t {REMOVED, ADDED, KILL, REVERSE_ORDER};
 
 
template <class T>
 
class eC_TSafeIterator : public eC_TIterator<T>
{
    friend class eC_TListDoubleLinked<T>;
    eC_TListDoubleLinked<T>* m_pList;    
    typename eC_TIterator<T>::Node* m_pSaveNextNode; 
    typename eC_TIterator<T>::Node* m_pSavePrevNode; 
 
    //------------------------------
 
    //this function updates a safe iterator, if list was modified.
    //function is called by list, if iterator has been registered (e.g. while initialized).
    void Validate(typename eC_TIterator<T>::Node* pkUpdateNode, Update_t eUpdate)
    {
        typename eC_TIterator<T>::Node * pkTempNode;
 
        switch (eUpdate)
        {
        case REMOVED :
            if (eC_TIterator<T>::m_pNode == pkUpdateNode)     //current element was removed
            {
                eC_TIterator<T>::m_pNode = NULL; //invalidate iterator until next iteration
            }
 
            else if (m_pSaveNextNode == pkUpdateNode)     //next element was removed
            {
                assert(m_pSaveNextNode != NULL);
                m_pSaveNextNode = m_pSaveNextNode->m_pkNext;
            }
 
            else if (m_pSavePrevNode == pkUpdateNode)     //previous element was removed
            {
                assert(m_pSavePrevNode != NULL);
                m_pSavePrevNode = m_pSavePrevNode->m_pkPrevious;
            }
            break;
 
        case KILL :      // iterator is invalid (after sorting and RemoveAll in list)
            eC_TIterator<T>::m_pNode = NULL;
            m_pSavePrevNode = NULL;
            m_pSaveNextNode = NULL;
            break;
 
        case REVERSE_ORDER :
            pkTempNode = m_pSaveNextNode;
            m_pSaveNextNode = m_pSavePrevNode;
            m_pSavePrevNode = pkTempNode;
            break;
 
        case ADDED :
            // The node "pkUpdateNode" was added:
            // if new element is added before current element that is associated with this iterator
 
            if (eC_TIterator<T>::m_pNode == pkUpdateNode->m_pkNext  // current element is next element of updated node
                    && eC_TIterator<T>::m_pNode != NULL)                   // current element is not invalid
            {
                m_pSavePrevNode = pkUpdateNode;   // previous node is the new node
            }
 
            // if new element is added after current element that is associated with this iterator
            else if (eC_TIterator<T>::m_pNode == pkUpdateNode->m_pkPrevious
                        && eC_TIterator<T>::m_pNode != NULL)
            {
                m_pSaveNextNode = pkUpdateNode;
            }
 
            // if formerly current node was deleted before and other element was added at this position
            else if (eC_TIterator<T>::m_pNode == NULL)
            {
                if (m_pSavePrevNode == pkUpdateNode->m_pkPrevious
                        && m_pSaveNextNode == pkUpdateNode->m_pkNext)
                {
                    eC_TIterator<T>::m_pNode = pkUpdateNode;
                }
            }
            break;
        }
    }
 
    void SetList(eC_TListDoubleLinked<T>* pList)
    {
        if (m_pList != pList)
        {
            eC_TListDoubleLinked<T>* pTempList = m_pList;
            m_pList = pList;
            if (pTempList)
                pTempList->UnregisterIterator(this);
            if (pList)
                pList->RegisterIterator(this);
        }
    }
 
public:
    eC_TSafeIterator() 
        : m_pList(NULL),
        m_pSaveNextNode(NULL),
        m_pSavePrevNode(NULL)
    {}
 
    eC_TSafeIterator(const eC_TSafeIterator<T>& kIter)
        : eC_TIterator<T>(kIter),
          m_pList(NULL)
    {
        SetList(kIter.m_pList);
        m_pSaveNextNode = kIter.m_pSaveNextNode;
        m_pSavePrevNode = kIter.m_pSavePrevNode;
    }
 
    //------------------------------
    virtual ~eC_TSafeIterator()
    {
        SetList(NULL);
    }
 
    eC_TSafeIterator& operator=(const eC_TSafeIterator& kIter)
    {
        eC_TIterator<T>::m_pNode = kIter.m_pNode;
        SetList(kIter.m_pList);
        m_pSaveNextNode = kIter.m_pSaveNextNode;
        m_pSavePrevNode = kIter.m_pSavePrevNode;
 
        return *this;
    }
 
    //-------------------------------------
    eC_Bool operator==(const eC_TSafeIterator &kIter) const
    {
        return (eC_TIterator<T>::m_pNode == kIter.eC_TIterator<T>::m_pNode
                    && (m_pSavePrevNode == kIter.m_pSavePrevNode)
                    && (m_pSaveNextNode == kIter.m_pSaveNextNode));
    }
 
    //-------------------------------------
    eC_Bool operator!=(const eC_TSafeIterator &kIter)
    {
        return (eC_TIterator<T>::m_pNode != kIter.eC_TIterator<T>::m_pNode
                    || (m_pSavePrevNode != kIter.m_pSavePrevNode)
                    || (m_pSaveNextNode != kIter.m_pSaveNextNode));
    }
 
    //-------------------------------------
    eC_TSafeIterator& operator++()
    {
        typename eC_TIterator<T>::Node * pOldNode = eC_TIterator<T>::m_pNode;
        eC_TIterator<T>::m_pNode = m_pSaveNextNode;
 
        if (pOldNode)
            m_pSavePrevNode = pOldNode;
 
        if (m_pSaveNextNode != NULL)
        {
            m_pSaveNextNode = m_pSaveNextNode->m_pkNext;
        }
 
        return *this;
    }
 
    //-------------------------------------
    eC_TSafeIterator& operator--()
    {
        typename eC_TIterator<T>::Node * pOldNode = eC_TIterator<T>::m_pNode;
        eC_TIterator<T>::m_pNode = m_pSavePrevNode;
 
        if (pOldNode)
            m_pSaveNextNode = pOldNode;
 
        if (m_pSavePrevNode != NULL)
        {
            m_pSavePrevNode = m_pSavePrevNode->m_pkPrevious;
        }
 
        return *this;
    }
 
    //-------------------------------------
    virtual eC_Bool IsInsideList() const
    {
        // Note, we may also be inside of list when current element is invalid
        return !((eC_TIterator<T>::m_pNode == NULL && m_pSaveNextNode == NULL)
               || (eC_TIterator<T>::m_pNode == NULL && m_pSavePrevNode != NULL));
    }
 
 
    eC_Bool IsPreviousValid() const { return m_pSavePrevNode != NULL;}
 
    eC_Bool IsNextValid() const{ return m_pSaveNextNode != NULL;}
};
 
#endif // ECTLISTITERATORS_H