Control/AthLinks/src/exceptions.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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)
{
  std::ostringstream os;
  os << "SG::ExcPointerNotInSG: "
     << "The object referenced by a DataLink / ElementLink is not registered "
     << "in StoreGate: " << pointer << ".";
  return os.str();
}
 
 
ExcPointerNotInSG::ExcPointerNotInSG (const void* pointer)
  : std::runtime_error (excPointerNotInSG_format (pointer))
{
  AthLinks_error();
}
 
 
//*************************************************************************
 
 
std::string excCLIDMismatch_format (CLID obj_clid, CLID link_clid)
{
  std::ostringstream os;
  os << "SG::ExcCLIDMismatch: "
     << "Attempt to set DataLink / ElementLink with CLID " << link_clid
     << " to object with CLID " << obj_clid;
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcInvalidLink: "
     << "Attempt to dereference invalid DataLink / ElementLink "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}
 
 
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::ostringstream os;
  os << "SG::ExcBadForwardLink: "
     << "ForwardIndexingPolicy: internal link state of '" << name << "' is invalid";
  if (index != static_cast<size_t>(-1)) {
    os << ": m_index = " << index
       << " is >= data container size = "
       << size << std::ends;
  } 
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcConstStorable: "
     << "Tried to retrieve const storable as a non-const pointer "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcBadThinning: "
     << "Bad thinning request "
     << "[" << clid << "/" << key << "] (" << sgkey << ")";
  return os.str();
}
 
 
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