StiSortedHitIterator.h

#ifndef StiSortedHitIterator_HH
#define StiSortedHitIterator_HH
#ifdef GNU_GCC
  #if __GNUC__<3
    #define HACK_forward_iterator
  #endif
#endif
#include <vector>
#include <iterator>
using namespace std;
#include "StiHit.h"
typedef StiHit Hit_t;
#include "StiDetector.h"
#include "StiHitContainer.h"

class StiSortedHitIterator
#ifndef HACK_forward_iterator
: public iterator<forward_iterator_tag, Hit_t, ptrdiff_t, Hit_t*, Hit_t&>
#else
    : public forward_iterator<Hit_t, int>
#endif
{
public:
  StiSortedHitIterator();
  StiSortedHitIterator(StiHitContainer * hitContainer,
                       vector<StiDetector*>::iterator firstDet,
                       vector<StiDetector*>::iterator lastDet);
  StiSortedHitIterator(const StiSortedHitIterator&iter);
  const StiSortedHitIterator& operator=(const StiSortedHitIterator&iter);
  ~StiSortedHitIterator() {};
  
  bool operator==(const StiSortedHitIterator& rhs);
  bool operator!=(const StiSortedHitIterator& rhs);
  StiHit& operator*();
  StiSortedHitIterator& operator++();
  StiSortedHitIterator operator++(int);
  //StiSortedHitIterator end();
  
private:
    StiHit * _currentHit;
    StiHitContainer * _hitContainer;
    vector<StiDetector*>::iterator _currentDet;
    vector<StiDetector*>::iterator _firstDet;
    vector<StiDetector*>::iterator _lastDet;
    vector<StiHit*>::iterator _currentDetHit;
    vector<StiHit*>::iterator _lastDetHit;
};



inline const StiSortedHitIterator& StiSortedHitIterator::operator=(const StiSortedHitIterator&iter)
{
  _currentHit = iter._currentHit; 
  _hitContainer = iter._hitContainer;
  _currentDet = iter._currentDet;
  _firstDet = iter._firstDet;
  _lastDet  = iter._lastDet;
  _currentDetHit = iter._currentDetHit;
  _lastDetHit = iter._lastDetHit;
  return *this;
}


inline bool StiSortedHitIterator::operator==(const StiSortedHitIterator& rhs)
{
  return _currentHit==rhs._currentHit;
}

inline bool StiSortedHitIterator::operator!=(const StiSortedHitIterator& rhs)
{
  return _currentHit!=rhs._currentHit;
}

inline StiHit& StiSortedHitIterator::operator*()
{
  assert(_currentHit);
  return *_currentHit;
}

inline StiSortedHitIterator& StiSortedHitIterator::operator++()
{
  // if this iterator points to a null hit, return because there is nothing to do.
  // This guarantees the end() iterator will behave properly.
  if (_currentHit==0)
    return *this;

  ++_currentDetHit;
  if (_currentDetHit<_lastDetHit)
    {
      _currentHit = *_currentDetHit;
    }
  else
    {
      // Reached end of current detector hits
      // Must go to next detector with hits.
      if (_currentDet<_lastDet)
        {
          // Still have detectors to traverse, find next one which
          // has hits.
          bool go = true;
          while (_currentDet<_lastDet && go )
            {
              ++_currentDet;
              if (_currentDet<_lastDet )
                {
                  // valid detector
        if (_hitContainer->hasDetector(*_currentDet)) {

                  _currentDetHit =  _hitContainer->hitsBegin(*_currentDet);
                  _lastDetHit    =  _hitContainer->hitsEnd(*_currentDet);
                  if (_currentDetHit < _lastDetHit)
                    {
                      // current detector has hits
                      // done for now.
                      _currentHit = *_currentDetHit;
                      go = false;
                    }
       }
                }
              else
                {
                  // reached past the last detector
                  // no more hits to serve
                  _currentHit = 0;
                  _currentDet = _lastDet;
                  _currentDetHit = _lastDetHit;
                }
            }
        }
      else  // !(_currentDet<_lastDet)
        {
          _currentHit = 0;
          _currentDet = _lastDet;
          _currentDetHit = _lastDetHit;
        }
    }
  return *this;
}
    

inline StiSortedHitIterator StiSortedHitIterator::operator++(int)
{
    StiSortedHitIterator temp = *this;
    ++(*this);
    return temp;
}

#endif