NavigationCore.icc

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIGNAVIGATION_HLTNAVIGATIONCORE_ICC
#define TRIGNAVIGATION_HLTNAVIGATIONCORE_ICC
 
#include <iostream>
#include <algorithm>
 
#include "TrigNavigation/Holder.h"
#include "TrigNavigation/Holder.icc"
#include "CxxUtils/checker_macros.h"
#include "CxxUtils/no_sanitize_undefined.h"
 
/*****************************************************************************
 *
 * COMPILE TYPE OBJECTS REGISTRATION
 *
 *****************************************************************************/
#include <type_traits>
 
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
bool HLT::NavigationCore::getFeatures( const TriggerElement* te,
                   std::vector<const T*>&  features, const std::string& label,
                   std::map<const T*, std::string>* /*labels*/) const {
 
 
  class_id_type clid = ClassID_traits<T>::ID();
  ATH_MSG_DEBUG("getFeatures: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                <<" to TE: " << te->getId()
                << " label: \"" << label << "\"");
 
  TriggerElement::FeatureVec features_access_helpers;  
  bool single = false; bool recursively = false;
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively)) {
    return false;
  }
 
  for(auto& fea : features_access_helpers) {
    TriggerElement::ObjectIndex objectIndex(fea.getIndex());
    HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
    const T* obj(0);
    if ( holder->get(obj, objectIndex) == false ) {
      ATH_MSG_WARNING("getFeatures: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder);
    } else {
      features.push_back(obj);
    }
  }
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getFeature NO_SANITIZE_UNDEFINED ( const TriggerElement* te, const T*&  feature, const std::string& label, std::string& sourcelabel) const {
 
  feature = 0;
 
  class_id_type clid = ClassID_traits<T>::ID();
 
  ATH_MSG_DEBUG("getFeature: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                <<" to TE: " << te->getId()
                << " label: \"" << label << "\"");
 
  TriggerElement::FeatureVec features_access_helpers;  
  bool single = true; bool recursively = false;
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively, m_unspecifiedTE, sourcelabel)) {
    return false;
  }
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getFeatureAccessors");
  }
 
  
  if ( features_access_helpers.empty() )
    return true;
 
  const TriggerElement::FeatureAccessHelper& fea = features_access_helpers.front();
  TriggerElement::ObjectIndex objectIndex(fea.getIndex());
  
  HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
  if (!holder) {
    return false;
  }
  
  if ( holder->get(feature, objectIndex) == false ) {
    ATH_MSG_WARNING("getFeature: problems while getting objects #" << objectIndex
                    << " from the holder: " << *holder);
    feature = 0;    
  }
  
  return true;  
}
 
template<class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getFeature( const TriggerElement* te,
                                      const ConstDataVector<T>*&  feature,
                                      const std::string& label, std::string& sourcelabel) const {
  const T* dv = nullptr;
  if (!getFeature (te, dv, label, sourcelabel))
    return false;
 
  feature = ConstDataVector<T>::fromDataVector (dv);
  return feature != nullptr;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class C, class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getFeaturesLinks( const TriggerElement* te, ElementLinkVector<C>& links, const std::string& label) const {
  
  class_id_type clid = ClassID_traits<T>::ID();
 
  ATH_MSG_DEBUG("getFeaturesLinks: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                << " to TE: " << te->getId()
                << " label: \"" << label << "\"");
 
  TriggerElement::FeatureVec features_access_helpers;
  bool single = false; bool recursively = false;
  if (!getFeatureAccessors(te,clid, label, single, features_access_helpers, recursively)) {
    return false;
  }
 
  for(auto& fea : features_access_helpers) {
    TriggerElement::ObjectIndex objectIndex(fea.getIndex());
    HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
    
    if ( holder->get(links, objectIndex) == false ) {
      ATH_MSG_WARNING("getFeaturesLinks: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder);
    }
  }
  return true;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
bool HLT::NavigationCore::getRecentFeatures( const TriggerElement* te,
                         std::vector<const T*>&  features, const std::string& label,
                         std::map<const T*, std::string>* /*labels*/) const {
 
  class_id_type clid = ClassID_traits<T>::ID();
 
  // start from itself
  ATH_MSG_DEBUG("getRecentFeatures: looking for CLID: " << clid  << "(" << ClassID_traits<T>::typeName() << ")"
                << " in TE: " << te->getId()
                << " label: \"" << label << "\"");
 
  TriggerElement::FeatureVec features_access_helpers;  
  bool single = false; bool recursively = true;
 
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively)) {
    return false;
  }
 
  // type specific code
  for( auto& fea : features_access_helpers) {
    TriggerElement::ObjectIndex objectIndex(fea.getIndex());
    HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
    const T* obj(0);
    if ( holder->get(obj, objectIndex) == false ) {
      ATH_MSG_WARNING("getRecentFeatures: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder);
    } else {
      features.push_back(obj);
    }
  }
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getRecentFeature( const TriggerElement* te, 
                        const T*&  feature, const std::string& label, 
                        const TriggerElement*& source, std::string& sourcelabel ) const {
 
  // important! set pointer to NULL to signify nothing was found, it will later be reset to sth else eventually
  feature = 0;
 
  class_id_type clid = ClassID_traits<T>::ID();
 
  ATH_MSG_DEBUG("getRecentFeature: looking for CLID: " << ClassID_traits<T>::ID()  << "(" << ClassID_traits<T>::typeName() << ")"
          << " in TE: " << te->getId()  
          << " label: \"" << label << "\"");
 
  TriggerElement::FeatureVec features_access_helpers; 
  bool single = true; bool recursively = true;
 
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively, source, sourcelabel)) {
    return false;
  }
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getRecentFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getRecentFeaturesImpl" );
  }
 
  if ( features_access_helpers.empty() )
    return true;
 
  const TriggerElement::FeatureAccessHelper& fea = features_access_helpers.front();
  TriggerElement::ObjectIndex objectIndex(fea.getIndex());
  HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
  
  if ( holder->get(feature, objectIndex) == false ) {
    ATH_MSG_WARNING("getRecentFeature: problems while getting objects #" << objectIndex
                    << " from the holder: " << *holder);
    feature = 0;    
  }
  
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class C, class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getRecentFeaturesLinks( const TriggerElement* te,
                          ElementLinkVector<C>& links, const std::string& label ) const {
 
  
  class_id_type clid = ClassID_traits<T>::ID();
 
  ATH_MSG_DEBUG("getRecentFeaturesLinks: looking for CLID: " << ClassID_traits<T>::ID()
                << "(" << ClassID_traits<T>::typeName() << ")"
                << " in TE: " << te->getId()
                << " label: \"" << label << "\"");
  
  TriggerElement::FeatureVec features_access_helpers;  
  bool single = false; bool recursively = true;
 
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively)) {
    return false;
  }
  
  for(auto& fea : features_access_helpers) {
    TriggerElement::ObjectIndex objectIndex(fea.getIndex());
    HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
 
    if ( holder->get(links, objectIndex) == false ) {
      ATH_MSG_WARNING("getRecentFeaturesLinks: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder);
    }
  }
  return true;
}
 
//helper struct to get the container type if template argument is datalink or the element type if template arg is ElementLink
 
template<class LinkType>
struct link_to_type;
 
template<class CONTAINERTYPE>
struct link_to_type<DataLink<CONTAINERTYPE> >{
  typedef CONTAINERTYPE container_type;
  typedef typename DataLink<CONTAINERTYPE>::value_type type;
};
 
template<class CONTAINERTYPE>
struct link_to_type<ElementLink<CONTAINERTYPE> >{
  typedef CONTAINERTYPE container_type;
  typedef typename ElementLink<CONTAINERTYPE>::ElementType ptr2constT_type;   // is a const T* if T is the feature type
  typedef typename std::remove_pointer<ptr2constT_type>::type constT_type;  // is a const T
  typedef typename std::remove_const<constT_type>::type type;               // is a       T
};
 
 
/////////////////////////////////////////////////////////////////////////////
template<class LinkType> 
__attribute__((__used__))
bool HLT::NavigationCore::getRecentFeatureDataOrElementLink( const TriggerElement* te, LinkType& link, const std::string& label,
                                                             const TriggerElement*& source, std::string& sourcelabel) const {
 
 
 
  
  typedef typename link_to_type<LinkType>::type T;
  class_id_type clid = ClassID_traits<T>::ID();
  ATH_MSG_DEBUG("getRecentFeatureDataOrElementLink: looking for CLID: " << clid  << "(" << ClassID_traits<T>::typeName() << ")"
              << " in TE: " << te->getId()  
              << " label: \"" << label << "\"");
  
  TriggerElement::FeatureVec features_access_helpers;  
  bool single = true; bool recursively = true;
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively, source, sourcelabel)) {
    ATH_MSG_INFO("looking for FAs failed. Returning false! Details CLID: " << ClassID_traits<T>::ID() <<
                 "(" << ClassID_traits<T>::typeName() << ")"
                 << " in TE: " << te->getId()  << " label: \"" << label << "\"");
    return false;
  }
 
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getRecentFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getRecentFeaturesImpl" );
  }
  
  if ( features_access_helpers.empty() )
    return true;
    
  const TriggerElement::FeatureAccessHelper& fea = features_access_helpers.front();
  TriggerElement::ObjectIndex objectIndex(fea.getIndex());
  HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
  
  //apparently must use function pointer to get all the types resolved properly
  typedef typename link_to_type<LinkType>::container_type containertype;  
  bool (HLTNavDetails::Holder<T>::*funcptr) (LinkType&, HLT::TriggerElement::ObjectIndex&) = 
  &HLTNavDetails::Holder<T>::template getWithLink<containertype>;
  
  if ( (holder->*funcptr)(link, objectIndex) == false ) {
      ATH_MSG_WARNING("getRecentFeatureLink: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder);
  }
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class C, class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getRecentFeatureLink( const TriggerElement* te,
                                                ElementLink<C>& link, const std::string& label, 
                                                const TriggerElement*& source, 
                                                std::string& sourcelabel) const {
 
  
  class_id_type clid = ClassID_traits<T>::ID();
 
  
  ATH_MSG_DEBUG("getRecentFeatureLink: looking for CLID: " << clid  << "(" << ClassID_traits<T>::typeName() << ")"
              << " in TE: " << te->getId()  
              << " label: \"" << label << "\"");
  
  if( std::is_same<C, T>::value ) 
    return false;
    
 
  TriggerElement::FeatureVec features_access_helpers; 
  bool single = true; bool recursively = true;
 
  if (!getFeatureAccessors(te, clid, label, single, features_access_helpers, recursively, source, sourcelabel)) {
    return false;
  }
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getRecentFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getRecentFeaturesImpl" );
  }
 
  if ( features_access_helpers.empty() )
    return true;
 
  const TriggerElement::FeatureAccessHelper& fea = features_access_helpers.front();
  TriggerElement::ObjectIndex objectIndex(fea.getIndex());
  HLTNavDetails::Holder<T>* holder = getHolder<T>(objectIndex.subTypeIndex());
 
  ElementLinkVector<C> links;
  if ( holder->get(links, objectIndex) == false ) {
    ATH_MSG_WARNING("getRecentFeatureLink: problems while getting objects #" << objectIndex
                    << " from the holder: " << *holder);
  } else {
    if ( links.size() != 1 ) {
      ATH_MSG_WARNING("getRecentFeatureLink: problems while getting objects #" << objectIndex
                      << " from the holder: " << *holder << " links vector has size "
                      << links.size() << " while shoudl have size == 1");
      return false;
    } else {
      link = links.back();
    }
  }
  return true;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
bool HLT::NavigationCore::getFeaturesInRoI( const TriggerElement* te,
                                            std::vector<const T*>&  features, const std::string& label,
                                            std::map<const T*, std::string>* labels) const {
  // easy, jump to the RoI (if not RoI node) and loop over all TEs attached to it
  const TriggerElement* roi(0);
  if ( TrigNavStructure::isRoINode(te) )
    roi = te;
  else if ( te->getRelated(TriggerElement::sameRoIRelation).size() == 1 ) // means we do not support topological TEs here
    roi = *(te->getRelated(TriggerElement::sameRoIRelation).begin());
  else
    return false;
 
  bool oneRetStatus = false;
  bool allRetStatus = false;
  for ( const TriggerElement* te : roi->getRelated(TriggerElement::sameRoIRelation) ) {
    oneRetStatus = getFeatures(te, features, label, labels );  // the features will be paked to the end of the vector (see push_back in getFeatures)
    allRetStatus = allRetStatus || oneRetStatus; // that's OK if at least one call returns some feature
  }
  return allRetStatus;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class C, class T> 
__attribute__((__used__))
bool HLT::NavigationCore::getAllFeatures( ElementLinkVector<C>&  features, const std::string& label ) const {
  std::lock_guard<std::recursive_mutex> lock(getMutex());
  const TrigHolderStructure& holderstorage = getHolderStorage();
 
  CLID clid = ClassID_traits<T>::ID();
  ATH_MSG_DEBUG("getAllFeatures: of clid: " << clid << "(" << ClassID_traits<T>::typeName() << ")"
                << " label: \"" << label << "\"");
  
  for ( auto& iholder : holderstorage.getHoldersOfClid(clid) ) {
    if ( label == iholder->label() || label == "" ) {
      HLTNavDetails::Holder<T>* holder = getHolder<T>(iholder->label(), nextSubTypeIndex(clid, label));
      ATH_MSG_VERBOSE("getAllFeatures: getting from: " << *holder);
      if ( holder->get(features) == false ) {
        ATH_MSG_WARNING("getAllFeatures: failed with the holder of clid: " << clid <<
                        "(" << ClassID_traits<T>::typeName() << ")" << " label: \"" << label << "\"");
        return false;
      }
    }
  }
  return true;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
HLTNavDetails::Holder<T>* HLT::NavigationCore::getHolder NO_SANITIZE_UNDEFINED (const std::string& label, uint16_t suggestedIndex) const {
 
  // find object
  CLID clid = ClassID_traits<T>::ID();
  ATH_MSG_DEBUG("Getting holder for type: " << clid << " label: " << label);
 
  HLTNavDetails::Holder<T>* holder = static_cast<HLTNavDetails::Holder<T>* >(getHolder(clid, label));
  
  if ( holder ) {
    return holder; 
  }
  
  // take an appropriate action if this is the first feature of that type#label to be attached/retrieved
  HLTNavDetails::IHolder* baseholder;
  if ( createHolder(baseholder, clid, label, suggestedIndex) ) {        // create fresh holder
    ATH_MSG_DEBUG("getHolder: predefined holder got");
    
  } else {
    ATH_MSG_ERROR("getHolder: predefined holder does not exist, load EDM classes for: "
                  << ClassID_traits<T>::typeName() << " CLID " << ClassID_traits<T>::ID());
    return 0;
  }
  holder = static_cast<HLTNavDetails::Holder<T>*>(baseholder);
 
  // registerHolder is thread-safe via a mutex:
  auto nc_this ATLAS_THREAD_SAFE = const_cast<HLT::NavigationCore*>(this);
  nc_this->registerHolder(holder);
 
  return holder;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class T>
__attribute__((__used__))
HLTNavDetails::Holder<T>* HLT::NavigationCore::getHolder NO_SANITIZE_UNDEFINED (uint16_t subTypeIndex ) const {
  // find object
  CLID clid = ClassID_traits<T>::ID();
  ATH_MSG_DEBUG("Getting holder for type: " << clid);
  HLTNavDetails::Holder<T>* holder = static_cast<HLTNavDetails::Holder<T>* >(getHolder(clid, subTypeIndex));
 
  return holder;
}
 
/////////////////////////////////////////////////////////////////////////////
// 2012-09-14 new stuff for composite obejcts
 
#include "TrigNavigation/NavigationInit.h"
 
#include <stdlib.h>
#include <cxxabi.h>
 
namespace HLT{
 
  template<class T, class C, bool get_by_contianer, bool get_by_object>
  struct get{};
 
  template<class T, class C>
  struct get< T, C, false, false>{
    static const T* do_it(const TrigFeatureLink&, const HLT::NavigationCore* ){
      return 0; // here compile time error shoudl be generated
    }
  };
 
  template<class T, class C>
  struct get< T,  C, false, true>{
    static const T* do_it(const TrigFeatureLink&fl, const HLT::NavigationCore* nav){
      HLTNavDetails::Holder<T>* holder = nav->getHolder<T>(fl.subTypeIndex());
      //std::cerr << " Holder acquired " << __LINE__ << std::endl;
      const T* ptr(0);
      holder->get(ptr, HLT::TriggerElement::ObjectIndex(fl.subTypeIndex(), fl.index(), fl.index()+1));
      //      std::cerr << " object retrieved " << __LINE__ << std::endl;
      return ptr;
    }
 
  };
 
  template<class T, class C>
  struct get< T, C, true, false>{
    static const T* do_it(const TrigFeatureLink&fl, const HLT::NavigationCore* nav){
      HLTNavDetails::Holder<C>* holder = const_cast<HLT::NavigationCore*>(nav)->getHolder<C>(fl.subTypeIndex());
      //std::cerr << " Holder acquired " << __LINE__ <<  " " << fl.clid() << " " << fl.subTypeIndex() << " " << holder << "  " <<  ClassID_traits<C>::ID() << std::endl;
      const C* ptr(0);
      holder->get(ptr, HLT::TriggerElement::ObjectIndex(fl.subTypeIndex(), fl.index(), fl.index()+1));
      //std::cerr << " object retrieved " << __LINE__ << std::endl;
      if ( ptr and ptr->size() == 1) {
    return ptr->at(0);
      }
      return 0;
    }
  };
 
 
  template<class T, class C>
  struct get< T, C, true, true> {
    static const T* do_it(const TrigFeatureLink&fl, const HLT::NavigationCore* nav){
      if ( fl.clid() == ClassID_traits<C>::ID() ) {
    return get<T,C, true, false>::do_it(fl, nav);
      } else if ( fl.clid() == ClassID_traits<T>::ID() ) {
    return get<T,C, false, true>::do_it(fl, nav);
      }
      return 0;
    }
  };
}
 
template<class T> 
__attribute__((__used__))
const T* HLT::NavigationCore::featureLink2Object( const TrigFeatureLink& fl) const {
  if (! fl.isValid())
    return (const T*)0;
 
  typedef typename Object2Features<T>::type list_of_possible_features;  
  typedef typename Object2Container<T>::type container;  
  
  // std::cerr << " in the list "  << HLT::tool::rtti_real_name(typeid(list_of_possible_features).name()) << std::endl;
  // std::cerr << " container "  << HLT::tool::rtti_real_name(typeid(container).name()) << std::endl;
  // std::cerr << " has T "  << list_of_possible_features::template has<T>::result << std::endl;
  // std::cerr << " has container "  << list_of_possible_features::template has<container>::result << std::endl;
 
  const T* ptr = HLT::get<T, container, 
    list_of_possible_features::template has<container>::result,
    list_of_possible_features::template has<T>::result>::do_it(fl, this);
 
  return ptr;
 
}
 
 
template<class T> 
__attribute__((__used__))
TrigFeatureLink HLT::NavigationCore::object2FeatureLink(const TriggerElement* te, const std::string& label,
                            const T* obj) const {
 
  //typedef typename Features2Container<T>::type Container;
  if ( obj == 0 ) 
    return TrigFeatureLink();
  TriggerElement::FeatureVec features_access_helpers;  
  std::string sourcelabel;
  if ( getFeatureAccessors(te, ClassID_traits<T>::ID(), label, true, features_access_helpers, true, m_unspecifiedTE, sourcelabel ) == false ) {
    return TrigFeatureLink();
  }
 
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getFeatureAccessors" );
  }
 
  if ( features_access_helpers.empty() )
    return TrigFeatureLink();
 
  const TriggerElement::ObjectIndex& oindex = features_access_helpers.at(0).getIndex();
  return TrigFeatureLink(ClassID_traits<T>::ID(), oindex.subTypeIndex(), oindex.objectsBegin());
 
}
 
template<class C> 
__attribute__((__used__))
TrigFeatureLink HLT::NavigationCore::object2FeatureLink(const TriggerElement* te, const std::string& label,
                            const typename Container2Object<C>::type* obj, 
                            const C* container) const {
 
  TriggerElement::FeatureVec features_access_helpers;  
  std::string sourcelabel;
  if ( getFeatureAccessors(te, ClassID_traits<C>::ID(), label, true, features_access_helpers, true, m_unspecifiedTE, sourcelabel ) == false ) {
    return TrigFeatureLink();
  }
  // remove following after testing
  if ( features_access_helpers.size() > 1 ) {
    ATH_MSG_WARNING("getFeature: logic error, got: " << features_access_helpers.size() <<  " features from: getFeatureAccessors" );
  }
 
  if ( features_access_helpers.empty() )
    return TrigFeatureLink();
 
  const TriggerElement::ObjectIndex& oindex = features_access_helpers.at(0).getIndex();
  typename C::const_iterator lookup = std::find(container->begin(), container->end(),obj);
  if ( lookup == container->end() )
    return TrigFeatureLink();
 
  const unsigned offset =  lookup - container->begin();
  return TrigFeatureLink(ClassID_traits<C>::ID(), oindex.subTypeIndex(), oindex.objectsBegin()+offset);
 
}
 
 
#endif