Holder.h

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGNAVIGATION_HOLDER_H
#define TRIGNAVIGATION_HOLDER_H
#include <string>
#include <vector>
#include <type_traits>
#include <memory>
 
#include "GaudiKernel/ClassID.h"
 
#include "CxxUtils/checker_macros.h"
#include "xAODCore/AuxSelection.h"
#include "AsgMessaging/AsgMessaging.h"
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/DataVector.h"
#include "AthLinks/ElementLinkVector.h"
#include "AthenaKernel/StorableConversions.h"
 
#include "TrigNavigation/AccessProxy.h"
#include "TrigNavigation/TypeProxy.h"
#include "TrigNavigation/TriggerElement.h"
 
#include "TrigSerializeResult/ITrigSerializerToolBase.h"
#include "TrigStorageDefinitions/TypeInformation.h"
#include "TrigStorageDefinitions/EDM_TypeInfoMethods.h"
 
#include "TrigNavStructure/BaseHolder.h"
#include "GaudiKernel/ToolHandle.h"
 
class MsgStream;
 
namespace SG {
  class IAuxStoreIO;
  class AuxStoreInternal;
}
 
namespace HLTNavDetails {

  //note: needs to be up here to get template compiled.
  std::string formatSGkey(const std::string& prefix, const std::string& containername, const std::string& label);
 

 
  class IHolder : public HLT::BaseHolder {
  public:
    IHolder();
    IHolder(const std::string& prefix, const std::string& label, uint16_t idx );
    virtual ~IHolder();
 
 
    virtual IHolder* clone(const std::string& prefix, const std::string& label,  uint16_t idx) const = 0; // actual constructor

    
    virtual void prepare(const asg::AsgMessaging& logger, HLT::AccessProxy* sg, IConversionSvc* objSerializer, bool readonly);
    
    virtual bool syncWithSG(SG::OwnershipPolicy policy = SG::OWN_ELEMENTS) = 0;

    virtual CLID typeClid() const  = 0;
    virtual CLID containerClid() const = 0;
    virtual CLID auxClidOrZero() const = 0;

    inline const std::string& label() const { return  m_label; }

    virtual const std::string& prefix() const { return m_prefix; }

    virtual const std::string& key() const = 0;

    virtual const std::string& typeName() const = 0;

    virtual const std::string& collectionName() const = 0;

    inline uint16_t subTypeIndex() const { return  m_subTypeIndex; }
 
    std::string generateAliasKey(CLID c, uint16_t sti, const std::string& label, unsigned size);

    virtual bool serialize(std::vector<uint32_t>& output)  const;

    bool serializeWithPayload(const xAOD::AuxSelection& sel,
                              std::vector<uint32_t>& output,
                              size_t& payloadsize);
 

    bool serializePayload(std::vector<uint32_t>& dataBlob,
                          const xAOD::AuxSelection& sel);
 
 
 
    virtual void print(MsgStream& m) const;

    bool deserializePayload(const std::vector<uint32_t>& dataBlob, int version);
 
    // serialization helpers
    virtual DataObject* getDataObject() = 0;
    virtual DataObject* getAuxDataObject() = 0;
 
    virtual bool setDataObject(DataObject* dobj) = 0;
    virtual bool setAuxDataObject(DataObject* dobjaux) = 0;

    virtual const ITypeProxy& containerTypeProxy() const = 0;
 
    virtual bool checkAndSetOwnership(SG::OwnershipPolicy policy) = 0;
    virtual std::string getUniqueKey() = 0; // this is backward compatibility for TrigCaloRec and TrigTauRec, whould be removed
    virtual std::string getNextKey() = 0;   // this is backward compatibility for TrigCaloRec and TrigTauRec, whould be removed
 
  protected:
    // serialization helpers
    const asg::AsgMessaging*        m_logger{0};
    IConversionSvc*                 m_objectserializerSvc{0};     
    HLT::AccessProxy*               m_storeGate{0};               
 
    bool         m_readonly{false};
    std::unique_ptr<ITypeProxy>  m_aux;
 
    // Adapters so we can use ATH_MSG macros
    MsgStream& msg() const { return m_logger->msg(); }
    MsgStream& msg(const MSG::Level lvl) const { return msg() << lvl; }
    bool msgLvl(const MSG::Level lvl) const { return msg().level() <= lvl; }
 
  private:
    bool serializeDynVars (const SG::IAuxStoreIO& iio,
                           const xAOD::AuxSelection& sel,
                           std::vector<uint32_t>& dataBlob);
 

    bool deserializeDynVars (const std::vector<uint32_t>& dataBlob,
                             size_t offs,
                             SG::IAuxStore& store);
 

    std::unique_ptr<SG::IAuxStore>
    deserializeDynVars (const std::vector<uint32_t>& dataBlob,
                        size_t offs);
 
    
    const std::type_info* getElementType (const std::string& tname,
                                          std::string& elementTypeName) const;
    
 
    std::string  m_prefix;            
    std::string  m_label;             
    uint16_t     m_subTypeIndex{0};   
    int          m_uniqueCounter{0};

    ToolHandle<ITrigSerializerToolBase> m_serializer;
  };
 


 
  template<class STORED, class CONTAINER, bool is_same> struct set_link;
 
  template<class STORED, class CONTAINER>
  struct set_link<STORED,CONTAINER,true>{
    typedef DataLink<CONTAINER> type;
    static type do_it(const STORED* el, const CONTAINER* src, HLT::TriggerElement::ObjectIndex idx){
      (void)src;(void)idx; //not used here
      type t(el);
      return t;
    }
  };
 
  template<class STORED, class CONTAINER>
  struct set_link<STORED,CONTAINER,false>{
    typedef ElementLink<CONTAINER> type;
    static type do_it(const STORED* el,const CONTAINER* src, HLT::TriggerElement::ObjectIndex idx){
      (void)el;//not used here
      type t(*src,idx.objectsBegin());
      return t;
    }
  };

  template<class T, class C> class HolderImp;
  template<class STORED>
  class Holder : public IHolder {
  public:
    Holder();
    Holder(const std::string& prefix, const std::string& label, uint16_t idx);
    virtual ~Holder();
 
    virtual HLT::TriggerElement::ObjectIndex add ATLAS_NOT_THREAD_SAFE ( const STORED* f, bool inSG, const std::string& = "" ) = 0;          
    virtual bool get(const STORED*& dest, HLT::TriggerElement::ObjectIndex idx) = 0;
 
    template<class CONTAINER2> 
    bool get(ElementLinkVector<CONTAINER2>& cont);
 
    template<class CONTAINER2> 
    bool get(ElementLinkVector<CONTAINER2>& cont, HLT::TriggerElement::ObjectIndex idx);
 
    template<class CONTAINER2> 
    bool getWithLink(typename set_link<STORED,CONTAINER2,std::is_same<STORED,CONTAINER2>::value>::type& link,
                     HLT::TriggerElement::ObjectIndex& idx) {
      
      bool result = static_cast<HolderImp<STORED,CONTAINER2>*>(this)->getWithLink(link,idx);
      return result;
    }       
 
    virtual bool contains(const STORED* obj, HLT::TriggerElement::ObjectIndex& idx) = 0;
  };


  template<class STORED, class CONTAINER>
  class HolderImp: public  Holder<STORED> {
  public:
    typedef Holder<STORED> base_type;
    typedef STORED stored_type;
    typedef CONTAINER container_type;
    typedef HLTNavDetails::TypeProxy<STORED> FeatureProxy;
    typedef HLTNavDetails::TypeProxy<CONTAINER> ContainerProxy;
 
    HolderImp();
    HolderImp(const std::string& prefix, const std::string& label, uint16_t idx);
    virtual ~HolderImp();
 
    virtual IHolder* clone(const std::string& prefix, const std::string& label, uint16_t idx ) const;

    virtual HLT::TriggerElement::ObjectIndex add( const STORED* f, bool inSG = false, const std::string& = "" );

    virtual bool get(const STORED*& dest, HLT::TriggerElement::ObjectIndex idx);

    virtual bool contains(const STORED* obj, HLT::TriggerElement::ObjectIndex& idx);
 
    bool getElementLinks(ElementLinkVector<CONTAINER>& cont,  HLT::TriggerElement::ObjectIndex idx);
    bool getElementLinks(ElementLinkVector<CONTAINER>& cont);
        
    bool getWithLink(typename set_link<STORED,CONTAINER,std::is_same<STORED,CONTAINER>::value>::type& link,
                     HLT::TriggerElement::ObjectIndex& idx);
        
    virtual std::string getUniqueKey(); // this is backward compatibility for TrigCaloRec and TrigTauRec, whould be removed
    virtual std::string getNextKey();   // this is backward compatibility for TrigCaloRec and TrigTauRec, whould be removed
 
    virtual void prepare(const asg::AsgMessaging& logger, HLT::AccessProxy* sg, IConversionSvc* objSerializer, bool readonly = false);
    virtual bool syncWithSG(SG::OwnershipPolicy policy=SG::OWN_ELEMENTS);
    virtual bool checkAndSetOwnership(SG::OwnershipPolicy policy);
 
    virtual bool serialize(std::vector<uint32_t>& output) const;
 
    virtual const std::string& key() const { return m_key; }
    virtual void print(MsgStream& m) const;
 
    virtual DataObject* getDataObject();
    virtual DataObject* getAuxDataObject();
    virtual bool setDataObject(DataObject* dobj);
    virtual bool setAuxDataObject(DataObject* dobjaux);
 
    virtual CLID typeClid() const { return ClassID_traits<STORED>::ID(); }
    virtual const std::string& typeName() const { return ClassID_traits<STORED>::typeName(); }
    virtual CLID containerClid() const { return ClassID_traits<CONTAINER>::ID(); }
    virtual const std::string& collectionName() const { return ClassID_traits<CONTAINER>::typeName(); }
    virtual CLID auxClidOrZero() const;
 
    virtual const ITypeProxy& containerTypeProxy() const { return m_containerProxy; }
 
    // for memory management
    struct MemoryMgr {
      MemoryMgr();
      MemoryMgr(const FeatureProxy& st, bool inSG);
      void clear();
      FeatureProxy proxy;
      bool inSG;
    };
 
    ContainerProxy m_containerProxy;
 
    typedef std::multimap<HLT::TriggerElement::ObjectIndex, MemoryMgr> MemoryMgrMap;
    MemoryMgrMap m_memMgr;
 
  private:
    std::string m_key; //<! StoreGate key
  };
 
  MsgStream& operator<< ( MsgStream& m, const HLTNavDetails::IHolder& nav ); //<! printing helper
  template<class T>
  MsgStream& operator<< ( MsgStream& m, const HLTNavDetails::Holder<T>& nav ); //<! printing helper
  template<class T, class C>
  MsgStream& operator<< ( MsgStream& m, const HLTNavDetails::HolderImp<T, C>& nav ); //<! printing helper
} // end of namespace
#endif