FEvent/Eye.h

Go to the documentation of this file.

#ifndef _fevt_Eye_h_
#define _fevt_Eye_h_

#include <fevt/FdComponentSelector.h>
#include <fevt/FdConstants.h>
#include <utl/ShadowPtr.h>
#include <utl/IteratorRange.h>

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


namespace fevt {

  class EyeRecData;
  class EyeTriggerData;
  class EyeHeader;
  class Telescope;


  class Eye {

  private:
    typedef std::list<Telescope*> InternalTelescopeContainer;
    typedef InternalTelescopeContainer::iterator InternalTelescopeIterator;
    typedef InternalTelescopeContainer::const_iterator InternalConstTelescopeIterator;

    typedef boost::indirect_iterator<InternalTelescopeIterator,
                                     Telescope&> AllTelescopeIterator;

    typedef boost::indirect_iterator<InternalConstTelescopeIterator,
                                     const Telescope&> ConstAllTelescopeIterator;

    AllTelescopeIterator AllTelescopesBegin() { return AllTelescopeIterator(fTelescopes.begin()); }
    AllTelescopeIterator AllTelescopesEnd() { return AllTelescopeIterator(fTelescopes.end()); }
    ConstAllTelescopeIterator AllTelescopesBegin() const { return ConstAllTelescopeIterator(fTelescopes.begin()); }
    ConstAllTelescopeIterator AllTelescopesEnd() const { return ConstAllTelescopeIterator(fTelescopes.end()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(AllTelescopeIterator, ConstAllTelescopeIterator, AllTelescopes)

  public:
    Eye(const Eye& eyeData);
    Eye& operator=(const Eye& eyeData);
    
    unsigned int GetId() const { return fId; }

    unsigned int GetNActiveTelescopes() const { return fTelescopes.size(); }

    Telescope& GetTelescope(const unsigned int telescopeId,
                            const ComponentSelector::Status status = ComponentSelector::eHasData);
    const Telescope& GetTelescope(const unsigned int telescopeId,
                                  const ComponentSelector::Status status = ComponentSelector::eHasData) const;
    void MakeTelescope(const unsigned int telescopeId,
                       const ComponentSelector::Status status = ComponentSelector::eHasData);
    bool HasTelescope(const unsigned int telescopeId,
                      const ComponentSelector::Status status = ComponentSelector::eHasData) const;

    typedef boost::filter_iterator<ComponentSelector, AllTelescopeIterator> TelescopeIterator;
    typedef boost::filter_iterator<ComponentSelector, ConstAllTelescopeIterator> ConstTelescopeIterator;

    TelescopeIterator TelescopesBegin();
    TelescopeIterator TelescopesEnd();
    ConstTelescopeIterator TelescopesBegin() const;
    ConstTelescopeIterator TelescopesEnd() const;
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES(TelescopeIterator, ConstTelescopeIterator, Telescopes)

    
    TelescopeIterator TelescopesBegin(const ComponentSelector::Status status)
    { return TelescopeIterator(ComponentSelector(status), AllTelescopesBegin(), AllTelescopesEnd()); }
    TelescopeIterator TelescopesEnd(const ComponentSelector::Status status)
    { return TelescopeIterator(ComponentSelector(status), AllTelescopesEnd(), AllTelescopesEnd()); }
    ConstTelescopeIterator TelescopesBegin(const ComponentSelector::Status status) const
    { return ConstTelescopeIterator(ComponentSelector(status), AllTelescopesBegin(), AllTelescopesEnd()); }
    ConstTelescopeIterator TelescopesEnd(const ComponentSelector::Status status) const
    { return ConstTelescopeIterator(ComponentSelector(status), AllTelescopesEnd(), AllTelescopesEnd()); }
    OFFLINE_MAKE_BOTH_ITERATOR_RANGES_ARG(TelescopeIterator, ConstTelescopeIterator, Telescopes, const ComponentSelector::Status arg)

    
    fevt::EyeHeader& GetHeader();
    const fevt::EyeHeader& GetHeader() const;

    void MakeHeader();
    bool HasHeader() const { return bool(fHeader); }

    fevt::EyeTriggerData& GetTriggerData();
    const fevt::EyeTriggerData& GetTriggerData() const;
    void MakeTriggerData();
    bool HasTriggerData() const { return bool(fTriggerData); }

    fevt::EyeRecData& GetRecData();
    const fevt::EyeRecData& GetRecData() const;
    void MakeRecData();
    bool HasRecData() const { return bool(fRecData); }

    ComponentSelector::Status GetStatus() const { return fStatus; }
    void SetStatus(const ComponentSelector::Status status) { fStatus = status; }

  private:
    Eye(const unsigned int eyeId, const ComponentSelector::Status status = ComponentSelector::eHasData);
    ~Eye();

    void Clear();

    unsigned int fId = 0;
    InternalTelescopeContainer fTelescopes;
    utl::ShadowPtr<EyeRecData> fRecData;
    utl::ShadowPtr<EyeTriggerData> fTriggerData;
    utl::ShadowPtr<EyeHeader> fHeader;
    ComponentSelector::Status fStatus;

    friend class FEvent;

  };

}


#endif