Holder.icc

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#include <iterator>
#include <type_traits>
 
#include "GaudiKernel/MsgStream.h"
 
#include "AthenaBaseComps/AthMsgStreamMacros.h"
#include "TrigNavigation/TypeMaps.h"
#include "TrigNavStructure/BaseHolder.h"
 
#ifndef TrigNavigation_Holder_icc
#define TrigNavigation_Holder_icc
 
#define HOLDERLOG(logger,x)   if (logger->msgLvl(MSG::x)) logger->msg() << MSG::x
 
/*
template<class T>
std::string type_real_name() {
  std::string name(__PRETTY_FUNCTION__);   
  size_t op = name.find('=');
  size_t cl = name.find(']');
  return name.substr(op+1, cl-op-1);
}
*/
 
/////////////////////////////////////////////////////////////////////////////
// T is for objects, C for container for this objects
template<class STORED>
HLTNavDetails::Holder<STORED>::Holder() {
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED>
HLTNavDetails::Holder<STORED>::Holder(const std::string& prefix, const std::string& label, uint16_t idx) :
  IHolder(prefix, label, idx)
{
}
 
 
/////////////////////////////////////////////////////////////////////////////
namespace HLTNavDetails {
template<class STORED>
Holder<STORED>::~Holder() {
}
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, bool> struct createTemporary;
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED> 
struct createTemporary<STORED, true>
{
  static STORED* do_it() { 
    STORED *s = new STORED;
    s->clear(SG::VIEW_ELEMENTS);
    return s; 
  }
}; 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED> 
struct createTemporary<STORED, false>
{
  static STORED* do_it() { 
    return 0;
  }
}; 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED> 
template<class CONTAINER2> 
bool HLTNavDetails::Holder<STORED>::get( ElementLinkVector<CONTAINER2>& el, HLT::TriggerElement::ObjectIndex idx) {
  return static_cast<HolderImp<STORED, CONTAINER2>* >(this)->getElementLinks(el, idx);
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED> 
template<class CONTAINER2> 
bool HLTNavDetails::Holder<STORED>::get( ElementLinkVector<CONTAINER2>& el ) {
  return static_cast<HolderImp<STORED, CONTAINER2>* >(this)->getElementLinks(el);
}
 
 
/////////////////////////////////////////////////////////////////////////////
// Implementation
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLTNavDetails::HolderImp<STORED, CONTAINER>::HolderImp() 
  : Holder<STORED>() {
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLTNavDetails::HolderImp<STORED, CONTAINER>::HolderImp(const std::string& prefix, const std::string& label, uint16_t idx) 
  : Holder<STORED>(prefix, label, idx),
    m_key (formatSGkey(prefix, ClassID_traits<CONTAINER>::typeName(), label))
{
}
 
/////////////////////////////////////////////////////////////////////////////
namespace HLTNavDetails {
template<class STORED, class CONTAINER>
HolderImp<STORED, CONTAINER>::~HolderImp() {  
  //typedef Holder<STORED> H;
  // Don't touch m_log here --- if we're running global dtors, then
  // it may have already been deleted.
  m_memMgr.clear();
}
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLTNavDetails::IHolder* HLTNavDetails::HolderImp<STORED, CONTAINER>::clone(const std::string& prefix, const std::string& label, uint16_t idx ) const {
  //typedef Holder<STORED> H;
  if ( not m_containerProxy.empty() ) {
    return 0;
  }
  HolderImp<STORED, CONTAINER> *imp = new HolderImp<STORED, CONTAINER>(prefix, label, idx);
  IHolder *h        = imp;
  return h;
}
 
template<class AUX>
struct auxCLIDOrZero {
  static CLID get() {
    return ClassID_traits<AUX>::ID();
  }
  static std::string getName() {
    return ClassID_traits<AUX>::typeName();    
  }
};
template<>
struct auxCLIDOrZero<HLT::TypeInformation::no_aux> {
  static CLID get() { 
    return 0;
  }
  static std::string getName() {
    return std::string("no_aux");    
  }
};
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER> 
CLID  HLTNavDetails::HolderImp<STORED, CONTAINER>::auxClidOrZero() const {
  return auxCLIDOrZero<typename Container2Aux<CONTAINER>::type>::get();
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER> 
void  HLTNavDetails::HolderImp<STORED, CONTAINER>::prepare(const asg::AsgMessaging& logger, HLT::AccessProxy* sg, IConversionSvc* conversionSvc, bool readonly){
  typedef Holder<STORED> H;
  IHolder::prepare(logger,sg,conversionSvc,readonly);
  CLID auxCLID = auxCLIDOrZero<typename Container2Aux<CONTAINER>::type>::get();
  if ( auxCLID ) {
 
    if(H::m_readonly){
      ATH_MSG_INFO("HolderImp::prepare using a read-only proxy for aux store");
      H::m_aux = new TypelessAuxProxy();
    }
    else{
 
      const auto itr = HLT::TypeMaps::proxies().find(auxCLID);
      if ( itr == HLT::TypeMaps::proxies().end() ) {
        ATH_MSG_ERROR("HolderImp::prepare can not find Aux store proxy " << *this);
        return;
      }
      
      H::m_aux = itr->second->clone();
      if ( H::m_aux == 0 ) {
        ATH_MSG_ERROR("HolderImp::prepare can not clone Aux store proxy " << *this);
      }
      ATH_MSG_VERBOSE("HolderImp::prepare proxy toAux store ready decorating");
    }
  }
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER> 
bool  HLTNavDetails::HolderImp<STORED, CONTAINER>::syncWithSG(SG::OwnershipPolicy policy) {
  ATH_MSG_DEBUG("HolderImp::syncWithSG policy " << policy);
  typedef Holder<STORED> H;
  if ( !H::m_storeGate ) {    
    ATH_MSG_WARNING("HolderImp::syncWithSG no SG available " << *this);
    return false;
  }
  ATH_MSG_VERBOSE("HolderImp::syncWithSG syncing holder with SG " << *this);
 
  const std::string auxkey = key()+"Aux.";
  ATH_MSG_VERBOSE("HolderImp::syncWithSG looking in SG for key " << key() << " possible aux should have " << auxkey);
 
  const bool transientInSG ( m_containerProxy.transientContains(H::m_storeGate, key() ) );
  const bool persistentThroughSG ( m_containerProxy.contains(H::m_storeGate, key() ) );
  if (  transientInSG or persistentThroughSG ) {
    ATH_MSG_VERBOSE("HolderImp::syncWithSG objects "
                    << ( transientInSG ?  "already in" : "available through" )
                    << " SG, syncing to them " << *this);
    
 
    if ( m_containerProxy.sync( H::m_storeGate, key()).isFailure() )  {
      ATH_MSG_WARNING("HolderImp::syncWithSG objects already in SG, however failed syncing (SG::retrieve) to them " << *this);
      return false;
    }
    if( m_containerProxy.data()->ownPolicy() != SG::VIEW_ELEMENTS && H::m_aux && H::m_aux->sync(H::m_storeGate,auxkey).isFailure()){
      ATH_MSG_WARNING("HolderImp::syncWithSG objects already in SG, however failed syncing (SG::retrieve) to aux store " << *this);
      return false;      
    };
    
 
  } else { // SG is empty, we need to put the obj into it
    ATH_MSG_VERBOSE("HolderImp::syncWithSG objects not in SG, adding them to SG " << *this);
    if (  m_containerProxy.create().isFailure() )  {
      ATH_MSG_WARNING("HolderImp::syncWithSG can not create container " << *this);
      return false;
    }
 
    auto defaultPolicy = m_containerProxy.data()->ownPolicy();
    m_containerProxy.data()->clear( defaultPolicy == SG::VIEW_ELEMENTS ? SG::VIEW_ELEMENTS : policy);
 
    
    CLID auxCLID = auxCLIDOrZero<typename Container2Aux<CONTAINER>::type>::get();
    if ( auxCLID and policy != SG::VIEW_ELEMENTS ) {
      if ( H::m_aux == 0 ) {
        ATH_MSG_ERROR("HolderImp::syncWithSG can not clone Aux store proxy " << *this);
        return false;
      }
      
      ATH_MSG_VERBOSE("HolderImp::syncWithSG proxy toAux store ready decorating");
 
      if( H::m_aux->create().isFailure() ) {
        ATH_MSG_WARNING("HolderImp::syncWithSG can not create Aux store for container " << *this);
        return false;
      }
 
      if( H::m_aux->reg(H::m_storeGate,auxkey).isFailure() ) {
        ATH_MSG_WARNING("HolderImp::syncWithSG can not register Aux store for container in SG " << *this);
        return false;
      }
 
      SG::AuxVectorBase* container = m_containerProxy.castAuxVectorBase();
      SG::IAuxStore* aux = H::m_aux->castIAuxStore();
      if ( container and aux ) {
        ATH_MSG_DEBUG("HolderImp::syncWithSG Aux sotore configured for " << *this);
        container->setStore(aux);
      } else {
        ATH_MSG_WARNING("HolderImp::syncWithSG type configured to have Aux store but no appropriate Aux interfaces are implemented AuxVectorBase for container: "
                       << container << " IAuxStore for Aux sotore: " << aux <<  " "<<  *this);
        return false;   
      }
    } 
    
    if ( m_containerProxy.reg( H::m_storeGate, key()).isFailure() ) {
       ATH_MSG_ERROR("HolderImp::syncWithSG recording collection failed " << *this);
      return false;   
    }
  }  
 
  return true;   
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER> 
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::checkAndSetOwnership(SG::OwnershipPolicy policy) {
  if ( m_containerProxy.empty() ) 
    return false;
 
  if ( m_containerProxy.data()->empty() ) {
    m_containerProxy.data()->clear(policy);
    return true;
  } 
  
  if ( m_containerProxy.data()->ownPolicy() == policy )
    return true;
 
  return false;
}
/////////////////////////////////////////////////////////////////////////////
template<class CONTAINER, bool b> 
struct transferBetweenContainers;
 
 
// case when the containers can be transfered
template <class CONTAINER> 
struct transferBetweenContainers<CONTAINER, true> {
  static void do_it(CONTAINER *source, CONTAINER* dest, const asg::AsgMessaging*) {
    dest->insertMove (dest->end(), *source);
  }
};
 
/////////////////////////////////////////////////////////////////////////////
// case when the containers CAN NOT be transfered
template <class CONTAINER> 
struct transferBetweenContainers<CONTAINER, false> {
  static void do_it(CONTAINER *, CONTAINER*, const asg::AsgMessaging*) {
    throw std::runtime_error
      ("TrigNavigation: Tried to attach an owning container of type " +
       ClassName<CONTAINER>::name() +
       "; only view containers of this type are supported.");    
  }
};
 
/////////////////////////////////////////////////////////////////////////////
// code below checks if the transfer of elements between the two OWNING containers can happen
// It is based on the check of the type returned by the iterator i.e. if the reference is const or not const (i.e. assignable)
//
template<class CONTAINER> 
struct canTransfer {  
  const static bool value = std::is_assignable<typename CONTAINER::iterator::reference,
                           typename CONTAINER::iterator::value_type>::value;
};
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER, bool b> struct insert;
 
/////////////////////////////////////////////////////////////////////////////
// implementation if stored and container are the same
// this version is suggested by Attila, it has several advantages
// 1) the source container is useable after the insertion (important for the monitoring)
// 2) ownership of objects is greately simplified (i.e. the event-wise container always own objects,
//    the roi-wise containers always view objects
//
template <class STORED, class CONTAINER>
struct insert<STORED, CONTAINER, true>{
  static bool do_it(STORED *source, CONTAINER* dest, bool /*hasAux*/, const asg::AsgMessaging* log) {
 
    HOLDERLOG(log, VERBOSE ) << "insert::do_it CONTAINER " << ClassID_traits<STORED>::typeName() << endmsg;
    HOLDERLOG(log, VERBOSE ) << "Destination is " << (dest->ownPolicy() == SG::VIEW_ELEMENTS ? "VIEW" : "OWN")
            << " source is " << (source->ownPolicy() == SG::VIEW_ELEMENTS ? "VIEW" : "OWN")  << endmsg;
 
    // From Scott
    // - Input container is owning.  Output container should also be owning;
    //   ownership should be transferred from input to output container.
 
    // - Input is a view container and doesn't track indices
    //   (trackIndices() is false).  Output should be a view container.
    //   Aux data are not transferred in this case.
 
    // - Input is a view container that does track indices
    //   (trackIndices() is true).  Output should be a view container
    //   with ALWAYS_TRACK_INDICES.  Aux data are transferred in this case.
    //   (I don't think trigger will see this case.)
 
 
    if ( dest->empty() ) { // empty destination, we can do adaptations
      if ( source->ownPolicy() == SG::OWN_ELEMENTS ) {
    dest->clear( SG::OWN_ELEMENTS );
      }
 
      if ( source->ownPolicy() == SG::VIEW_ELEMENTS and source->trackIndices() == false ) {
    HOLDERLOG(log, VERBOSE ) << "insert::do_it destination container made a VIEW"    << endmsg;
    dest->setStore(static_cast<SG::IAuxStore*>(nullptr));
    dest->clear( SG::VIEW_ELEMENTS);
      }
 
      if ( source->ownPolicy() == SG::VIEW_ELEMENTS and source->trackIndices() == true ) {
    HOLDERLOG(log, VERBOSE ) << "insert::do_it destination container made a VIEW wiht indices tracking "    << endmsg;
    // it should be like this but I can not implemnt it like this because many container do not implement second arg dest->clear( SG::VIEW_ELEMENTS, SG::ALWAYS_TRACK_INDICES );
    dest->clear( SG::VIEW_ELEMENTS );
      }
    }
    if ( source->ownPolicy() != dest->ownPolicy() ) {  // a simple check if in case of nonempty container we are dooing consistent insertion
      HOLDERLOG(log, WARNING ) << "insert::do_it objects can not be inserted because of ownership issues. "
              << "Destination container has already " << dest->size() << " objects "
              <<  " and ownership policy "
              << (dest->ownPolicy() == SG::OWN_ELEMENTS ? "OWN" : "")  // this is dumb code but who knows what other policies will be implemented in the future
              << (dest->ownPolicy() == SG::VIEW_ELEMENTS ? "VIEW" : "")
              << " no action is performed, potential memory leak"    << endmsg;
      return false;
    }
 
 
    if ( source->ownPolicy() == SG::VIEW_ELEMENTS ) {
      dest->insert(dest->end(), source->begin(), source->end());
      HOLDERLOG(log, VERBOSE ) << "insert::do_it objects copied, conversion to view container not needed"    << endmsg;
    } else {
      // We have an owning container.  Transfer the element ownership
      // from SOURCE to DEST.  We can only do this if the container
      // has modifiable iterators.  For containers with non-modifiable
      // iterators (like CaloTowerContainer), we throw an exception.
      // Such containers should be added only as view containers.
      transferBetweenContainers<CONTAINER, canTransfer<CONTAINER>::value>
    ::do_it(source, dest, log);
    }
    return true;
  }
};
 
 
 
/////////////////////////////////////////////////////////////////////////////
// implementation if stored and container are distinct
template <class STORED, class CONTAINER> 
struct insert <STORED, CONTAINER, false>{
  static bool do_it(STORED *s, CONTAINER* dest, bool /*hasAux*/, const asg::AsgMessaging*) {
    dest->push_back(s);
    return true;
  }
};
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER, bool b> struct remap;
template<class STORED, class CONTAINER> 
struct remap<STORED, CONTAINER, false> {
  static void do_it(const std::string&, const std::string&, STORED *, CONTAINER*, HLT::AccessProxy*, const asg::AsgMessaging*) {
    
  }
};
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
struct remap<STORED, CONTAINER, true> {
  static void do_it(const std::string& storedkey , const std::string& contkey, STORED *s, CONTAINER* cont, HLT::AccessProxy *sg,  const asg::AsgMessaging* log ) {
    std::string skey = storedkey;
    if ( storedkey == "" ) {
      // we can't do it
      HOLDERLOG(log, VERBOSE) << "HolderImp::remap trying to discover object key, this is potentially slow and should be avoided, type: "  << ClassID_traits<STORED>::typeName() << " from: " << s << " to: " << cont  << endmsg;
      SG::DataProxy* px = sg->proxy((void const* )s);
      if ( !px ) {
        HOLDERLOG(log, WARNING) << "HolderImp::remap When remaping containers found no proxy for the object" << s << " of type " << ClassID_traits<STORED>::typeName()  << endmsg;
        return;
      }
      if ( !px->isValid() ) {
        HOLDERLOG(log, WARNING) << "HolderImp::remap When remaping containers found no valid proxy for the object" << s << " of type " << ClassID_traits<STORED>::typeName()  << endmsg;
        return;
      }
      skey = px->name();
    }
    HOLDERLOG(log, VERBOSE) << "HolderImp::remap remapping collections of type: " << ClassID_traits<STORED>::typeName()
                            << " from: " << skey << " to: " << contkey << " while destination container size is: " <<  cont->size() << endmsg;
    sg->remap(ClassID_traits<CONTAINER>::ID(), skey, contkey, cont->size());
  }
};
 
template<class STORED, class CONTAINER, bool>
struct destinationOwnPolicy {};
 
template<class STORED, class CONTAINER>
struct destinationOwnPolicy<STORED, CONTAINER, false> {
  static SG::OwnershipPolicy get(const STORED* /*source*/) {
    return SG::OWN_ELEMENTS;
  }
};
 
template<class STORED, class CONTAINER>
struct destinationOwnPolicy<STORED, CONTAINER, true> {
  static SG::OwnershipPolicy get(const STORED* source) {
    if ( source->ownPolicy() == SG::VIEW_ELEMENTS )
      return SG::VIEW_ELEMENTS;
    return SG::OWN_ELEMENTS;
  }
};
 
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLT::TriggerElement::ObjectIndex HLTNavDetails::HolderImp<STORED, CONTAINER>::add ATLAS_NOT_THREAD_SAFE ( const STORED* f_in, bool inSG, const std::string& sgKey ) {
  // FIXME:
  // If insertMove is used, then the pointer being recorded cannot be const.
  // Taking this object by const is anyway wrong because it will be modified
  // (unless it's a view container).
  STORED* f = const_cast<STORED*>(f_in);
  typedef Holder<STORED> H;
  
  if ( ! syncWithSG( destinationOwnPolicy<STORED, CONTAINER, std::is_same<STORED, CONTAINER>::value>::get(f) ) )
    return HLT::TriggerElement::ObjectIndex();
 
  uint32_t bidx = m_containerProxy.data()->size();
 
  bool wasRecorded = false;
  std::string thiskey(sgKey);
  if ( !inSG && std::is_same<STORED, CONTAINER>::value ) { // conditions to place partial containers in SG 
    thiskey  = this->getUniqueKey();
    if ( H::m_storeGate->record(f, thiskey).isFailure()  ) {
      ATH_MSG_WARNING("HolderImp::add object " <<  f << "and sgKey:" << thiskey << " intended for holder" << *this << " can't be placed directly in SG");
    } else {
      inSG = true;
      wasRecorded = true;
      ATH_MSG_VERBOSE("HolderImp::add feature SG direct registration succesful with the key:" << thiskey);
    }
  }
 
  if ( inSG ) { //conditions to add remapping
    remap<STORED, CONTAINER,  
      std::is_same<STORED, CONTAINER>::value>::do_it (thiskey, key(), f, m_containerProxy.data(), H::m_storeGate, H::m_logger);
  }
 
  bool insertStatus = insert<STORED, CONTAINER, std::is_same<STORED, CONTAINER>::value>
    ::do_it (f, m_containerProxy.data(), H::m_aux != 0, H::m_logger);
  if ( insertStatus == false ) {
    ATH_MSG_WARNING("HolderImp::add  insert failed " );
    return  HLT::TriggerElement::ObjectIndex();
  }
 
  uint32_t eidx = m_containerProxy.data()->size();
  ATH_MSG_VERBOSE("HolderImp::add added object(s) to the container, size increase from : " << bidx << " to: " << eidx);
  HLT::TriggerElement::ObjectIndex objIdx (H::subTypeIndex(), bidx, eidx );
 
  m_memMgr.insert(std::make_pair(objIdx, MemoryMgr(f, inSG||m_containerProxy.data()->ownPolicy() == SG::OWN_ELEMENTS)));
 
  if ( wasRecorded ) {
    if ( H::m_storeGate->setConst(f).isFailure()  ) {
      ATH_MSG_WARNING("HolderImp::add  setConst failed " );
    }
  }
  
  return objIdx;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER, bool b> struct retrieve;
 
/////////////////////////////////////////////////////////////////////////////
// implementation if stored and container are the same
template <class STORED, class CONTAINER> 
struct retrieve<STORED, CONTAINER, true>{
  static bool do_it(const STORED*& dest, CONTAINER* src, HLT::TriggerElement::ObjectIndex idx) {
    // find 2 iterators
    if ( src->size() < idx.objectsBegin() || src->size() < idx.objectsEnd()) {
      REPORT_MESSAGE_WITH_CONTEXT(MSG::VERBOSE,"Holder") << "either begin index or end index is larger than size";
      REPORT_MESSAGE_WITH_CONTEXT(MSG::VERBOSE,"Holder") << "size: " << src->size() << " begin: " << idx.objectsBegin() << " end: " << idx.objectsEnd();
      dest = 0;
      return false;
    }
    dest = createTemporary<STORED, std::is_same<STORED, CONTAINER>::value>::do_it(); 
    typename CONTAINER::iterator beg = src->begin(); 
    typename CONTAINER::iterator end = src->begin(); 
    std::advance(beg, idx.objectsBegin());
    std::advance(end, idx.objectsEnd());
 
    // get(Feature) should really not be taking a const reference for the case
    // where STORED!=CONTAINER as we do have to modify the destination. But the
    // user is responsible for not filling the same container concurrently anyway.
    auto nonconst_dest ATLAS_THREAD_SAFE = const_cast<STORED*&>(dest);
    nonconst_dest->insert(nonconst_dest->end(), beg, end);
    return true;
  }
};
 
/////////////////////////////////////////////////////////////////////////////
// implementation if stored and container are distinct
template <class STORED, class CONTAINER> 
struct retrieve <STORED, CONTAINER, false>{
  static bool do_it(const STORED*& dest, CONTAINER* src, HLT::TriggerElement::ObjectIndex idx) {
 
    if (idx.objectsBegin() <  (*src).size()) {
      dest = src->at(idx.objectsBegin());
      return true;
    } else {
      dest = 0;
      return false;
    }
  }
};
 
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::getWithLink(typename set_link<STORED,CONTAINER,std::is_same<STORED,CONTAINER>::value>::type& link,
                 HLT::TriggerElement::ObjectIndex& idx) {
 
   const STORED* dest = 0;
   bool result = this->get(dest,idx);
   if(!result) return false;
 
   link = set_link<STORED,CONTAINER,std::is_same<STORED,CONTAINER>::value>::do_it(dest,m_containerProxy.data(),idx);
   return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::get(const STORED*& dest, HLT::TriggerElement::ObjectIndex idx) {
  typedef Holder<STORED> H;
  if ( !syncWithSG() )
    return false;
 
 
  ATH_MSG_VERBOSE("HolderImp::get getting object(s) from Holder" << *this);
  typename MemoryMgrMap::const_iterator cache;
  if ( (cache = m_memMgr.find(idx)) != m_memMgr.end() ) {
    ATH_MSG_DEBUG("HolderImp::get object found in the cache with address " << idx);
    dest = cache->second.proxy.data();
    return true;
  }
  else{
    ATH_MSG_VERBOSE("HolderImp::get getting object from primary collection " << idx);
  }
 
  if ( ! retrieve<STORED, CONTAINER,  // short circuited .. retrieve will not run if in cache
          std::is_same<STORED, CONTAINER>::value>::
       do_it (dest, m_containerProxy.data(), idx) ) {
    ATH_MSG_WARNING("HolderImp::get getting chunk of the container failed for Holder: " << *this
           << " index: " << idx);
    return false;
  }
      
  if ( std::is_same<STORED, CONTAINER>::value ) { // temporary view containers in SG and cache filling
 
    // We don't have an implementation of FeatureProxy that takes a const reference.
    // But this should be safe (modulo the comments in the do_it method above).
    auto nonconst_dest ATLAS_THREAD_SAFE = const_cast<STORED*&>(dest);
    FeatureProxy tempProxy( nonconst_dest );
    
    m_memMgr.insert(std::make_pair(idx, MemoryMgr(tempProxy, true)));    // store it in the cache for futher uses
    
    std::string sgKey = this->generateAliasKey(this->typeClid(), this->subTypeIndex(), this->label(), 0xffffffff );
 
    if ( tempProxy.reg(H::m_storeGate, sgKey).isFailure() ) {
      ATH_MSG_WARNING("HolderImp::get for some reason object can't be placed in SG, key:" << sgKey);
      return false;
    }
    remap<STORED, CONTAINER, 
      std::is_same<STORED, CONTAINER>::value>::do_it (sgKey, key(), tempProxy.data(), m_containerProxy.data(), H::m_storeGate, H::m_logger);
    ATH_MSG_VERBOSE("Added view collection to SG with defined EL remapping to event-wide colection, key: " << sgKey);
  }
  return true;
}
 
 
/////////////////////////////////////////////////////////////////////////////
// check if objects in obj are in the container 
template<class STORED, class CONTAINER, bool b> struct isin;
 
/////////////////////////////////////////////////////////////////////////////
// check if the container obj is a subcontainer of cont 
template <class STORED, class CONTAINER> 
struct isin<STORED, CONTAINER, true> {
  static bool do_it(const STORED* obj, const CONTAINER* cont, const asg::AsgMessaging*, uint32_t& begin, uint32_t& end) {
    typename CONTAINER::const_iterator it =  std::search(cont->begin(), cont->end(), obj->begin(), obj->end());
    if ( it == cont->end() ) {
      return false;
    }
    begin = it - cont->begin();
    end = begin + obj->size();
    return true;
  }
};
 
/////////////////////////////////////////////////////////////////////////////
// check if the obj is in a container cont
template <class STORED, class CONTAINER> 
struct isin<STORED, CONTAINER, false> {
  static bool do_it(const STORED* obj, const CONTAINER* cont, const asg::AsgMessaging*, uint32_t& begin, uint32_t& end) {
    typename CONTAINER::const_iterator it = std::find(cont->begin(), cont->end(), obj);
    if ( it == cont->end() ) {
      return false;
    } 
    begin = it - cont->begin();
    end = begin+1;
    
    return true;
  }
};
 
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::contains(const STORED* obj, HLT::TriggerElement::ObjectIndex& idx) {
  typedef Holder<STORED> H;
  if ( !syncWithSG() )
    return false;
 
  ATH_MSG_VERBOSE("HolderImp::contains");
  uint32_t begin=0;
  uint32_t end=0;
  bool ok = isin<STORED, CONTAINER, 
         std::is_same<STORED, CONTAINER>::value>::do_it (obj, m_containerProxy.data(), H::m_logger, begin, end);
  if ( !ok ) {
    ATH_MSG_VERBOSE("HolderImp::contains object " << obj << " not in the holder" << *this );
    return false;
  }
  idx = HLT::TriggerElement::ObjectIndex(H::subTypeIndex(),begin,end);
  ATH_MSG_VERBOSE("HolderImp::contains object " << obj << " found by in holder" << *this << " " << idx);
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::getElementLinks(ElementLinkVector<CONTAINER>& cont,  
                                  HLT::TriggerElement::ObjectIndex idx) {
  //typedef Holder<STORED> H;
  if ( !syncWithSG() )
    return false;
 
  ATH_MSG_VERBOSE("HolderImp::getElementLinks(ELV, Index) getting objects");
  for (unsigned i = idx.objectsBegin(); i != idx.objectsEnd(); ++i ){
    cont.push_back(ElementLink<CONTAINER>(*(m_containerProxy.data()), i));
  }
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::getElementLinks(ElementLinkVector<CONTAINER>& cont) {
 
  //typedef Holder<STORED> H;
  if ( !syncWithSG() )
    return false;
  ATH_MSG_VERBOSE("HolderImp::getElementLinks (ELV) getting all objects");
  for (unsigned i = 0; i < m_containerProxy.data()->size(); ++i ){
    cont.push_back(ElementLink<CONTAINER>(*(m_containerProxy.data()), i));
  }
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
std::string HLTNavDetails::HolderImp<STORED, CONTAINER>::getUniqueKey() {
  ATH_MSG_VERBOSE("HolderImp::getUniqueKey");
  if ( !syncWithSG() )
    return "Bad_Key";
  return IHolder::generateAliasKey( this->typeClid(), this->subTypeIndex(), this->label(),
                    m_containerProxy.data()->size() );
}
 
template<class STORED, class CONTAINER>
std::string HLTNavDetails::HolderImp<STORED, CONTAINER>::getNextKey() {
  ATH_MSG_VERBOSE("HolderImp::getNextKey");
  return getUniqueKey();
}
 
 
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::serialize(std::vector<uint32_t>& output) const {
  typedef Holder<STORED> H; // this is to make things below shorter
  
  ATH_MSG_VERBOSE("HolderImp::serialize " << *this);
  // if feature to be forgotten then indication of it is simply 0 size of serialized vector
  H::serialize(output);
  
  return true;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
void HLTNavDetails::HolderImp<STORED, CONTAINER>::print(MsgStream& m) const {
  IHolder::print(m);
  if ( not m_containerProxy.empty() )
    m << " size: " << m_containerProxy.data()->size() << " @"<<m_containerProxy.data();
  else
    m << " container not allocated yet";
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
DataObject* HLTNavDetails::HolderImp<STORED, CONTAINER>::getDataObject() {
  if(!m_containerProxy.data()) return 0;
  return SG::asStorable(m_containerProxy.data());
}
 
#define _IS_AUXTYPE_ !std::is_same<typename Container2Aux<T>::type,HLT::TypeInformation::no_aux>::value
 
struct AuxDataObjectHelper{
  template<typename T>
  static typename std::enable_if<!_IS_AUXTYPE_,DataObject*>::type get(HLTNavDetails::ITypeProxy*/* aux*/){
    return 0;
  }
  template<typename T>
  static typename std::enable_if<_IS_AUXTYPE_,DataObject*>::type get(HLTNavDetails::ITypeProxy* aux){
    typedef typename Container2Aux<T>::type auxtype;
    HLTNavDetails::TypeProxy<auxtype>* auxcasted = static_cast<HLTNavDetails::TypeProxy<auxtype>*>(aux);
    if(auxcasted){
      if(!auxcasted->data()) return 0;
      return SG::asStorable(auxcasted->data());
    }
    return 0;
  }
  template<typename T>
  static typename std::enable_if<!_IS_AUXTYPE_,bool>::type set(HLTNavDetails::ITypeProxy*,DataObject*){
    return true;//always success
  }
  template<typename T>
  static typename std::enable_if<_IS_AUXTYPE_,bool>::type set(HLTNavDetails::ITypeProxy* aux, DataObject* dobjaux){
    typedef typename Container2Aux<T>::type auxtype;
    HLTNavDetails::TypeProxy<auxtype>* auxcasted = static_cast<HLTNavDetails::TypeProxy<auxtype>*>(aux);
    if(auxcasted){      
      bool success = SG::fromStorable(dobjaux,auxcasted->data_ref());
      auxcasted->syncTypeless();
      REPORT_MESSAGE_WITH_CONTEXT(MSG::VERBOSE,"Holder") << "set from storable " << success << " to address " << auxcasted->data() << std::endl;
      return success;
    }
    return 0;
  }
};
 
template<class STORED, class CONTAINER>
DataObject* HLTNavDetails::HolderImp<STORED, CONTAINER>::getAuxDataObject() {
  return AuxDataObjectHelper::get<CONTAINER>(this->m_aux);
}
 
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::setAuxDataObject(DataObject* dobjaux) {
  bool status =  AuxDataObjectHelper::set<CONTAINER>(this->m_aux,dobjaux);
  ATH_MSG_VERBOSE("container data is: " << m_containerProxy.data());
  SG::AuxVectorBase* container = m_containerProxy.castAuxVectorBase();
  if(!this->m_aux or !container){
    ATH_MSG_ERROR("in aux branch but aux type proxy or container proxy is null");
    ATH_MSG_ERROR("container is: " << container);
    ATH_MSG_ERROR("aux is: " << this->m_aux);
    return false;
  }
  SG::IAuxStore* aux = this->m_aux->castIAuxStore();
  if(!aux){
    ATH_MSG_ERROR("cast of auxstore failed");
  }
  if(container and aux and status){
    ATH_MSG_VERBOSE("container is: " << container);
    ATH_MSG_VERBOSE("aux is: " << this->m_aux);
    container->setStore(aux);
    return true;
  }
  ATH_MSG_WARNING("something went wrong setting aux data object");
  return false;
}
 
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
bool HLTNavDetails::HolderImp<STORED, CONTAINER>::setDataObject(DataObject* dobj) {
  bool success = SG::fromStorable(dobj, m_containerProxy.data_ref());
  m_containerProxy.syncTypeless();
  REPORT_MESSAGE_WITH_CONTEXT(MSG::VERBOSE,"Holder") << "set from storable " << success << " to address " << m_containerProxy.data();
  return success;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLTNavDetails::HolderImp<STORED, CONTAINER>::MemoryMgr::MemoryMgr(const FeatureProxy& st, bool sg)
  : proxy(st), inSG(sg)
{}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
HLTNavDetails::HolderImp<STORED, CONTAINER>::MemoryMgr::MemoryMgr()
  :  inSG(false)
{}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
void HLTNavDetails::HolderImp<STORED, CONTAINER>::MemoryMgr::clear() {
  // if the thing is not in SG it shoudl not be cleared, if is the SG will take care of it if ( !inSG )   proxy.clear();
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED>
MsgStream& HLTNavDetails::operator<< ( MsgStream& m, const HLTNavDetails::Holder<STORED>& h ) {
  h.print(m);
  return m;
}
 
/////////////////////////////////////////////////////////////////////////////
template<class STORED, class CONTAINER>
MsgStream& HLTNavDetails::operator<< ( MsgStream& m, const HLTNavDetails::HolderImp<STORED, CONTAINER>& h ) {
  h.print(m);
  return m;
}
 
#endif