CDetector.h

Go to the documentation of this file.

#ifndef _cdet_CDetector_h_
#define _cdet_CDetector_h_

#include <iterator>
#include <cstddef>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <cdet/Station.h>
#include <boost/iterator/transform_iterator.hpp>
#include <utl/Validated.h>


namespace det {
  class Detector;
}

namespace utl {
  class NonExistentComponentException;
}

namespace cevt {
  class Station;
}

namespace cdet {

  class CDetector {

  private:
    typedef std::map<int, const cdet::Station*> InternalStationMap;
    typedef InternalStationMap::const_iterator InternalStationIterator;

  public:

    class StationIterator :
      public std::iterator<std::input_iterator_tag, const cdet::Station&, ptrdiff_t, const cdet::Station*, const cdet::Station& > {
      
    public:
      // use this to loop over all stations
      StationIterator(const InternalStationIterator& it) :
        fInternalIterator(it),
        fEnd(it),
        fIndex(CDetectorConstants::eAny),
        fFilter(false)
      { }
      
      // use this to loop only over stations that match the GridIndex
      StationIterator(const InternalStationIterator& begin,
                      const InternalStationIterator& end,
                      const CDetectorConstants::GridIndex index) :
        fInternalIterator(begin), fEnd(end), fIndex(index), fFilter(true)
      { }
      
      StationIterator&
      operator++()
      {
        ++fInternalIterator;
        if (fFilter)
          // step further to next hit or end
          for ( ; fInternalIterator != fEnd; ++fInternalIterator)
            if (fInternalIterator->second->IsInGrid(fIndex) || fInternalIterator->second->IsDense())
              break;
        return *this;
      }
      
      bool operator==(const StationIterator& other) const
      { return fInternalIterator == other.fInternalIterator; }
      
      bool operator!=(const StationIterator& other) const
      { return !operator==(other); }
      
      const Station& operator*() const
      { return *fInternalIterator->second; }
      
      const Station* operator->() const
      { return fInternalIterator->second; }
      
    private:
      InternalStationIterator fInternalIterator;
      InternalStationIterator fEnd;
      CDetectorConstants::GridIndex fIndex;
      bool fFilter;
    };
    

    StationIterator StationsBegin() const
    { return StationIterator(fCommissionedStationList.begin()); }
    

    StationIterator StationsEnd() const
    { return StationIterator(fCommissionedStationList.end()); }
    

    StationIterator
    GridStationsBegin(const CDetectorConstants::GridIndex index)
      const
    {
      return StationIterator(fCommissionedStationList.begin(),
                             fCommissionedStationList.end(),
                             index);
    }
    

    StationIterator GridStationsEnd() const { return StationsEnd(); }
    

    StationIterator AllStationsBegin() const
    { return StationIterator(fFullStationMap.begin()); }
    

    StationIterator AllStationsEnd() const
    { return StationIterator(fFullStationMap.end()); }
    

    bool IsStationCommissioned(const int stationId) const
    { return fCommissionedStationList.find(stationId) != fCommissionedStationList.end(); }
    
    bool IsStationDense(const int stationId) const
    { return std::find(fDenseStationSubList.begin(), fDenseStationSubList.end(),
                       stationId) != fDenseStationSubList.end(); }

    const Station& GetStation(const int stationId) const;

    const Station& GetStation(const cevt::Station& station) const;

    const Station& GetAllStation(const int stationId) const;

    const std::vector<int>& GetFullStationList() const;

    const std::vector<int>& GetDenseStationList() const
    { return fDenseStationSubList; }

    typedef std::map<int, std::set<int> > StationGroups;
    typedef StationGroups::const_iterator StationGroupsIterator;

    const StationGroups& GetStationGroups() const { return fStationGroups; }

  private:
    CDetector() { }
    ~CDetector();

    CDetector(const CDetector& cdetector);
    CDetector& operator=(const CDetector& cdetector);

    void Update();
    void UpdateDense();

    void FetchStationGroups() const;

    // Container for all stations commissioned at the
    // current detector time.
    mutable InternalStationMap fCommissionedStationList;

    // List of all stations available in the external sources
    // (external sources are, for example, the XML file with
    // station list or perhaps some MySQL database)
    mutable utl::Validated<std::vector<int> > fFullStationList;
    mutable InternalStationMap fFullStationMap;
    mutable StationGroups fStationGroups;

    // list of all dense stations.  Used to set the IsDense flag
    mutable std::vector<int> fDenseStationSubList;

    friend class det::Detector;

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: