Control/AthContainers/Root/exceptions.cxx

Go to the documentation of this file.

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

std::string excFormatName (SG::auxid_t auxid)
{
  if (auxid != null_auxid) {
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    return std::format ("`{}::{}' ({})",
                        r.getClassName (auxid),
                        r.getName (auxid),
                        auxid);
  }
  return "(null)";
}
  
 
//*************************************************************************
 

std::string excNoAuxStore_format (SG::auxid_t auxid)
{
  return std::format ("SG::ExcNoAuxStore: "
                      "Requested aux data item {} but there is no associated aux data store.",
                      excFormatName (auxid));
}
 

std::string excNoAuxStore_format (const char* op)
{
  return std::format ("SG::ExcNoAuxStore: "
                      "Operation attempted on container with no associated aux data store: {}", op);;
}
 

ExcNoAuxStore::ExcNoAuxStore (SG::auxid_t auxid)
  : std::runtime_error (excNoAuxStore_format (auxid))
{
}
 

ExcNoAuxStore::ExcNoAuxStore (const char* op)
  : std::runtime_error (excNoAuxStore_format (op))
{
}
 
 
//*************************************************************************
 

std::string excBadAuxVar_format (SG::auxid_t auxid)
{
  return std::format ("SG::ExcBadAuxVar: "
                      "Attempt to retrieve nonexistent aux data item {}.",
                      excFormatName (auxid));
}
 

ExcBadAuxVar::ExcBadAuxVar (SG::auxid_t auxid)
  : std::runtime_error (excBadAuxVar_format (auxid))
{
}
 
 
//*************************************************************************
 

std::string excConstAuxData_format (const std::string& op, SG::auxid_t auxid)
{
  return std::format ("SG::ExcConstAuxData: "
                      "Non-const operation `{}' performed on const aux data {}.",
                      op, excFormatName (auxid));
}
 

ExcConstAuxData::ExcConstAuxData (const std::string& op, SG::auxid_t auxid)
  : std::runtime_error (excConstAuxData_format (op, auxid))
{
}
 
 
//*************************************************************************
 

ExcUntrackedSetStore::ExcUntrackedSetStore()
  : std::runtime_error
    ("SG::ExcUntrackedSetStore: "
     "Attempt to set aux data store on container that doesn't track indices, "
     "or disable index tracking for a container with aux data.")
{
}
 
 
//*************************************************************************
 

ExcBadPrivateStore::ExcBadPrivateStore (const std::string& op)
  : std::runtime_error ("SG::ExcBadPrivateStore: "
                        "Bad use of private store: " + op)
{
}
 
 
//*************************************************************************
 

std::string excAuxTypeMismatch_format (SG::auxid_t auxid,
                                       const std::type_info& new_type,
                                       const std::type_info& old_type,
                                       const std::string& new_alloc_type,
                                       const std::string& old_alloc_type)
{
  std::string s =
    std::format ("SG::ExcAuxTypeMismatch: "
                 "Type mismatch for aux variable {}; old type is {} new type is {}",
                 excFormatName (auxid),
                 AthContainers_detail::typeinfoName (old_type),
                 AthContainers_detail::typeinfoName (new_type));
  if (old_alloc_type != new_alloc_type)
  {
    s += std::format (".  Old allocator type is {} new allocator type is {}",
                      old_alloc_type, new_alloc_type);
  }
  return s;
}
 

ExcAuxTypeMismatch::ExcAuxTypeMismatch (SG::auxid_t auxid,
                                        const std::type_info& new_type,
                                        const std::type_info& old_type,
                                        const std::string& new_alloc_type,
                                        const std::string& old_alloc_type)
  : std::runtime_error (excAuxTypeMismatch_format (auxid,
                                                   new_type, old_type,
                                                   new_alloc_type,
                                                   old_alloc_type))
{
}
 
 
//*************************************************************************
 

std::string excInsertionInBaseClass_format (const char* op,
                                            const std::type_info& base_type,
                                            const std::type_info& complete_type)
{
  return std::format ("SG::ExcInsertionInBaseClass: "
                      "Attempted to do {} on a {} base class of {}; can only be done on the most-derived class.",
                      op,
                      AthContainers_detail::typeinfoName (base_type),
                      AthContainers_detail::typeinfoName (complete_type));
}
 

ExcInsertionInBaseClass::ExcInsertionInBaseClass
   (const char* op,
    const std::type_info& base_type,
    const std::type_info& complete_type)
     : std::runtime_error (excInsertionInBaseClass_format (op,
                                                           base_type,
                                                           complete_type))
{
}
 
 
//*************************************************************************
 

std::string excStoreLocked_format (SG::auxid_t auxid)
{
  return std::format ("SG::ExcStoreLocked: "
                      "Attempted to modify auxiliary data in a locked store: {}",
                      excFormatName (auxid));
}
 

std::string excStoreLocked_format (const char* op)
{
  return std::format ("SG::ExcStoreLocked: "
                      "Attempted to modify auxiliary data in a locked store: {}", op);
}
 

ExcStoreLocked::ExcStoreLocked (SG::auxid_t auxid)
  : std::runtime_error (excStoreLocked_format (auxid))
{
}
 

ExcStoreLocked::ExcStoreLocked (const char* op)
  : std::runtime_error (excStoreLocked_format (op))
{
}
 
 
//*************************************************************************
 

ExcNonowningContainer::ExcNonowningContainer()
  : std::runtime_error ("SG::ExcNonowningContainer: Attempted to insert a unique_ptr to a non-owning container.")
{
}
 

void throwExcNonowningContainer()
{
  throw ExcNonowningContainer();
}
 
 
//*************************************************************************
 

std::string excUnknownAuxItem_format (const std::string& name,
                                      const std::string& clsname,
                                      const std::type_info* typ)
{
  std::string s = std::format ("SG::ExcUnknownAuxItem: "
                               "Unknown aux data item {}{}{}",
                               clsname, (clsname.empty() ? "" : "::"), name);
  if (typ)
    s += std::format (" (of type {})",
                      AthContainers_detail::typeinfoName (*typ));
  return s;
}
 

ExcUnknownAuxItem::ExcUnknownAuxItem (const std::string& name,
                                      const std::string& clsname /*= ""*/,
                                      const std::type_info* typ /*= 0*/)
  : std::runtime_error (excUnknownAuxItem_format (name, clsname, typ))
{
}
 

void throwExcUnknownAuxItem (const std::string& name,
                             const std::string& clsname /*= ""*/,
                             const std::type_info* typ /*= 0*/)
{
  throw ExcUnknownAuxItem (name, clsname, typ);
}
 
 
//*************************************************************************
 

std::string excDVToELV_format (const std::string& detail)
{
  return std::format ("SG::ExcDVToELV: "
                      "Can't convert DataVector to vector of ElementLinks: {}",
                      detail);
}
 

ExcDVToELV::ExcDVToELV (const std::string& detail)
  : std::runtime_error (excDVToELV_format (detail))
{
}
 
 
//*************************************************************************
 

ExcViewVectorNotView::ExcViewVectorNotView()
  : std::runtime_error ("ViewVector not in view mode.")
{
}
 

void throwExcViewVectorNotView()
{
  throw ExcViewVectorNotView();
}
 
 
//*************************************************************************
 

ExcMissingViewVectorCLID::ExcMissingViewVectorCLID (const std::type_info& ti)
  : std::runtime_error ("ViewVector " + AthContainers_detail::typeinfoName(ti) +
                        "was used in a context that requires a CLID, "
                        "but no CLID was available.  Make sure a "
                        "VIEWVECTOR_CLASS_DEF declaration exists for the class "
                        "in a library that has been loaded.")
{
}
 

void throwExcMissingViewVectorCLID (const std::type_info& ti)
{
  throw ExcMissingViewVectorCLID (ti);
}
 
 
//*************************************************************************
 

ExcMissingBaseInfo::ExcMissingBaseInfo (const std::type_info& ti)
  : std::runtime_error ("Missing BaseInfo for " +
                        AthContainers_detail::typeinfoName(ti))
{
}
 

void throwExcMissingBaseInfo (const std::type_info& ti)
{
  throw ExcMissingBaseInfo (ti);
}
 
 
//*************************************************************************
 

ExcInsertMoveOwnershipMismatch::ExcInsertMoveOwnershipMismatch()
  : std::runtime_error ("Ownership mismatch for insertMove.")
{
}
 
 
//*************************************************************************
 

std::string excFormatFlags (SG::AuxVarFlags flags)
{
  std::string out;
  if (flags & SG::AuxVarFlags::Atomic)
    out = "atomic";
  if (flags & SG::AuxVarFlags::Linked) {
    if (!out.empty()) out += " ";
    out = "linked";
  }
 
  return "[" + out + "]";
}
 

std::string excFlagMismatch_format (SG::auxid_t auxid,
                                    const std::type_info& type,
                                    SG::AuxVarFlags existing_flags,
                                    SG::AuxVarFlags requested_flags)
{
  return std::format ("SG::ExcFlagMismatch: "
                      "Flag mismatch for aux variable {} of type {} between existing {} and requested {} flags. "
                      "This may occur as a result of not using AtomicDecorator to access an atomic variable.",
                      excFormatName (auxid),
                      AthContainers_detail::typeinfoName (type),
                      excFormatFlags (existing_flags),
                      excFormatFlags (requested_flags));
}
 

ExcFlagMismatch::ExcFlagMismatch (SG::auxid_t auxid,
                                  const std::type_info& type,
                                  SG::AuxVarFlags existing_flags,
                                  SG::AuxVarFlags requested_flags)
  : std::runtime_error (excFlagMismatch_format (auxid, type, existing_flags, requested_flags))
{
}
 
 
//*************************************************************************
 

std::string excLinkMismatch_format (SG::auxid_t auxid,
                                    const std::type_info& type,
                                    SG::auxid_t existing_linked_id,
                                    SG::auxid_t requested_linked_id)
{
  return std::format ("SG::ExcLinkMismatch: "
                      "Linked variable mismatch for aux variable {} of type {} between existing {} and requested {} linked variables.",
                      excFormatName (auxid),
                      AthContainers_detail::typeinfoName (type),
                      excFormatName (existing_linked_id),
                      excFormatName (requested_linked_id));
}
 

ExcLinkMismatch::ExcLinkMismatch (SG::auxid_t auxid,
                                  const std::type_info& type,
                                  SG::auxid_t existing_linked_id,
                                  SG::auxid_t requested_linked_id)
  : std::runtime_error (excLinkMismatch_format (auxid, type,
                                                existing_linked_id, requested_linked_id))
{
}
 
 
//*************************************************************************
 

std::string excNoLinkedVar_format (SG::auxid_t auxid,
                                   const std::type_info& type)
{
  return std::format ("SG::ExcNoLinkedVar: "
                      "Linked variable not found for aux variable {} of type {}",
                      excFormatName (auxid), AthContainers_detail::typeinfoName (type));
}
 

ExcNoLinkedVar::ExcNoLinkedVar (SG::auxid_t auxid,
                                const std::type_info& type)
  : std::runtime_error (excNoLinkedVar_format (auxid, type))
{
}
 
 
//*************************************************************************
 

std::string excInvalidThinningTarget_format (unsigned int clid,
                                             const std::string& key)
{
  return std::format ("SG::ExcInvalidThinningTarget: "
                      "ThinningHandle target does not exist: {}/{}",
                      clid, key);
}
 

ExcInvalidThinningTarget::ExcInvalidThinningTarget (unsigned int clid,
                                                    const std::string& key)
  : std::runtime_error (excInvalidThinningTarget_format (clid, key))
{
}
 
 
//*************************************************************************
 

ExcBadIterSwap::ExcBadIterSwap()
  : std::runtime_error ("SG::ExcBadIterSwap: Attempt to swap between containers with inconsistent ownership.")
{
}
 
 
//*************************************************************************
 

ExcAllocOwnership::ExcAllocOwnership()
  : std::runtime_error ("SG::ExcAllocOwnership: Bad allocation ownership.")
{
}
 

void throwExcAllocOwnership()
{
  throw ExcAllocOwnership();
}
 
 
//*************************************************************************
 

std::string excBadVarName_format (const std::string& name)
{
  return std::format ("SG::ExcBadVarName: "
                      "Bad name for auxiliary variable `{}'. "
                      "Variable and class names must consist of only digits, letters, "
                      "and underscores, and cannot start with a digit.  "
                      "Variable names may not be empty, but class names may be.",
                      name);
}
 

ExcBadVarName::ExcBadVarName (const std::string& name)
  : std::runtime_error (excBadVarName_format (name))
{
}
 
 
//*************************************************************************
 

std::string excJaggedVecOverlappingCopy_format()
{
  return "SG::ExcJaggedVecOverlappingCopy: Overlapping copies not implemented for jagged vectors.  Talk to core software if this is an issue.";
}
 

ExcJaggedVecOverlappingCopy::ExcJaggedVecOverlappingCopy()
  : std::runtime_error (excJaggedVecOverlappingCopy_format())
{
}
 

void throwJaggedVecOverlappingCopy()
{
  throw ExcJaggedVecOverlappingCopy();
}
 
 
} // namespace SG