Navigation.icc

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIGNAVIGATION_HLTNAVIGATION_ICC
#define TRIGNAVIGATION_HLTNAVIGATION_ICC
 
 
/*****************************************************************************
 *
 * COMPILE TYPE OBJECTS REGISTRATION
 *
 *****************************************************************************/
 
#include <type_traits>
#include "TrigNavigation/Holder.h"
#include "CxxUtils/checker_macros.h"
#include "CxxUtils/no_sanitize_undefined.h"
 
 
/*****************************************************************************
 *
 * FEATURES OPERATIONS
 *
 *****************************************************************************/
 
template<class T>
__attribute__((__used__))
bool HLT::Navigation::attachFeature NO_SANITIZE_UNDEFINED ATLAS_NOT_THREAD_SAFE
                                   ( TriggerElement* te, const T* feature,
                     MemoryManagement mmanagement, std::string& key,
                     const std::string& label ) {
  // Get clid
  CLID clid = ClassID_traits<T>::ID();
 
  ATH_MSG_DEBUG("attachFeature: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                << " to TE: " << te->getId()
                << " label: \"" << label << "\""
                << " memory management: " << mmanagement);
 
  // get a holder for this type --- if that's new it will be created
 
  ATH_MSG_VERBOSE("getting Holder for label: " << label);
  HLTNavDetails::Holder<T>* holder = getHolder<T>(label, nextSubTypeIndex(clid,label));
  ATH_MSG_VERBOSE("got Holder: " << holder);
 
  if ( ! holder ) {
    ATH_MSG_WARNING("attachFeature: Holder missing for CLID: " << clid);
    return false;
  }
 
  TriggerElement::ObjectIndex objectIndex = holder->add(feature, mmanagement == ObjectInStoreGate,  key);
  if ( not objectIndex.valid() )
      return false;
  te->addFeature(clid, objectIndex, false);
 
  return true;
}
 
 
template<class T>
__attribute__((__used__))
bool HLT::Navigation::attachFeature ATLAS_NOT_THREAD_SAFE ( TriggerElement* te, const ConstDataVector<T>* feature,
                     MemoryManagement mmanagement, std::string& key,
                     const std::string& label ) {
  return attachFeature (te, feature->asDataVector(),
                        mmanagement, key, label);
}
 
 
template<class T>
__attribute__((__used__))
bool HLT::Navigation::associateExternalCollection(const std::string& label) {
  CLID clid = ClassID_traits<T>::ID();
  
  ATH_MSG_DEBUG("associateExternalCollection: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                << " label: \"" << label << "\"");
  HLTNavDetails::Holder<T>* holder = getHolder<T>(label, nextSubTypeIndex(clid,label));    
  if ( ! holder ) { 
    ATH_MSG_WARNING("associateExternalCollection: Holder missing for CLID: " << clid);
    return false;
  }
  return true;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
bool HLT::Navigation::findOwners(const T* obj, std::vector<const TriggerElement*>& owners, unsigned int id) {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  TriggerElementFactory& factory = getFactory();
  TrigHolderStructure& holderstorage = getHolderStorage();
 
  std::vector<TriggerElement*>::const_iterator it      = factory.listOfProduced().begin();
  std::vector<TriggerElement*>::const_iterator itEnd   = factory.listOfProduced().end();
  if ( id != 0 ) {
    it      = factory.listOfProduced(id).begin();
    itEnd   = factory.listOfProduced(id).end();
    ATH_MSG_VERBOSE("findOwners will scann TEs of ID : " << id << " #: " << itEnd-it);
  } else {
    ATH_MSG_VERBOSE("findOwners will scann ALL TEs (slow):" << itEnd-it);
  }
 
  CLID clid = ClassID_traits<T>::ID();
 
  auto holders_of_clid = holderstorage.getHoldersOfClid<HLTNavDetails::Holder<T> >(clid); 
  
  if(holders_of_clid.empty())
    return true;
 
  ATH_MSG_VERBOSE("findOwners features of this CLID present");
  bool holderFound = false;
  HLT::TriggerElement::ObjectIndex idx;
  for(auto holder : holders_of_clid ) {
    if ( holder->contains(obj, idx) ) {
      holderFound = true;
      ATH_MSG_VERBOSE("findOwners found holder owning the object " << *holder << " and index: " << idx);
      break;
    }
  }
  if ( !holderFound ) 
    return true;
 
  for (; it != itEnd; ++it ) {
    for ( const TriggerElement::FeatureAccessHelper& f : (*it)->getFeatureAccessHelpers() ) {
      if ( f.getCLID() == clid && f.getIndex().isSameOrWithin(&idx) ) {
        owners.push_back(*it);
        ATH_MSG_VERBOSE("findOwners while looking in TE(id): " << *it <<"(" << (*it)->getId() << ")" <<
                        " and access helper " << f.getIndex() << " found owner");
        break;
      }
    }
  }
  return true;
}
 
template<class T>
__attribute__((__used__))
const std::string HLT::Navigation::getNextKey( const std::string& label ) {
  CLID clid = ClassID_traits<T>::ID();
  HLTNavDetails::Holder<T>* holder = getHolder<T>(label, nextSubTypeIndex(clid,label));
  if (!holder) return ""; // should never happen, but who knows
 
  return holder->getNextKey( );
}
 
template<class T>
__attribute__((__used__))
const std::string HLT::Navigation::getUniqueKey( const std::string& label ) {
  CLID clid = ClassID_traits<T>::ID();
  HLTNavDetails::Holder<T>* holder = getHolder<T>(label, nextSubTypeIndex(clid, label));
  
  if (!holder) return ""; // should never happen, but who knows
 
  return holder->getUniqueKey( );
}
 
 
#endif // TRIGNAVIGATION_HLTNAVIGATION_ICC