SEvent.h

Go to the documentation of this file.

#ifndef _sevt_SEvent_h_
#define _sevt_SEvent_h_

#include <sevt/SEventSimData.h>
#include <utl/LameShadowPtr.h>
#include <utl/IteratorRange.h>
#include <sevt/Station.h>
#include <sevt/Header.h>

#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/filter_iterator.hpp>

#include <vector>
#include <map>
#include <algorithm>


namespace evt {
  class Event;
}

namespace sevt {

  //class Station;
  class EventTrigger;
  class Meteo;


  class SEvent {

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

  public:
    SEvent(const SEvent& sEvent) { *this = sEvent; }
    SEvent& operator=(const SEvent& sEvent);

    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()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(StationIterator, ConstStationIterator, Stations)

    
    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()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(CandidateStationIterator, ConstCandidateStationIterator, CandidateStations)

    
    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()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(SilentStationIterator, ConstSilentStationIterator, SilentStations)

    
    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()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(RejectedStationIterator, ConstRejectedStationIterator, RejectedStations, const int arg = ~0)

    
    Station& GetStation(const int stationId) { return OFFLINE_CAST_CONST_METHOD(GetStation(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(); }

    // The following  methods map from IoSdEvent
    // and set and get the actual number of stations
    // in the T3

    int GetNErrorZeroStations() const { return fNErrorZeroStations; }
    void SetNErrorZeroStations(const unsigned int n) { fNErrorZeroStations = n; }

    // SD Event SimData

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

    // SD Event Central Trigger Information

    EventTrigger& GetTrigger() { return *fTrigger; }
    const EventTrigger& GetTrigger() const { return *fTrigger; }
    void MakeTrigger();
    bool HasTrigger() const { return bool(fTrigger); }

    sevt::Header& GetHeader() { return fHeader; }
    const sevt::Header& GetHeader() const { return fHeader; }


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

    // new Meteo weather information

    bool HasMeteo() const { return bool(fMeteo); }

    void MakeMeteo();

    Meteo& GetMeteo() { return *fMeteo; }
    const Meteo& GetMeteo() const { return *fMeteo; }

  private:
    SEvent() = default;
    ~SEvent();


    StationIterator RemoveStation(const StationIterator& it);

    mutable InternalStationCollection fStations;
    utl::LameShadowPtr<SEventSimData> fSimData;
    utl::LameShadowPtr<EventTrigger> fTrigger;
    Header fHeader;
    unsigned int fNErrorZeroStations = 0;
    utl::LameShadowPtr<Meteo> fMeteo;

    friend class evt::Event;
    friend class utl::LameShadowPtr<SEvent>;

  };

}


#endif