Control/StoreGate/src/exceptions.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "StoreGate/exceptions.h"
#include <format>
 
 
namespace SG {
 

ExcNullHandleKey::ExcNullHandleKey()
  : std::runtime_error ("SG::ExcNullHandleKey: Attempt to dereference a Read/Write/UpdateHandle with a null key.")
{
}
 

[[noreturn]]
void throwExcNullHandleKey()
{
  throw ExcNullHandleKey();
}
 
 
//****************************************************************************
 

ExcBadHandleKey::ExcBadHandleKey (const std::string& key)
  : std::runtime_error ("SG::ExcBadHandleKey: Bad key format for VarHandleKey: `" + key + "'")
{
}
 
 
//****************************************************************************
 

ExcForbiddenMethod::ExcForbiddenMethod (const std::string& name)
  : std::runtime_error ("SG::ExcForbiddenMethod: Forbidden method called: `" + name + "'")
{
}
 
 
//****************************************************************************
 

std::string excHandleInitError_format (CLID clid,
                                       const std::string& sgkey,
                                       const std::string& storename)
                                       
{
  return std::format ("SG::ExcHandleInitError: "
                      "Error initializing VarHandle from VarHandleKey: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcHandleInitError::ExcHandleInitError (CLID clid,
                                        const std::string& sgkey,
                                        const std::string& storename)
  : std::runtime_error (excHandleInitError_format (clid, sgkey, storename))
{
}
 
 
//****************************************************************************
 

std::string excUninitKey_format (CLID clid,
                                 const std::string& sgkey,
                                 const std::string& storename,
                                 const std::string& holdername,
                                 const std::string& htype)
                                       
{
  std::string s =
    std::format ("SG::ExcUninitKey: "
                 "Error initializing {} from uninitialized {}Key: {}+{}[{}]; "
                 "keys should be initialized in your initialize().",
                 htype, htype, storename, sgkey, clid);
  if ( holdername.size() )
    s += std::format (" Key held by {}.", holdername);
  return s;
}
 

ExcUninitKey::ExcUninitKey (CLID clid,
                            const std::string& sgkey,
                            const std::string& storename,
                            const std::string& holdername /*= ""*/,
                            const std::string& htype /*= "VarHandle"*/)
  : std::runtime_error (excUninitKey_format (clid, sgkey, storename, holdername, htype))
{
}
 
 
//****************************************************************************
 

std::string excConstObject_format (CLID clid,
                                   const std::string& sgkey,
                                   const std::string& storename)
  
{
  return std::format ("SG::ExcConstObject: "
                      "Tried to retrieve non-const pointer to const object via VarHandleKey: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcConstObject::ExcConstObject (CLID clid,
                                const std::string& sgkey,
                                const std::string& storename)
  : std::runtime_error (excConstObject_format (clid, sgkey, storename))
{
}
 
 
//****************************************************************************
 

std::string excNullWriteHandle_format (CLID clid,
                                       const std::string& sgkey,
                                       const std::string& storename)
  
{
  return std::format ("SG::ExcNullWriteHandle: "
                      "Attempt to dereference write handle before record: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcNullWriteHandle::ExcNullWriteHandle (CLID clid,
                                        const std::string& sgkey,
                                        const std::string& storename)
  : std::runtime_error (excNullWriteHandle_format (clid, sgkey, storename))
{
}
 

void throwExcNullWriteHandle (CLID clid,
                              const std::string& sgkey,
                              const std::string& storename)
{
  throw ExcNullWriteHandle (clid, sgkey, storename);
}
 
 
//****************************************************************************
 

std::string excNullReadHandle_format (CLID clid,
                                      const std::string& sgkey,
                                      const std::string& storename)
  
{
  return std::format ("SG::ExcNullReadHandle: "
                      "Dereference of read handle failed: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcNullReadHandle::ExcNullReadHandle (CLID clid,
                                      const std::string& sgkey,
                                      const std::string& storename)
  : std::runtime_error (excNullReadHandle_format (clid, sgkey, storename))
{
}
 

void throwExcNullReadHandle (CLID clid,
                             const std::string& sgkey,
                             const std::string& storename)
{
  throw ExcNullReadHandle (clid, sgkey, storename);
}
 
 
//****************************************************************************
 

std::string excNullUpdateHandle_format (CLID clid,
                                        const std::string& sgkey,
                                        const std::string& storename)
  
{
  return std::format ("SG::ExcNullUpdateHandle: "
                      "Dereference of update handle failed: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcNullUpdateHandle::ExcNullUpdateHandle (CLID clid,
                                          const std::string& sgkey,
                                          const std::string& storename)
  : std::runtime_error (excNullUpdateHandle_format (clid, sgkey, storename))
{
}
 

void throwExcNullUpdateHandle (CLID clid,
                               const std::string& sgkey,
                               const std::string& storename)
{
  throw ExcNullUpdateHandle (clid, sgkey, storename);
}
 
 
//****************************************************************************
 

std::string excNonConstHandleKey_format (CLID clid,
                                         const std::string& sgkey,
                                         const std::string& storename)
  
{
  return std::format ("SG::ExcNonConstHandleKey: "
                      "Attempt to get non-const VarHandleKey from non-owning VarHandle: {}+{}[{}]",
                      storename, sgkey, clid);
}
 

ExcNonConstHandleKey::ExcNonConstHandleKey (CLID clid,
                                            const std::string& sgkey,
                                            const std::string& storename)
  : std::runtime_error (excNonConstHandleKey_format (clid, sgkey, storename))
{
}
 

void throwExcNonConstHandleKey (CLID clid,
                                const std::string& sgkey,
                                const std::string& storename)
{
  throw ExcNonConstHandleKey (clid, sgkey, storename);
}
 
 
//****************************************************************************
 

ExcInvalidIterator::ExcInvalidIterator()
  : std::runtime_error ("SG::ExcInvalidIterator: Attempt to dereference invalid SG::Iterator/SG::ConstIterator")
{
}
 
 
//****************************************************************************
 

ExcBadInitializedReadHandleKey::ExcBadInitializedReadHandleKey()
  : std::runtime_error ("Initialization of InitializedReadHandleKey failed.")
{
}
 
 
//****************************************************************************
 

std::string excBadContext_format (const EventContext& ctx,
                                  const std::string& key)
  
{
  return std::format ("SG::ExcBadContext: "
                      "Bad EventContext extension while building ReadCondHandle. "
                      "The EventContext extension is not {} for key {}.",
                      (ctx.hasExtension() ? "of type Atlas::ExtendedEventContext" : "set"),
                      key);
}
 

ExcBadContext::ExcBadContext (const EventContext& ctx, const std::string& key)
  : std::runtime_error (excBadContext_format (ctx, key))
{
}
 
 
//****************************************************************************
 

std::string excNoCondCont_format (const std::string& key,
                                  const std::string& why)
  
{
  return std::format ("SG::ExcNoCondCont: "
                      "Can't retrieve CondCont from ReadCondHandle for key {}. {}",
                      key, why);
}
 

ExcNoCondCont::ExcNoCondCont (const std::string& key, const std::string& why)
  : std::runtime_error (excNoCondCont_format (key, why))
{
}
 
 
//****************************************************************************
 

ExcBadReadCondHandleInit::ExcBadReadCondHandleInit()
  : std::runtime_error ("SG::ExcBadReadCondHandleInit: ReadCondHandle didn't initialize in getRange().")
{
}
 
 
//****************************************************************************
 

ExcNoRange::ExcNoRange()
  : std::runtime_error ("SG::ExcBadReadCondHandleInit: Range not set in ReadCondHandle::getRange().")
{
}
 
 
//****************************************************************************
 

std::string excBadDecorElement_format (Gaudi::DataHandle::Mode mode,
                                       CLID clid,
                                       const std::string& decorKey)
{
  std::string modestr = "???";
  if (mode == Gaudi::DataHandle::Writer)
    modestr = "Write";
  else if (mode == Gaudi::DataHandle::Reader)
    modestr = "Read";
  return std::format ("SG::ExcBadDecorElement: "
                      "{}DecorHandle {}[{}]"
                      " given an element not in the requested container.",
                      modestr, decorKey, clid);
}
 

ExcBadDecorElement::ExcBadDecorElement (Gaudi::DataHandle::Mode mode,
                                        CLID clid,
                                        const std::string& decorKey)
  : std::runtime_error (excBadDecorElement_format (mode, clid, decorKey))
{
}
 

[[noreturn]]
void throwExcBadDecorElement (Gaudi::DataHandle::Mode mode,
                              CLID clid,
                              const std::string& decorKey)
{
  throw SG::ExcBadDecorElement (mode, clid, decorKey);
}
 
 
} // namespace SG