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

// -*- c++ -*-
#ifndef TRIGNAVSTRUCTURE_TRIGGERELEMENT_H
#define TRIGNAVSTRUCTURE_TRIGGERELEMENT_H

#include <map>
#include <vector>
#include <string>
#include <stdint.h>
#include <iostream>


#include "TrigNavStructure/Types.h"
namespace HLT {

  //  class NavigationCore;
  //  class RoICacheHelper;
  //  class TrigNavigationSlimmingTool;
  /*
  class FeatureDescriptor {
  public:
    FeatureDescriptor(std::string label, uint32_t objectsBegin, uint32_t objectsEnd)
      : m_label(label), m_begin(objectsBegin), m_end(objectsEnd) {}

    const std::string& label() const { return m_label; }
    uint32_t objectsBegin() const { return m_begin; }
    uint32_t objectsEnd() const { return m_end; }
  private:
    std::string m_label;
    uint32_t m_begin;
    uint32_t m_end;
  };
  */

  class TriggerElement {
  public:
    
    TriggerElement();
    TriggerElement( te_id_type id, bool ghost, bool nofwd=false);
    ~TriggerElement();

    //    void reset();

    inline te_id_type getId() const { return m_id; }

    inline bool getActiveState() const { return m_state & activeState; }

    void setActiveState( bool state );

    inline bool ghost() const { return m_state & ghostState; }
    bool getGhostState() const { return m_state & ghostState; }
    void setGhostState( bool t = true); 

    void setTransient(bool t = true) { m_transient = t; }
    bool transient() { return m_transient; }


    void setErrorState(bool state = true);

    inline bool getErrorState() const { return m_state & errorState; }

    //    friend class HLT::NavigationCore; //!< this class will be able to play with the navigation
    //    friend class HLT::TrigNavigationSlimmingTool;
    //    friend class HLT::RoICacheHelper; //!< this class will be able to play with the navigation

    class ObjectIndex {
    public:
      
      ObjectIndex();

      ObjectIndex(sub_index_type subType, index_type begin, index_type end); 
      sub_index_type subTypeIndex() const;  
      index_type objectsBegin() const;   
      index_type objectsEnd() const;   
      bool isSameOrWithin ( const ObjectIndex* idx) const; 
      void updateBeginAndEnd( index_type begin, index_type end);
      bool operator<(const ObjectIndex& obj) const;

      void serialize(std::vector<uint32_t>& output) const;
      void deserialize( std::vector<uint32_t>::const_iterator& inputIt);

      void setSubTypeIndex(sub_index_type idx) { m_subTypeIndex = idx; }
      bool valid() const;
      bool operator==(const ObjectIndex& rhs) const {
    if (m_subTypeIndex != rhs.m_subTypeIndex || m_objIndexBegin != rhs.m_objIndexBegin 
        || m_objIndexEnd != rhs.m_objIndexEnd)
      return false;
    return true;
      }
      bool operator!=(const ObjectIndex& rhs) const {
    return ! (*this == rhs);
      }

    private:
      sub_index_type m_subTypeIndex;           
      index_type m_objIndexBegin;          
      index_type m_objIndexEnd;            
    };





    enum Relation {
      sameRoIRelation,             
      seedsRelation,               
      seededByRelation             
    };

    inline const std::vector<TriggerElement*>& getRelated( Relation rel ) const { return m_relations[rel];}

    enum States { 
      activeState = 0x1,          
      ghostState  = 0x2,          
      nofwdState  = 0x4,          
      errorState  = 0x8           
    };

    mutable std::map<Relation, std::vector<TriggerElement*> > m_relations;   

    void relate( TriggerElement* te, Relation r ) const;

    void relate( const std::vector<TriggerElement*> tes, Relation r ) const;

    static unsigned int enquireId( std::vector<uint32_t>::const_iterator& inputIt );

    void serialize( std::vector<uint32_t>& output, const std::map<TriggerElement*, uint16_t>& keys, const TriggerElement* previous ) const;

    void deserialize( std::vector<uint32_t>::const_iterator& inputIt, const std::map<uint16_t, TriggerElement*>& keys, const TriggerElement* previous );



    class FeatureAccessHelper {      
    public:
      FeatureAccessHelper() 
    : m_CLID(0), m_forget(false) {}

      FeatureAccessHelper( class_id_type clid, ObjectIndex index, bool forget=false) 
    : m_CLID(clid), m_index(index),m_forget(forget) {}

      //FeatureAccessHelper( unsigned int clid, const ObjectIndex& index, bool forget=false) //!< the only constructor
      //    : m_CLID(clid), m_index(index),m_forget(forget) {}

      //method needed for navigation rewiring (AOD->xAOD)
      void setCLIDandIndex(class_id_type clid, sub_index_type idx){
    m_CLID = clid;
    m_index.setSubTypeIndex(idx);
      }
      inline class_id_type getCLID() const {return m_CLID;}     
      inline const ObjectIndex& getIndex() const {return m_index;}   

      inline void setForget( bool value = true ) { m_forget = value; }  
      inline bool forget() const { return m_forget; }          
      friend std::ostream& operator<<( std::ostream& o, const FeatureAccessHelper& f ) {
    o << " CLID:" << f.m_CLID 
      << " idx:" << f.m_index.subTypeIndex() 
      << ":" << f.m_index.objectsBegin() 
      << ":" << f.m_index.objectsEnd()   << std::dec;
    return o;
      }
      bool operator==(const FeatureAccessHelper& rhs) const {
    if (m_CLID != rhs.m_CLID || m_index != rhs.m_index)
      return false;
    return true;
      }
      
      bool valid() const { return m_CLID != invalid_class_id and m_index.valid(); }

    private:
      class_id_type m_CLID;        
      ObjectIndex   m_index;  
      bool          m_forget; 
    };
    typedef std::vector< FeatureAccessHelper > FeatureVec;

    const std::vector< FeatureAccessHelper >& getFeatureAccessHelpers() const { return m_uses; }
    std::vector< FeatureAccessHelper >& getFeatureAccessHelpers() { return m_uses; }

    void addFeature( class_id_type clid, const ObjectIndex& index, bool forget=false );
    void addFeature( const FeatureAccessHelper& f);

    
    const std::vector<FeatureAccessHelper>& getPreviousFeatures() const {return m_prev; }
    std::vector<FeatureAccessHelper>& getPreviousFeatures() {return m_prev; }
    //    void appendFeaturesKeyPrint(const std::vector<FeatureAccessHelper>& k);

  private:
    unsigned int m_state;        
    te_id_type m_id;                
    bool m_transient;            
    std::vector< FeatureAccessHelper > m_uses; 
    std::vector< FeatureAccessHelper > m_prev; 
    
  };
} // eof namespace

#endif //TRIGNAVSTRUCTURE_TRIGGERELEMENT_H

---