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

// Dear emacs, this is -*- c++ -*-

#ifndef TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H
#define TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H

#include <vector>

#include "TrigNavStructure/TriggerElement.h"
#include "TrigNavStructure/TriggerElementFactory.h"
#include "TrigNavStructure/BaseHolder.h"

#include "TrigNavStructure/TrigHolderStructure.h"

namespace HLTNavDetails {
  // RAII trick to fill sizes at the exit of the function
  // at construction the extra word is reserved and the current size remembered
  // at destruction the current size is filled at the previously reserved index
  struct FillSize {
    std::vector<uint32_t>& m_output;
    size_t m_index;
    FillSize(std::vector<uint32_t>& o)
      : m_output(o), m_index(m_output.size()) {
      m_output.push_back(0);
    }
    ~FillSize() {
      m_output[m_index]  = m_output.size();
    }
  };
}

namespace HLT {
  class TrigNavStructure {
  public:
    
    virtual ~TrigNavStructure();

    virtual void reset();

    TriggerElement* getInitialNode();
    const TriggerElement* getInitialNode() const;

    TriggerElement* addRoINode( TriggerElement* initial );

    static const std::vector<TriggerElement*>& getRoINodes( const TriggerElement* somenode );

    TriggerElement* addNode( TriggerElement* seed, unsigned int id );

    TriggerElement* addNode( std::vector<TriggerElement* >& seeds, unsigned int id, bool ghost=false, bool nofwd=false );

    static const std::vector<TriggerElement*>& getDirectPredecessors( const TriggerElement* te );

    static const std::vector<TriggerElement*>& getDirectSuccessors( const TriggerElement* te );

    static const TriggerElement* getSuccessor( const TriggerElement* te, unsigned int id );

    static bool isInitialNode( const TriggerElement* te );

    static bool isRoINode( const TriggerElement* te );

    static bool isTerminalNode( const TriggerElement* te );


    void printASCIIArt( std::string& str, const TriggerElement* te = 0, int offset = 0 ) const;

    bool serializeTEs( std::vector<uint32_t>& output ) const;
    bool deserializeTEs( std::vector<uint32_t>::const_iterator& start, unsigned int totalSize);

    virtual bool serialize( std::vector<uint32_t>&) const = 0;
    virtual bool deserialize( const std::vector<uint32_t>&) = 0;

    TriggerElement::FeatureAccessHelper getFeature(const TriggerElement* te, class_id_type clid, const index_or_label_type& index_or_label) const;


    TriggerElement::FeatureAccessHelper getFeatureRecursively(const TriggerElement* startTE, class_id_type clid,
                                  const index_or_label_type& index_or_label, const TriggerElement*& sourceTE) const;


    void getAllRoIThresholdTEs( std::vector< TriggerElement* >& output ) const;

    void getAll( std::vector< TriggerElement* >& output, const bool activeOnly = true ) const;

    std::vector<TriggerElement*>& getAllTEs() { return m_factory.listOfProduced(); } 

    void getAllOfType( const te_id_type id, std::vector< TriggerElement* >& output,  const bool activeOnly = true ) const;    



    unsigned int countAllOfType( const te_id_type id, const bool activeOnly = true ) const;

    static bool haveCommonRoI( const TriggerElement* te1,  const TriggerElement* te2 );

    static bool haveDistinctRoI(const TriggerElement* te1, const TriggerElement* te2 );

    static bool haveAllCommonRoIs ( const HLT::TriggerElement* te1, const HLT::TriggerElement* te2 );

    static bool haveCommonSeed( const TriggerElement* te1, const TriggerElement* te2 );

    static bool haveDistinctSeed( const TriggerElement* te1, const TriggerElement* te2 );

    static bool increasingOrderByTEId( const TriggerElement* te1, const TriggerElement* te2 );
    static bool decreasingOrderByTEId( const TriggerElement* te1, const TriggerElement* te2 );

    static bool hasIdFromTheSet( const TriggerElement* te, std::vector<unsigned int> ids );

    static inline bool isNotActive( const TriggerElement* te ) { return !te->getActiveState(); }

    static inline bool isTopological( const TriggerElement* te) { return (getDirectPredecessors(te).size() > 1 ? true : false); }

    static bool isCompatibleTree(const TriggerElement* te1, const TriggerElement* te2 );


    
    bool propagateDeactivation(const TrigNavStructure* nav);



    bool combine(std::vector<unsigned int>& types,
                 std::vector< std::vector<TriggerElement*> >& output,
                 unsigned int maxResults = 1000, bool onlyActive = true);

    bool overlaps(const TriggerElement* t1, const TriggerElement* t2) const;

    bool overlaps(const TriggerElement* t1, const std::vector<TriggerElement*>& teVec) const;


    bool getTopologicallySpannedBy( const TriggerElement* te, const std::vector<unsigned int>& types,
                    std::vector<TriggerElement*>& children, const bool activeOnly = true ) const;

    unsigned int copyAllFeatures( const TriggerElement* sourceTE, TriggerElement* destTE);

    const BaseHolder* getHolder(const TriggerElement::FeatureAccessHelper& fea) const;

    sub_index_type subType(class_id_type clid, const index_or_label_type& sti_or_label) const;
    std::string label(class_id_type clid, const index_or_label_type& sti_or_label) const;


    virtual bool getFeatureAccessors( const TriggerElement* te, class_id_type clid,
                      const index_or_label_type& index_or_label,
                      bool only_single_feature,
                          TriggerElement::FeatureVec& features, 
                          bool with_cache_recording,
                          bool travel_backward_recursively,
                          const TriggerElement*& source = m_unspecifiedTE, 
                          std::string& sourcelabel  = m_unspecifiedLabel) const;
  protected:

    virtual bool getFeatureAccessorsSingleTE( const TriggerElement* te, class_id_type clid,
                          const index_or_label_type& index_or_label,
                          bool only_single_feature,
                          TriggerElement::FeatureVec& features,
                          bool with_cache_recording,
                          const TriggerElement*& source,
                          std::string& sourcelabel ) const ;
    
    
    //method to see if feature matches by clid and either index or label
    bool matchFeature(const TriggerElement::FeatureAccessHelper& fea, class_id_type clid,  const index_or_label_type& index_or_label) const;

    void fillSameRoIRelation ( TriggerElement* roi, TriggerElement* te );

    bool addOneLevel(std::vector< std::vector<TriggerElement*> >& currentCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& currentIdxs,
                     unsigned int type,
                     std::vector< std::vector<TriggerElement*> >& newCombs,
                     std::vector< std::vector<std::pair<unsigned int, unsigned int> > >& newIdxs,
                     unsigned int maxResults = 1000, bool onlyActive = 1);



    TriggerElementFactory m_factory;                     
    TrigHolderStructure m_holderstorage;                 
    static const TriggerElement* m_unspecifiedTE;
    static std::string m_unspecifiedLabel;


  };
} // end of HLT namespace

#endif // TRIGNAVSTRUCTURE_TRIGNAVSTRUCTURE_H

---