#ifndef TOWER_ITERATORS
#define TOWER_ITERATORS

#ifdef USE_CDFEDM2
//////////////////////////////////////////////////////////////////////////
//
// Component: TowerIterators.hh
// Purpose: Contains a tower type iterator class and a "high-level"
//          iterator with predicate classes to use on CalData towers. 
//          Note: CalData has an Iterator nested class
//    
// Created: 02/05/99 (Pierre Savard, Jim Kowolkowski)
// History: 
//
//////////////////////////////////////////////////////////////////////////

#include <iosfwd>
#include <iostream>
#include <vector>
#include <utility>
#include <functional>
#include <memory>

#include "CalorGeometry/TowerDescription.hh"

namespace calor {

  //  using namespace std;
  //  typedef pair<int,int> Range;

  typedef enum { CEM,PEM,WHA,PHA,CHA,PPR } Detectors;
  typedef CalTower* TowerData[ETABINS][PHIBINS];
  typedef TowerType value_type;

  template <class T>
    class TypeIter{
    
    public:

      //
      // Memory management
      //
 
      TypeIter();
      TypeIter(TowerData& td,int Eta, int Phi);

      //
      // Testing
      //
    
      // Equality test

      bool operator==(const TypeIter& it) const
	{ return data==it.data && phi==it.phi && iter==it.iter; }
      bool operator!=(const TypeIter& it) const { return !operator==(it); }
      
      //
      // Manipulation and access
      //

      TypeIter& operator++()
	{
	  if((*data)[++phi][*iter]==0) { ++iter; phi=1; }
	  return *this;
	}
      
      CalTower* operator->() { return (*data)[phi][*iter]; }
      CalTower& operator*() { return *operator->(); }

      
      TypeIter& operator=(const TypeIter& it)
	{
	  data=it.data; cdata=it.cdata; iter=it.iter; il=it.il; phi=it.phi;
	  return *this;
	}

      bool done() const { return iter==il.end(); }

      //
      // Printing
      //

      friend std::ostream& operator<<(std::ostream& os, const Iterator& s);


    private:
      CalorData::Towerdata* data;
      CalorData* cdata;
      IndexList il;
      int phi;
      IndexList::iterator iter; // current eta

    };
 

  template <class CONT, class PRED=None>
    class HighlevelIter
    {

    public:

      HighLevelIter(CONT& c);
      HighLevelIter(CONT& c,PRED p);

      HighLevelIter& operator++();

      CONT::value_type* operator->() { return &*iter; }
      CONT::value_type& operator*() { return *operator->(); }

      bool operator==(const HighLevelIter& it) const
	{ return /*pred==it.pred &&*/ iter==it.iter; }
      bool operator!=(const HighLevelIter& it) const 
	{ return !operator==(it); }

      HighLevelIter& operator=(const HighLevelIter& it)
	{
	  cont=it.cont; iter=it.iter; pred=it.pred;
	  return *this;
	}

      bool done() const { return iter==cont->end(); }

    private:
      PRED pred;
      CONT* cont;
      CONT::iterator iter;
      
      void first()
	{ while(iter != cont->end() && pred(*iter)==false) ++iter; }
    };

  //
  // Predicate classes
  //


  class HasTiming
  {
  public:
    HasTiming() { }
    bool operator()(CalTower& t) const { return t.hasTiming()==true; }
  private:
  };


  class HadEnergyGreater
  {
  public:

    HadEnergyGreater():value(0.0) { }
    HadEnergyGreater(double x):value(x) { }
    bool operator()(CalTower& t) const { return t.hadEnergy()>value; }
    // { bool rc=t.hadEnergy()>value; if(rc==true) std::cerr << ' ' <<
    // t.hadEnergy() << ' '; return rc;}

  private:
    double value;
  };


  class None
  {
  public:

    bool operator()(CalTower& t) const { return true; }

  };


  class IsDetectorType
  {
  public:

    IsDetectorType() { }
    IsDetectorType(Detectors x):value(x) { }
    bool operator()(CalTower& t) const { return t.includesDetector(value); }

  private:
    Detectors value;
  };

  namespace {
    bool ascending(CalTower* t1, CalTower* t2) { return t1->hadEnergy() <
					     t2->hadEnergy(); }
  }

  template <class SRC, class DEST, class PRED>
    void extractTowers(SRC& src, DEST& dest, PRED pred)
    {
      dest.clear();
      SRC::iterator i = src.begin();
      while(i!=src.end())
	{
	  if(pred(*i)==true) dest.push_back(&(*i));
	  ++i;
	}
    }
  
} // namespace Calor 

#endif  // USE_CDFEDM2
#endif // TOWER_ITERATORS