Control/StoreGate/src/exceptions.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "StoreGate/exceptions.h"
#include <sstream>
 
 
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)
                                       
{
  std::ostringstream os;
  os << "SG::ExcHandleInitError: "
     << "Error initializing VarHandle from VarHandleKey: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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::ostringstream os;
  os << "SG::ExcUninitKey: "
     << "Error initializing " << htype << " from uninitialized " << htype << "Key: "
     << storename << "+" << sgkey << "[" << clid << "]; "
     << "keys should be initialized in your initialize().";
  if ( holdername.size() ) os << " Key held by " << holdername << ".";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcConstObject: "
     << "Tried to retrieve non-const pointer to const object via VarHandleKey: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcNullWriteHandle: "
     << "Attempt to dereference write handle before record: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcNullReadHandle: "
     << "Dereference of read handle failed: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcNullUpdateHandle: "
     << "Dereference of update handle failed: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcNonConstHandleKey: "
     << "Attempt to get non-const VarHandleKey from non-owning VarHandle: "
     << storename << "+" << sgkey << "[" << clid << "]";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcBadContext: Bad EventContext extension while building ReadCondHandle. "
     << "The EventContext extension is not "
     << (ctx.hasExtension() ? "of type Atlas::ExtendedEventContext" : "set")
     << " for key " << key << ".";
  return os.str();
}
 

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)
  
{
  std::ostringstream os;
  os << "SG::ExcNoCondCont: Can't retrieve CondCont from ReadCondHandle for key "
     << key << ". " << why;
  return os.str();
}
 

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::ostringstream os;
  os << "SG::ExcBadDecorElement: ";
  if (mode == Gaudi::DataHandle::Writer)
    os << "Write";
  else if (mode == Gaudi::DataHandle::Reader)
    os << "Read";
  else
    os << "???";
  os << "DecorHandle " << decorKey
     << "[" << clid << "]"
     << " given an element not in the requested container.";
  return os.str();
}
 

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