StiCompositeLeafIterator.h

//StiCompositeLeafIterator.h
//M.L. Miller (Yale Software)
//07/01

#ifndef StiCompositeLeafIterator_HH
#define StiCompositeLeafIterator_HH

#include <vector>
using std::vector;

#include "StiCompositeTreeNode.h"
#include "StlUtilities.h"

template <class T>
class StiCompositeLeafIterator
{
public:
    typedef StiCompositeTreeNode<T> tnode_t;
    
    typedef vector<tnode_t*> tnode_vec;

    StiCompositeLeafIterator(tnode_t* node);

    virtual ~StiCompositeLeafIterator();
    
    void reset();
    void unset(){;}
    
    tnode_t* operator*() const;
    
    void operator++();
    
    bool operator!=(const typename tnode_vec::const_iterator& rhs) {
          return (mcurrentleaf != rhs);
    }

    unsigned int getLeafCount() const;
    
public:
    //Safe forward Access to leaves

    typename tnode_vec::iterator begin() { return mleaves.begin();}

    
    typename tnode_vec::iterator end() { return mleaves.end(); }

    
    typename tnode_vec::const_iterator const_begin() const {return mleaves.begin();}

    typename tnode_vec::const_iterator const_end() const {return mleaves.end();}
    
protected:
    StiCompositeLeafIterator();

    void findLeaves();

    tnode_t* mcurrentnode;

    typename tnode_vec::const_iterator mcurrentleaf;

    tnode_vec mleaves;
    
private:
};

template <class T>
StiCompositeLeafIterator<T>::StiCompositeLeafIterator(tnode_t* node)
    : mcurrentnode(node) 
{
    findLeaves();
}

template <class T>
StiCompositeLeafIterator<T>::~StiCompositeLeafIterator()
{
}

template <class T>
inline void StiCompositeLeafIterator<T>::reset()
{
    mcurrentleaf=mleaves.begin();
}

template <class T>
inline typename StiCompositeLeafIterator<T>::tnode_t*
StiCompositeLeafIterator<T>::operator*() const
{
    return (*mcurrentleaf);
}

template <class T>
inline void StiCompositeLeafIterator<T>::operator ++()
{
    ++mcurrentleaf;
}

/*
  template <class T>
  inline bool StiCompositeLeafIterator<T>::operator != (const tnode_vec::const_iterator& rhs) 
  {
  return (mcurrentleaf != rhs);
  }
*/

template <class T>
inline unsigned int StiCompositeLeafIterator<T>::getLeafCount() const 
{
    return mleaves.size();
}


/*
  template <class T>
  inline StiCompositeLeafIterator<T>::tnode_vec::iterator //return type
  StiCompositeLeafIterator<T>::begin()
  {
  return mleaves.begin();
  }
*/


/*
  template <class T>
  inline StiCompositeLeafIterator<T>::tnode_vec::iterator //return type
  StiCompositeLeafIterator<T>::end()
  {
  return mleaves.end();
  }
*/

/*
  template <class T>
  inline StiCompositeLeafIterator<T>::tnode_vec::const_iterator //return type
  StiCompositeLeafIterator<T>::const_begin() const
  {
  return mleaves.begin();
  }
*/

/*
  template <class T>
  inline StiCompositeLeafIterator<T>::tnode_vec::const_iterator //return type
  StiCompositeLeafIterator<T>::const_end() const
  {
  return mleaves.end();
  }

*/

template <class T>
void StiCompositeLeafIterator<T>::findLeaves() 
{
    LeafFinder<T> myLeafFinder(mleaves);
    myLeafFinder(mcurrentnode);
    reset();
}

#endif