CEvent.h

Go to the documentation of this file.

#ifndef _cevt_CEvent_h_
#define _cevt_CEvent_h_

#include <vector>
#include <map>
#include <algorithm>
#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/filter_iterator.hpp>

#include <utl/LameShadowPtr.h>
#include <cevt/CEventSimData.h>
#include <cevt/Station.h>

static const char CvsId_cevt_CEvent[] =
  "$Id$";

namespace evt {
  class Event;
}

namespace cevt {

//   class EventTrigger;
//   class Header;
//   class SQualityCuts;


  class CEvent {

  private:
    typedef std::vector<Station*> InternalStationCollection;
    typedef InternalStationCollection::iterator InternalStationIterator;
    typedef InternalStationCollection::const_iterator InternalConstStationIterator;

  public:
    CEvent(const CEvent& cEvent);
    CEvent& operator=(const CEvent& cEvent);
 
    typedef boost::indirect_iterator<InternalStationIterator,
                                     Station&> StationIterator;
    typedef boost::indirect_iterator<InternalConstStationIterator,
                                     const Station&> ConstStationIterator;

    StationIterator StationsBegin()
    { return StationIterator(fStations.begin()); }
    StationIterator StationsEnd()
    { return StationIterator(fStations.end()); }

    ConstStationIterator StationsBegin() const
    { return ConstStationIterator(fStations.begin()); }
    ConstStationIterator StationsEnd() const
    { return ConstStationIterator(fStations.end()); }


    typedef boost::filter_iterator<CandidateStationFilter,
                                   StationIterator> CandidateStationIterator;
    typedef boost::filter_iterator<CandidateStationFilter,
                                   ConstStationIterator> ConstCandidateStationIterator;

    CandidateStationIterator CandidateStationsBegin()
    { return CandidateStationIterator(StationsBegin(), StationsEnd()); }
    CandidateStationIterator CandidateStationsEnd()
    { return CandidateStationIterator(StationsEnd(), StationsEnd()); }

    ConstCandidateStationIterator CandidateStationsBegin() const
    { return ConstCandidateStationIterator(StationsBegin(), StationsEnd()); }
    ConstCandidateStationIterator CandidateStationsEnd() const
    { return ConstCandidateStationIterator(StationsEnd(), StationsEnd()); }

    typedef boost::filter_iterator<SilentStationFilter,
                                   StationIterator> SilentStationIterator;
    typedef boost::filter_iterator<SilentStationFilter,
                                   ConstStationIterator> ConstSilentStationIterator;

    SilentStationIterator SilentStationsBegin()
    { return SilentStationIterator(StationsBegin(), StationsEnd()); }
    SilentStationIterator SilentStationsEnd()
    { return SilentStationIterator(StationsEnd(), StationsEnd()); }

    ConstSilentStationIterator SilentStationsBegin() const
    { return ConstSilentStationIterator(StationsBegin(), StationsEnd()); }
    ConstSilentStationIterator SilentStationsEnd() const
    { return ConstSilentStationIterator(StationsEnd(), StationsEnd()); }

    typedef boost::filter_iterator<RejectedStationFilter,
                                   StationIterator> RejectedStationIterator;
    typedef boost::filter_iterator<RejectedStationFilter,
                                   ConstStationIterator> ConstRejectedStationIterator;

    // DV: maybe in the future the rejectionMask should be replaced with an expression template
    RejectedStationIterator RejectedStationsBegin(const int rejectionMask = ~0)
    { return RejectedStationIterator(RejectedStationFilter(rejectionMask), StationsBegin(), StationsEnd()); }
    RejectedStationIterator RejectedStationsEnd(const int rejectionMask = ~0)
    { return RejectedStationIterator(RejectedStationFilter(rejectionMask), StationsEnd(), StationsEnd()); }

    ConstRejectedStationIterator RejectedStationsBegin(const int rejectionMask = ~0) const
    { return ConstRejectedStationIterator(RejectedStationFilter(rejectionMask), StationsBegin(), StationsEnd()); }
    ConstRejectedStationIterator RejectedStationsEnd(const int rejectionMask = ~0) const
    { return ConstRejectedStationIterator(RejectedStationFilter(rejectionMask), StationsEnd(), StationsEnd()); }


    Station& GetStation(const int stationId);
    const Station& GetStation(const int stationId) const;

    void MakeStation(const int stationId);
    bool HasStation(const int stationId) const;
    int GetNumberOfStations() const { return fStations.size(); }


//     // SD Event Central Trigger Information

//     /// Get the object with central trigger data, throw if n.a.
//     EventTrigger& GetTrigger() { return *fTrigger; }
//     const EventTrigger& GetTrigger() const { return *fTrigger; }
//     /// Create the central trigger object
//     void MakeTrigger();
//     /// check whether the central trigger object exists
//     bool HasTrigger() const { return fTrigger; }

//     Header& GetHeader() { return *fHeader; }
//     const Header& GetHeader() const { return *fHeader; }


    template<class OrderingCriterion>
    void SortStations(const OrderingCriterion ord)
    { std::sort(fStations.begin(), fStations.end(), ord); }

    //     bool HasQualityCuts() const { return fQualityCuts; }
    //     const SQualityCuts& GetQualityCuts() const { return *fQualityCuts; }
    //     void SetQualityCuts(const SQualityCuts& cuts);



    CEventSimData & GetSimData() { return *fSimData; }
    const CEventSimData & GetSimData() const { return *fSimData; }
    void MakeSimData();
    bool HasSimData() const { return bool(fSimData); }


  private:
    CEvent();
    ~CEvent();


    StationIterator RemoveStation(const StationIterator it);

    InternalStationCollection fStations;

    //     utl::LameShadowPtr<EventTrigger> fTrigger;
    //     utl::InitializedLameShadowPtr<Header> fHeader;
    //     utl::LameShadowPtr<SQualityCuts> fQualityCuts;

    utl::LameShadowPtr<CEventSimData> fSimData;  
    friend class evt::Event;
    friend class utl::LameShadowPtr<CEvent>;

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k"
// End: