MetaHandleKey.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthenaKernel/StoreID.h"
#include "GaudiKernel/System.h"
#include <typeinfo>
 
namespace SG {
  
  template <class T>
  MetaHandleKey<T>::MetaHandleKey(const std::string& key, 
                                  const std::string& dbKey,
                                  Gaudi::DataHandle::Mode mode ) :
    VarHandleKey(ClassID_traits<T>::ID(), key, mode,
                 StoreID::storeName(StoreID::METADATA_STORE), true),
    m_store(StoreID::storeName(StoreID::METADATA_STORE),"MetaHandleKey"),
    m_dbKey(dbKey)
  {}
 
  //------------------------------------------------------------------------  
  
  template <class T>
  StatusCode
  MetaHandleKey<T>::initialize() {
    if (m_isInit) return StatusCode::SUCCESS;
    
    if (VarHandleKey::initialize() != StatusCode::SUCCESS) {
      return StatusCode::FAILURE;
    }
    if (empty()) return StatusCode::SUCCESS;
    
    MsgStream msg(Athena::getMessageSvc(), "MetaHandleKey");
    if (!m_store.isValid()) {
      msg << MSG::ERROR 
          << "MetaHandleKey::initialize() :Unable to locate MetaDataStore " 
          << m_store.name()
          << endmsg;
      return StatusCode::FAILURE;
    }
 
    if (mode() == DataHandle::Writer) {
      if (m_store->contains< MetaCont<T> > (SG::VarHandleKey::key())) {
    msg << MSG::ERROR
        << StoreID::storeName( StoreID::METADATA_STORE )
        << " already contains a MetaCont of type "
        << Gaudi::DataHandle::fullKey()
        << endmsg;
    return StatusCode::FAILURE;
      }
      else {
    m_cont = new MetaCont<T>();
    if(m_store->record(m_cont,SG::VarHandleKey::key()).isFailure()) {
      msg << MSG::ERROR
          << "MetaHandleKey::init(): unable to record empty MetaCont of "
          << Gaudi::DataHandle::fullKey() << " in "
          << StoreID::storeName( StoreID::METADATA_STORE )
          << " with key " << SG::VarHandleKey::key() << endmsg;
      delete m_cont;
      m_cont = nullptr;
      return StatusCode::FAILURE;
    }
      }
    }
    else {
      // lets see if we get lucky and the Write alg already created the
      // container we want
      if (m_store->contains<MetaCont<T>>(SG::VarHandleKey::key()) ) {
    if (m_store->retrieve(m_cont, SG::VarHandleKey::key()).isFailure()) {
      msg << MSG::ERROR
          << "MetaHandleKey::init(): unable to retrieve MetaCont of "
          << Gaudi::DataHandle::fullKey() << " from "
          << StoreID::storeName(StoreID::METADATA_STORE)
          << " with key " << SG::VarHandleKey::key()
          << endmsg;
      m_cont = 0;
      return StatusCode::FAILURE;
    }
      }
    }
 
/*
    // Retrieve the guid/SID from the data header
    const DataHeader* thisDH;
    ServiceHandle<StoreGateSvc> instore("StoreGateSvc/InputMetaDataStore","MetaHandleKey");
    if (instore.retrieve().isFailure()) return StatusCode::FAILURE;
    if(instore->retrieve(thisDH)!=StatusCode::SUCCESS) {
      msg << MSG::ERROR << "Unable to get DataHeader" << endmsg;
      msg << instore->dump() << endmsg;
      return StatusCode::FAILURE;
    }
    // Get string guid for SourceID
    m_dbKey = thisDH->begin()->getToken()->dbID().toString();
 
    // if you can't get the sid, then this won't work, so fail
    if (m_dbKey.size()==0) {
      msg << MSG::ERROR << "Unable to get source id from dataheader" << endmsg;
      return StatusCode::FAILURE;
    }
*/
    m_isInit = true;
 
    return StatusCode::SUCCESS;
 
  }
 
  //------------------------------------------------------------------------
 
  template <class T>
  StoreGateSvc* 
  MetaHandleKey<T>::getStore() const {
    if (!m_store.isValid()) {
      MsgStream msg(Athena::getMessageSvc(), "MetaHandleKey");
      msg << MSG::ERROR 
          << "MetaHandleKey::getStore() : Unable to locate MetaDataStore" 
          << endmsg;
      return 0;
    }
 
    return m_store.get();
  }
 
 
}