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

#ifndef TRIGGER_DECISION_TOOL_CACHE_GLOBAL_MEMORY_H
#define TRIGGER_DECISION_TOOL_CACHE_GLOBAL_MEMORY_H

/**********************************************************************************
 * @Project: TrigDecisionTool
 * @Package: TrigDecisionTool
 * @Class  : CacheGlobalMemory
 *
 * @brief registry for ChainGroups
 *
 * @author Michael Begel  <michael.begel@cern.ch> - Brookhaven National Laboratory
 *
 ***********************************************************************************/

#include<iterator>
#include<vector>
#include<list>
#include<set>
#include<map>
#include<string>
#include "boost/foreach.hpp"
#include <unordered_map>

#include "TrigConfHLTData/HLTChain.h"
#include "TrigConfHLTData/HLTChainList.h"
#include "TrigConfHLTData/HLTStreamTag.h"

#include "TrigConfL1Data/CTPConfig.h"

#include "TrigSteeringEvent/Chain.h"
#include "xAODTrigger/TrigCompositeContainer.h"

#include "TrigDecisionTool/IDecisionUnpacker.h"
#include "TrigDecisionTool/Logger.h"
#include "AsgTools/AsgMessaging.h"



namespace HLT {
  class Chain;
  class TriggerElement;
}

namespace LVL1CTP {
  class Lvl1Item;
  class Lvl1Result;
}


#include "TrigDecisionTool/EventPtrDef.h"

namespace Trig {

  class ChainGroup;

  class CacheGlobalMemory : public virtual Logger {

  using Logger::msgLvl;//resolve ambiguity from also inheriting from Logger
  
  public:
    // constructors, destructor
    CacheGlobalMemory();
    ~CacheGlobalMemory();

    const Trig::ChainGroup* createChainGroup(const std::vector< std::string >& patterns,
                                             const std::string& alias="");
    void update(const TrigConf::HLTChainList* confChains,
                const TrigConf::CTPConfig* ctp);

    const LVL1CTP::Lvl1Item* item(const std::string& name) const;            
    const LVL1CTP::Lvl1Item* item(const TrigConf::TriggerItem& i) const;     
    const TrigConf::TriggerItem* config_item(const std::string& name) const; 
    float item_prescale(int ctpid) const;                                      
    
    const HLT::Chain* chain(const std::string& name) const;                  
    const HLT::Chain* chain(const TrigConf::HLTChain& chIt) const;           
    const TrigConf::HLTChain* config_chain(const std::string& name) const;   

    const HLT::TrigNavStructure* navigation() const {   
      if(!m_unpacker->unpacked_navigation()){
    if(const_cast<CacheGlobalMemory*>(this)->unpackNavigation().isFailure()){
      ATH_MSG_WARNING("unpack Navigation failed");;
    }
      }
      return m_navigation; 
    }
    void navigation(HLT::TrigNavStructure* nav) { m_navigation = nav; }       
    
    std::map< std::vector< std::string >, Trig::ChainGroup* >& getChainGroups() {return m_chainGroupsRef;};
    //    std::map<unsigned, const LVL1CTP::Lvl1Item*>  getItems() {return m_items;};
    //    std::map<unsigned, const LVL1CTP::Lvl1Item*>  getItems() const {return m_items;};
    //    std::map<unsigned, const HLT::Chain*>         getL2chains() {return m_l2chains;};
    //    std::map<unsigned, const HLT::Chain*>         getL2chains() const {return m_l2chains;};
    //    std::map<unsigned, const HLT::Chain*>         getEFchains() {return m_efchains;};
    //    std::map<unsigned, const HLT::Chain*>         getEFchains() const {return m_efchains;};
    std::map<std::string, std::vector<std::string> > getStreams() {return m_streams;};
    std::map<std::string, std::vector<std::string> > getStreams() const {return m_streams;};

    const xAOD::TrigCompositeContainer* expressStreamContainer() const;

    bool assert_decision();

    void setUnpacker( Trig::IDecisionUnpacker* up ){ m_unpacker = up; }
    Trig::IDecisionUnpacker* unpacker(){ return m_unpacker; }
    

    void setStore( EventPtr_t store ) { m_store = store; }
    EventPtr_t store() const { return m_store; }


    // 
    template<class T>
    void deleteAtTheEndOfEvent(T t) const { m_deleteAtEndOfEvent.insert(t); }


    

  private:
    friend class DecisionAccess;

    StatusCode unpackDecision();
    StatusCode unpackNavigation();

    void updateChainGroup(Trig::ChainGroup* chainGroup);

    //
    // Data members
    //

    EventPtr_t m_store;
    
    IDecisionUnpacker* m_unpacker;

    // Navigation owned by CGM
    HLT::TrigNavStructure* m_navigation;
    
    // chain groups 
    typedef std::map< std::vector< std::string >, Trig::ChainGroup* >::iterator ChGrIt;
    std::map< std::vector< std::string >, Trig::ChainGroup* > m_chainGroups;     
    std::map< std::vector< std::string >, Trig::ChainGroup* > m_chainGroupsRef;  

    //    std::map<CTPID, const LVL1CTP::Lvl1Item*>          m_items;    //!< items keyed by id (changing every event)
    //    std::map<CHAIN_COUNTER, const HLT::Chain*>         m_l2chains; //!< chains keyed by chain counter (chainging every event)
    //    std::map<CHAIN_COUNTER, const HLT::Chain*>         m_efchains;
    
    std::map<std::string, const LVL1CTP::Lvl1Item*>  m_itemsByName;     
    std::map<std::string, const HLT::Chain*>         m_l2chainsByName;  
    std::map<std::string, const HLT::Chain*>         m_efchainsByName;  
    
    typedef unsigned CTPID;
    typedef unsigned CHAIN_COUNTER;
    std::map<CTPID, LVL1CTP::Lvl1Item*>  m_itemsCache;               
    std::map<CHAIN_COUNTER, HLT::Chain*> m_l2chainsCache;            
    std::map<CHAIN_COUNTER, HLT::Chain*> m_efchainsCache;            

    std::map<std::string, std::vector<std::string> > m_groups;          
    std::map<std::string, std::vector<std::string> > m_streams;         
    
    const TrigConf::ItemContainer* m_confItems;             
    const TrigConf::HLTChainList*  m_confChains;            
    mutable const xAOD::TrigCompositeContainer* m_expressStreamContainer;

    struct eqstr
    {
      bool operator()(const char* s1, const char* s2) const
      {
        return strcmp(s1, s2) == 0;
      }
    };
    
    typedef std::unordered_map<const char*, const TrigConf::HLTChain*, std::hash<const char*>, eqstr> ChainHashMap_t;
    ChainHashMap_t     m_mConfChains;            
  
    char     m_bgCode; 
    
    
    class AnyTypeDeleter {

      
      struct iholder {
        virtual ~iholder() {}
        virtual void* ptr() const { return 0;}
      };

      struct holder_comp {
        bool operator()(iholder* lhs, iholder* rhs) const { 
          return lhs->ptr() < rhs->ptr(); }      
      };
      template<class T>
      class holder : public iholder {    
      public:
        holder(T& t): m_held(t) {}
        virtual ~holder() { 
          delete m_held;
          m_held = 0; }    
        virtual void* ptr() const { return (void*)m_held;}
      private:
        T m_held;
      };

    public:
      template<class T>
      void insert(T t) {
        m_todel.insert(new holder<T>(t));
      }
      void clear() {
        BOOST_FOREACH(iholder* i, m_todel) {
          delete i;
        }    
        m_todel.clear();
      }
      ~AnyTypeDeleter();
    private:  
      std::set< iholder*, holder_comp > m_todel;
    };  // end of deleter
    
    mutable AnyTypeDeleter m_deleteAtEndOfEvent;



  };
} // End of namespace

#endif

---