---

CTBmapIterator.hxx

Go to the documentation of this file.

#ifndef _CTBmapIterator_HXX
#define _CTBmapIterator_HXX 1

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

template <class K, class V, class C>
class CTBmapBrowser {
  public:

    typedef CTBmap<K,V,C>          Map;
    typedef CTBmapNode<K,V,C>      Node;
    typedef CTBmapBrowser<K,V,C>   Browser;

                    CTBmapBrowser();
                    CTBmapBrowser(const CTBmap<K,V,C>* p_map,
                                  const CTBmapNode<K,V,C>* p_node);

    bool            Next();
    bool            Prev();

    bool            Valid() const;
    bool            IsFirst() const;
    bool            IsLast() const;
    CTBint          Rank() const;

    bool            Equal(const CTBmapBrowser<K,V,C>& rhs) const;

    const CTBpair<const K,V>* Current() const;

    const K&        Key() const;
    const V&        Value() const;

    CTBmapBrowser<K,V,C>& operator++();
    CTBmapBrowser<K,V,C>  operator++(int);

    CTBmapBrowser<K,V,C>& operator--();
    CTBmapBrowser<K,V,C>  operator--(int);

    const CTBpair<const K,V>& operator[](CTBint i_offset);

    const CTBpair<const K,V>* operator->();
    const CTBpair<const K,V>& operator*();

    CTBmapBrowser<K,V,C>& operator+=(CTBint i_offset);
    CTBmapBrowser<K,V,C>& operator-=(CTBint i_offset);

                    operator const CTBpair<const K,V>*() const;
                    operator bool() const;

                    operator const CTBmapNode<K,V,C>*() const;

  protected:

    Map*            mp_map;                 
    Node*           mp_node;                
};

template <class K, class V, class C>
CTBmapBrowser<K,V,C> operator+(const CTBmapBrowser<K,V,C>& lhs,
                               CTBint i_offset);
template <class K, class V, class C>
CTBmapBrowser<K,V,C> operator-(const CTBmapBrowser<K,V,C>& lhs,
                               CTBint i_offset);

template <class K, class V, class C>
CTBint operator-(const CTBmapBrowser<K,V,C>& lhs,
                 const CTBmapBrowser<K,V,C>& rhs);

template <class K, class V, class C>
bool operator==(const CTBmapBrowser<K,V,C>& lhs,
                const CTBmapBrowser<K,V,C>& rhs);

template <class K, class V, class C>
ostream& operator<<(ostream& os, const CTBmapBrowser<K,V,C>& obj);

//##############################################################################

template <class K, class V, class C>
class CTBmapIterator : public CTBmapBrowser<K,V,C> {
  public:

    typedef CTBmapIterator<K,V,C>  Iterator;

                    CTBmapIterator();
                    CTBmapIterator(CTBmap<K,V,C>* p_map,
                                   CTBmapNode<K,V,C>* p_node);

    CTBpair<const K,V>* Current() const;

    V&              Value() const;

    CTBmapIterator<K,V,C>& operator++();
    CTBmapIterator<K,V,C>  operator++(int);

    CTBmapIterator<K,V,C>& operator--();
    CTBmapIterator<K,V,C>  operator--(int);
  
    CTBpair<const K,V>& operator[](CTBint i_offset);

    CTBpair<const K,V>* operator->();
    CTBpair<const K,V>& operator*();

    CTBmapIterator<K,V,C>& operator+=(CTBint i_offset);
    CTBmapIterator<K,V,C>& operator-=(CTBint i_offset);

                    operator CTBpair<const K,V>*() const;
                    operator bool() const;

                    operator CTBmapNode<K,V,C>*() const;
};

template <class K, class V, class C>
CTBmapIterator<K,V,C> operator+(const CTBmapIterator<K,V,C>& lhs,
                                CTBint i_offset);
template <class K, class V, class C>
CTBmapIterator<K,V,C> operator-(const CTBmapIterator<K,V,C>& lhs,
                                CTBint i_offset);

// Notes:
//  1. CTBmapIterator and CTBmapBrowser implement the read/write and read-only
//     interface and have thus many almost identical methods.
//      ==> do all changes in these two classes in a consistent fashion !!!
//
//  2. It is necessary to have a bool conversion on Iterator. Otherwise
//     egcs complains about ambiguities between the pointer conversions and
//     the base class bool conversion. 
//
// the implementation is fully inlined and always included here
//
#include "CTBmapIterator.icc"

#endif

---