Control/AthLinks/src/exceptions.cxx

Go to the documentation of this file.

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

void AthLinks_error() {}
 
 
//*************************************************************************
 

std::string excPointerNotInSG_format (const void* pointer)
{
  return std::format ("SG::ExcPointerNotInSG: "
                      "The object referenced by a DataLink / ElementLink is not registered "
                      "in StoreGate: {}.", pointer);
}
 

ExcPointerNotInSG::ExcPointerNotInSG (const void* pointer)
  : std::runtime_error (excPointerNotInSG_format (pointer))
{
  AthLinks_error();
}
 
 
//*************************************************************************
 

std::string excCLIDMismatch_format (CLID obj_clid, CLID link_clid)
{
  return std::format ("SG::ExcCLIDMismatch: "
                      "Attempt to set DataLink / ElementLink with CLID {} to object with CLID {}",
                      link_clid, obj_clid);
}
 

ExcCLIDMismatch::ExcCLIDMismatch (CLID obj_clid, CLID link_clid)
  : std::runtime_error (excCLIDMismatch_format (obj_clid, link_clid))
{
  AthLinks_error();
}
 
 
//*************************************************************************
 

std::string
excInvalidLink_format (CLID clid, const std::string& key, SG::sgkey_t sgkey)
{
  return std::format ("SG::ExcInvalidLink: "
                      "Attempt to dereference invalid DataLink / ElementLink "
                      "[{}/{}] ({})",
                      clid, key, sgkey);
}
 

ExcInvalidLink::ExcInvalidLink (CLID clid,
                                const std::string& key,
                                SG::sgkey_t sgkey)
  : std::runtime_error (excInvalidLink_format (clid, key, sgkey))
{
  AthLinks_error();
}
 

void throwExcInvalidLink (CLID clid, const std::string& key, SG::sgkey_t sgkey)
{
  throw ExcInvalidLink (clid, key, sgkey);
}
 
 
//*************************************************************************
 

std::string
excBadForwardLink_format (size_t index, size_t size, const std::string& name)
{
  std::string s = std::format ("SG::ExcBadForwardLink: "
                               "ForwardIndexingPolicy: internal link state of '{}' is invalid", name);
  if (index != static_cast<size_t>(-1)) {
    s += std::format (": m_index = {} is >= data container size = {}",
                      index, size);
  } 
  return s;
}
 

ExcBadForwardLink::ExcBadForwardLink (size_t index, size_t size, const std::string& name)
  : std::runtime_error (excBadForwardLink_format (index, size, name))
{
  AthLinks_error();
}
 

void throwExcBadForwardLink (size_t index, size_t size, const std::string& name)
{
  throw ExcBadForwardLink (index, size, name);
}
 
 
//*************************************************************************
 

ExcElementNotFound::ExcElementNotFound (const std::string& where)
  : std::runtime_error ("SG::ExcElementNotFound: " + where +
                        ": element not found")
{
  AthLinks_error();
}
 

void throwExcElementNotFound (const char* where)
{
  throw ExcElementNotFound (where);
}
 
 
//*************************************************************************
 

ExcInvalidIndex::ExcInvalidIndex (const std::string& where)
  : std::runtime_error ("SG::ExcInvalidIndex: " + where + ": invalid index")
{
  AthLinks_error();
}
 

void throwExcInvalidIndex (const char* where)
{
  throw ExcInvalidIndex (where);
}
 
 
//*************************************************************************
 

ExcIndexNotFound::ExcIndexNotFound (const std::string& where)
  : std::runtime_error ("SG::ExcIndexNotFound: " + where + ": index not found")
{
  AthLinks_error();
}
 

void throwExcIndexNotFound (const char* where)
{
  throw ExcIndexNotFound (where);
}
 
 
//*************************************************************************
 

ExcIncomparableEL::ExcIncomparableEL()
  : std::runtime_error ("SG::ExcIncomparableEL: Attempt to compare an ElementLink that does not have a SG key or index.")
{
  AthLinks_error();
}
 

void throwExcIncomparableEL()
{
  throw ExcIncomparableEL();
}
 
 
//*************************************************************************
 

ExcBadToTransient::ExcBadToTransient()
  : std::runtime_error ("SG::ExcBadToTransient: toTransient() called on an already-initialized link.")
{
  AthLinks_error();
}
 

void throwExcBadToTransient()
{
  throw ExcBadToTransient();
}
 
 
//*************************************************************************
 

std::string
excConstStorable_format (CLID clid, const std::string& key, SG::sgkey_t sgkey)
{
  return std::format ("SG::ExcConstStorable: "
                      "Tried to retrieve const storable as a non-const pointer "
                      "[{}/{}] ({})",
                      clid, key, sgkey);
}
 

ExcConstStorable::ExcConstStorable (CLID clid,
                                    const std::string& key,
                                    SG::sgkey_t sgkey)
  : std::runtime_error (excConstStorable_format (clid, key, sgkey))
{
  AthLinks_error();
}
 
 
//*************************************************************************
 

std::string
excBadThinning_format (CLID clid, const std::string& key, SG::sgkey_t sgkey)
{
  return std::format ("SG::ExcBadThinning: Bad thinning request [{}/{}] ({})",
                      clid, key, sgkey);
}
 

ExcBadThinning::ExcBadThinning (CLID clid,
                                const std::string& key,
                                SG::sgkey_t sgkey)
  : std::runtime_error (excBadThinning_format (clid, key, sgkey))
{
  AthLinks_error();
}
 

void throwExcBadThinning (CLID clid,
                          const std::string& key,
                          SG::sgkey_t sgkey)
{
  throw ExcBadThinning (clid, key, sgkey);
}
 
 
} // namespace SG