StoreGate/src/VarHandleKey.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "GaudiKernel/DataHandle.h"
#include "GaudiKernel/ToStream.h"
 
#include "StoreGate/VarHandleKey.h"
#include "StoreGate/exceptions.h"
#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/getMessageSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "AthenaKernel/StoreID.h"
 
#include <sstream>
 
constexpr char const storeSeparator = '+';
 
namespace SG {
 

VarHandleKey::VarHandleKey (CLID clid,
                            const std::string& sgkey,
                            Gaudi::DataHandle::Mode a,
                            const std::string& storeName /*= "StoreGateSvc"*/,
                            bool isCond /*= false*/)
  : Gaudi::DataHandle (DataObjID (clid, sgkey), isCond, a),
    m_storeHandle (storeName, "VarHandleKey")
{
  parseKey (sgkey, storeName);
  m_isEventStore =  (m_storeHandle.name() == StoreID::storeName(StoreID::EVENT_STORE) ||
                     m_storeHandle.name() == StoreID::storeName(StoreID::PILEUP_STORE));
}
 

VarHandleKey& VarHandleKey::operator= (const std::string& sgkey)
{
  parseKey (sgkey, m_storeHandle.name());
 
  // Update the hashed key if initialize was already called.
  if (m_hashedKey > 0) m_hashedKey = m_storeHandle->stringToKey (m_sgKey, clid());
 
  return *this;
}
 

StatusCode VarHandleKey::assign (const std::string& sgkey)
{
  try {
    parseKey (sgkey, m_storeHandle.name());
  } catch (SG::ExcBadHandleKey &e) {
    std::println (std::cerr, "VarHandleKey::assign failure: {}", e.what());
    return StatusCode::FAILURE;
  } catch (...) {
    return StatusCode::FAILURE;
  }
 
  // Update the hashed key if initialize was already called.
  if (m_hashedKey > 0) m_hashedKey = m_storeHandle->stringToKey (m_sgKey, clid());
 
  return StatusCode::SUCCESS;
}
 

StatusCode VarHandleKey::initialize (bool used /*= true*/)
{
  if (!used) {
    Gaudi::DataHandle::updateKey ( "" );
    m_sgKey.clear();
    m_hashedKey = 0;
    return StatusCode::SUCCESS;
  }
 
  //  if (Gaudi::DataHandle::objKey() == "") {
  if (key().empty()) {
    REPORT_ERROR (StatusCode::FAILURE)
      << "Cannot initialize a Read/Write/Update handle with a null key.";
    return StatusCode::FAILURE;
  }
  // Don't do retrieve() here.  That unconditionally fetches the pointer
  // from the service manager, even if it's still valid, which it might
  // be if this is a handle that was just created from a key.
  if (!m_storeHandle.isValid()) {
    REPORT_ERROR (StatusCode::FAILURE)
      << "Cannot locate store: " << m_storeHandle.typeAndName();
    return StatusCode::FAILURE;
  }
 
  CLID this_clid = clid();
  m_hashedKey = m_storeHandle->stringToKey (m_sgKey, this_clid);
 
  // Make sure we also register hashes for base and copy classes at this point,
  // to prevent collisions with transient keys.
  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (this_clid);
  if (bib) {
    for (CLID base_clid : bib->get_bases()) {
      if (base_clid != this_clid) {
         m_storeHandle->stringToKey (m_sgKey, base_clid);
      }
    }
    for (CLID copy_clid : bib->get_copy_conversions()) {
      if (copy_clid != this_clid) {
         m_storeHandle->stringToKey (m_sgKey, copy_clid);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}
 

StatusCode VarHandleKey::initialize (AllowEmptyEnum)
{
  if (key().empty()) {
    return StatusCode::SUCCESS;
  }
  return initialize (true);
}
 

CLID VarHandleKey::clid() const
{
  return Gaudi::DataHandle::fullKey().clid();
}
 

void VarHandleKey::setKey(DataObjID /*key*/)
{
  throw SG::ExcForbiddenMethod ("VarHandleKey::setKey");
}
 

void VarHandleKey::updateKey(std::string /*key*/)
{
  throw SG::ExcForbiddenMethod ("VarHandleKey::updateKey");
}
 

 * not an empty store name.
 *
 * we also have to check that if the key contains the store name,
 * it matches the store name that they Handle was constructed with
 *
 * blank keys result in blank DataObjIDs
 *
 */
void VarHandleKey::parseKey (const std::string& key,
                             const std::string& storeName)
{
  std::string sn;
  // test if storeName has classname
  std::string::size_type sp = storeName.find('/');
  if (sp == std::string::npos) {
    sn = storeName;
  } else {
    sn = storeName.substr(sp+1,storeName.length()-sp+1);
  }
 
  if (key.empty()) {
    this->updateHandle(sn);
    Gaudi::DataHandle::updateKey("");
    m_sgKey.clear();
    m_hashedKey = 0;
    return;
  }
 
  // StoreName separator is "+"
  sp = key.find(storeSeparator);
  if(sp == std::string::npos) {
    m_sgKey = key;
  } else {
    sn = key.substr(0,sp);
    m_sgKey = key.substr(sp+1,key.length()-sp-1);
  }
 
 
  this->updateHandle(sn);
 
  StoreID::type st;
  // would be nice if we could get the storeID from the storeHandle, but
  // we can't be sure that the store has been created when the VHK is
  // constructed.
  //
 
  st = StoreID::findStoreID(sn);
 
  if (st != StoreID::CONDITION_STORE && st != StoreID::METADATA_STORE) {
    if (m_sgKey.find('/') != std::string::npos) {
      throw SG::ExcBadHandleKey("key \"" + key
                                + "\": keys with \"/\" only allowed for "
                                + StoreID::storeName(StoreID::CONDITION_STORE)
                                + " - store is \""
                                + sn + "\"");
    }
  } else {
    sp = m_sgKey.rfind('/');
    if (sp != std::string::npos) {
      if (sp == 0
      && m_sgKey.size() == 1) {
        // Replace '\' with blank key
        m_sgKey.clear();
        m_hashedKey = 0;
      } else if ( sp == m_sgKey.length()-1) {
        throw SG::ExcBadHandleKey("key \"" + key
                                  + "\": must not end with a \"/\"");
      }
    }
  }
 
  if (m_sgKey.empty()) {
    Gaudi::DataHandle::updateKey("");
  } else {
    Gaudi::DataHandle::updateKey(sn + storeSeparator + m_sgKey);
  }
 
 
}
 

void VarHandleKey::updateHandle (const std::string& name)
{
  // Don't invalidate a stored pointer if the handle is already pointing
  // at the desired service.
  if (m_storeHandle.name() != name) {
    m_hashedKey = 0;
    m_storeHandle = ServiceHandle<IProxyDict>(name, "VarHandleKey");
    m_isEventStore =  (name == StoreID::storeName(StoreID::EVENT_STORE) ||
                       name == StoreID::storeName(StoreID::PILEUP_STORE));
  }
}

std::string VarHandleKey::pythonRepr() const
{
  const std::string& className = fullKey().className().empty() ?
    Gaudi::DataHandle::default_type : fullKey().className();
 
  std::ostringstream ost;
  std::print (ost, "DataHandle(");;
  Gaudi::Utils::toStream(m_storeHandle.name() + storeSeparator + m_sgKey, ost);
  std::print (ost, ",");
  switch (mode()) {
  case Gaudi::DataHandle::Writer:
    Gaudi::Utils::toStream("W", ost); break;
  default:
    Gaudi::Utils::toStream("R", ost); break;
  }
  std::print (ost, ",");
  Gaudi::Utils::toStream(className, ost);
  std::print (ost, ",");
  Gaudi::Utils::toStream(isCondition(), ost);
  std::print (ost, ")");
 
  return ost.str();
}
 
 
std::ostream& operator<<(std::ostream& s, const SG::VarHandleKey& m) {
  std::print (s, "{}", m);
  return s;
}
 
 
} // namespace SG