TypedHolder.h

Go to the documentation of this file.

// Emacs -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGNAVSTRUCTURE_TYPEDHOLDER_H
#define TRIGNAVSTRUCTURE_TYPEDHOLDER_H
 
//#include <stdexcept>
#include <type_traits>
 
#include "TrigNavStructure/TypelessHolder.h"
#include "TrigNavStructure/TriggerElement.h"
 
#include "AthContainers/OwnershipPolicy.h"
 
#ifdef XAOD_STANDALONE
#include "xAODCore/ClassID_traits.h"  //guarded b/c athena includes its own
#include "AsgTools/SgTEvent.h"
#else
#include "StoreGate/StoreGateSvc.h"
#endif
 
#include "AsgMessaging/AsgMessaging.h"
#include "AsgTools/EventStoreType.h"
 
//forward declarations
class TrigRoiDescriptor;
class TrigRoiDescriptorCollection;
 
namespace HLTNavDetails{
  std::string formatSGkey(const std::string& prefix, const std::string& containername, const std::string& label);
}
 
namespace HLT{
 
 
  template<typename FEATURE, typename CONTAINER> class TypedHolder;
 
 
  template<>
  class TypedHolder<TrigRoiDescriptor,TrigRoiDescriptorCollection>;
  
  template<typename FEATURE, typename CONTAINER>
  class TypedHolder : public TypelessHolder, public asg::AsgMessaging {
  public:
    template<typename T,bool value> using StatusCode_if = typename std::enable_if<std::is_same<T,CONTAINER>::value == value,StatusCode>::type;
 
    TypedHolder(const BaseHolder& baseholder, const asg::EventStoreType* store, const std::string& container_name = ClassID_traits<CONTAINER>::typeName())
      : TypelessHolder(baseholder.typeClid(),baseholder.label(),baseholder.subTypeIndex()), 
    asg::AsgMessaging("TypedHolder"),
    m_store(store),
    m_cont(0) {
      //      if(!clidCheck<FEATURE>())
      //throw std::runtime_error("attempted construction with CLID mismatch! Check template parameter and passed typeless holder");
      m_key = HLTNavDetails::formatSGkey("HLT",container_name,this->label());
    }
    
    TypedHolder(const TypelessHolder& typeless, const asg::EventStoreType* store, const std::string& container_name = ClassID_traits<CONTAINER>::typeName())
      : TypelessHolder(typeless),
    asg::AsgMessaging("TypedHolder"),
    m_store(store),
    m_cont(0) {
      //if(!clidCheck<FEATURE>())
      //    throw std::runtime_error("attempted construction with CLID mismatch! Check template parameter and passed typeless holder");
      m_key = HLTNavDetails::formatSGkey("HLT",container_name,this->label());
    }
 
    std::string key() const {return m_key;}
 
    template<typename T> StatusCode_if<T,true> get(const T*& destination, HLT::TriggerElement::ObjectIndex idx){
      if(syncWithStore().isFailure()){
    ATH_MSG_ERROR("accessing holder with key: " << key() << " sync with store failed ");
    return StatusCode::FAILURE;
      }
      if(m_cont->size() < idx.objectsEnd()){
    ATH_MSG_ERROR("accessing holder with key: " << key() << " index past range " << "idx range is: " << idx.objectsBegin() << ":" << idx.objectsEnd() << " container size: " << m_cont->size());
    return StatusCode::FAILURE;
      };
 
      // make sure we get a fresh pointer as were about to set it to a newly created one
      if(destination){
    //ATH_MSG_ERROR("reference pointe provided is already set");
    return StatusCode::FAILURE;
      }
 
      CONTAINER* nonConstDestination = new CONTAINER(SG::VIEW_ELEMENTS);
 
       // need to cast to be able to use non const iterators
      CONTAINER* src = const_cast<CONTAINER*>(m_cont);
      typename CONTAINER::iterator beg = src->begin();
      typename CONTAINER::iterator end = src->begin();
      
      std::advance(beg, idx.objectsBegin());
      std::advance(end, idx.objectsEnd());
      nonConstDestination->insert(nonConstDestination->end(), beg, end);
 
      // from now own we don't want anybody modifying the container
      destination = nonConstDestination;
      return StatusCode::SUCCESS;
    }
 
    template<typename T> StatusCode_if<T,false> get(const T*& destination, HLT::TriggerElement::ObjectIndex idx){
      if((idx.objectsEnd() - idx.objectsBegin())!=1){
    //ATH_MSG_ERROR("accessing holder with key: " << key() << "index is not single element: " << idx.objectsBegin() << ":" << idx.objectsEnd());
    return StatusCode::FAILURE;
      }
      if(syncWithStore().isFailure()){
    //ATH_MSG_ERROR("accessing holder with key: " << key() << " sync with store failed ");
    return StatusCode::FAILURE;
      }
      if(m_cont->size() < idx.objectsBegin()){
    //ATH_MSG_ERROR("accessing holder with key: " << key() << " index past range " << "indexBegin is: " << idx.objectsBegin() << " container size: " << m_cont->size() << std::endl;
    return StatusCode::FAILURE;
      };
 
      //everything went fine
      destination = m_cont->at(idx.objectsBegin());
      return StatusCode::SUCCESS;
    }
 
  private:
 
    StatusCode syncWithStore(){
      if(m_cont) return StatusCode::SUCCESS;
 
      StatusCode sc = m_store->retrieve(m_cont,key());
      
      //sanity checks
      if(sc.isFailure()) return StatusCode::FAILURE;
      if(!m_cont) return StatusCode::FAILURE;
 
      return StatusCode::SUCCESS;
    }
    
    TypedHolder(){;}
    const asg::EventStoreType* m_store = nullptr;
    const CONTAINER* m_cont = nullptr;
    std::string m_key;
  };    
 
}//namespace HLT
 
#endif