CondHandleKey.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthenaKernel/StoreID.h"
#include "GaudiKernel/System.h"
#include <typeinfo>
 
namespace SG {
  
  template <class T>
  CondHandleKey<T>::CondHandleKey(const std::string& key, 
                                  const std::string& dbKey,
                                  Gaudi::DataHandle::Mode mode ) :
    VarHandleKey(ClassID_traits<T>::ID(), key, mode,
                 StoreID::storeName(StoreID::CONDITION_STORE), true),
    m_cs(StoreID::storeName(StoreID::CONDITION_STORE),"CondHandleKey"),
    m_dbKey(dbKey)
  {
    CondCont<T>::registerBaseInit();
  }
 
  //---------------------------------------------------------------------------  
  
  template <class T>
  StatusCode
  CondHandleKey<T>::initialize(bool used /*= true*/) {
    if (m_isInit) return StatusCode::SUCCESS;
    
 
    if (VarHandleKey::initialize(used) != StatusCode::SUCCESS) {
      return StatusCode::FAILURE;
    }
    if (empty()) return StatusCode::SUCCESS;
 
    if (!m_cs.isValid()) {
      MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
      msg << MSG::ERROR 
          << "CondHandleKey::initialize() :Unable to locate ConditionStore " 
          << m_cs.name()
          << endmsg;
      return StatusCode::FAILURE;
    }
 
              
    if (mode() == DataHandle::Writer) {
      if (m_cs->contains< CondCont<T> > (SG::VarHandleKey::key()) ) {
        MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
        msg << MSG::ERROR 
            << StoreID::storeName( StoreID::CONDITION_STORE ) 
            << " already contains a CondCont of type "
            << Gaudi::DataHandle::fullKey() 
            << endmsg;
        return StatusCode::FAILURE;
      } else {
        ServiceHandle<Athena::IRCUSvc> rcusvc ("Athena::RCUSvc", "CondHandleKey");
        m_cc = new CondCont<T>(*rcusvc, Gaudi::DataHandle::fullKey());
        if (m_cs->record(m_cc, SG::VarHandleKey::key()).isFailure()) {
          MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
          msg << MSG::ERROR 
              << "CondHandleKey::init(): unable to record empty CondCont of " 
              << Gaudi::DataHandle::fullKey() << " in " 
              << StoreID::storeName( StoreID::CONDITION_STORE ) 
              << " with key " << SG::VarHandleKey::key() << endmsg;
          delete m_cc;
          m_cc = 0;
          return StatusCode::FAILURE;
        }
      }
    } else {
      // lets see if we get lucky and the Write alg already created the
      // container we want
      if (m_cs->contains< CondCont<T> > (SG::VarHandleKey::key()) ) {
        if (m_cs->retrieve(m_cc, SG::VarHandleKey::key()).isFailure()) {
          MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
          msg << MSG::ERROR 
              << "CondHandleKey::init(): unable to retrieve CondCont of "
              << Gaudi::DataHandle::fullKey() << " from " 
              << StoreID::storeName(StoreID::CONDITION_STORE)
              << " with key " << SG::VarHandleKey::key()
              << endmsg;
          m_cc = 0;
          return StatusCode::FAILURE;
        }
      }
    }
          
 
    m_isInit = true;
 
    return StatusCode::SUCCESS;
 
  }
 
  template <class T>
  StatusCode
  CondHandleKey<T>::initialize(AllowEmptyEnum) {
    if (key().empty()) {
      return StatusCode::SUCCESS;
    }
    return initialize (true);
  }
//---------------------------------------------------------------------------
 
  template <class T>
  const StoreGateSvc*
  CondHandleKey<T>::getCS() const {
    if (!m_cs.isValid()) {
      MsgStream msg(Athena::getMessageSvc(), "CondHandleKey");
      msg << MSG::ERROR 
          << "CondHandleKey::getCS() : Unable to locate ConditionStore" 
          << endmsg;
      return 0;
    }
 
    return m_cs.get();
  }
 
 
//---------------------------------------------------------------------------
 
 
  /**
   * @brief Called by the owning algorithm during the START transition.
   *
   * AthAlgorithm and friends will call this during START.  This allows
   * for extra initialization that we can't do during initialize(), such
   * as retrieving a conditions container from the store.
   */
  template <class T>
  StatusCode CondHandleKey<T>::start()
  {
    if (m_isInit && m_cc == nullptr && mode() == DataHandle::Reader) {
      // Try again to retrieve the conditions container from the store.
      // If this is a conditions object that is read by CondInputLoader,
      // then we will not have found this during initialize(),
      // as CondInputLoader only records the object during start().
      m_cc = m_cs->tryRetrieve< CondCont<T> > (SG::VarHandleKey::key());
    }
    return StatusCode::SUCCESS;
  }
 
 
}