/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/TrigConfHLTData/TrigConfHLTData/HLTSequence.h

#ifndef TrigConf_HLTSequence
#define TrigConf_HLTSequence

#include "TrigConfL1Data/TrigConfData.h"

#include <iosfwd>
#include <fstream>
#include <string>
#include <vector>

namespace TrigConf {

   class HLTSequence;
   class HLTTriggerElement;
   class DiffStruct;
   std::ostream & operator<<(std::ostream &, const HLTSequence &);

   class HLTSequence : public TrigConfData {
   public:

      HLTSequence();

      HLTSequence( const std::vector<HLTTriggerElement*>& inputTEs,
                   HLTTriggerElement* outputTE,
                   const std::vector<std::string>& algorithms);

      ~HLTSequence();

      // accessors
      std::vector<HLTTriggerElement*>& inputTEs() { return m_inputTEs;   } 
      HLTTriggerElement*               outputTE() { return m_outputTE;  } 
      std::vector<std::string>&        algorithms() { return m_algorithms; } 
      HLTTriggerElement*               topoStartTE() { return m_topoStartTE;} 

      const std::vector<HLTTriggerElement*>& inputTEs() const { return m_inputTEs;   } 
      const HLTTriggerElement*               outputTE()  const { return m_outputTE;   } 
      const std::vector<std::string>&        algorithms() const { return m_algorithms; } 
      const HLTTriggerElement*               topoStartTE() const { return m_topoStartTE; } 
      unsigned int                           hashId() const;

      void set_inputTEs   ( std::vector<HLTTriggerElement*>& inputTEs ) { m_inputTEs = inputTEs;   } 
      void set_outputTE   ( HLTTriggerElement* outputTE );
      void set_algorithms ( std::vector<std::string>& algorithms ) { m_algorithms = algorithms; } 
      void set_topoStartTE( HLTTriggerElement* te ) { m_topoStartTE = te; }         

      void print(const std::string& indent="", unsigned int detail=1) const;
      void writeXML(std::ofstream & xmlfile);

      std::string concise() const;

      void setL2(bool on=true) const { set(); if(on) m_level |= 0x1; else m_level &= 0x6; }
      void setEF(bool on=true) const { set(); if(on) m_level |= 0x2; else m_level &= 0x5; }
      void setHLT(bool on=true) const { set(); if(on) m_level = 0x4; else m_level &= 0x3; }

      void reset() const { m_level = 0x8; }
      bool inL2() const { return (m_level&0x1) != 0; }
      bool inEF() const { return (m_level&0x2) != 0; }
      bool inHLT() const { return (m_level&0x4) != 0; }
      bool isSet() const { return (m_level&0x8) == 0; }

      bool operator<(const HLTSequence& s) const {
         return name() < s.name();
      }

      DiffStruct* compareTo(const HLTSequence* o) const;

      // python
      std::string __str__() const;

   private:

      std::vector<HLTTriggerElement*> m_inputTEs;   
      HLTTriggerElement*              m_outputTE { nullptr };   
      std::vector<std::string>        m_algorithms; 
      HLTTriggerElement*              m_topoStartTE { nullptr }; 

      // bit 0 - L2 / bit 1 - EF / bit 2 - HLT / bit 3 - unset
      mutable unsigned int            m_level { 0 };      

      void set() const { m_level &= 0x7; } 
                                             
      friend std::ostream & operator<<(std::ostream &, const HLTSequence &);

   };

}

#endif

---