Control/AthContainers/Root/exceptions.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#include "AthContainers/exceptions.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/error.h"
#include <sstream>
 
 
namespace SG {
 
 
std::string excFormatName (SG::auxid_t auxid)
{
  std::ostringstream os;
  if (auxid != null_auxid) {
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    os << "`" << r.getClassName (auxid);
    if (!os.str().empty())
      os << "::";
    os << r.getName (auxid);
    os << "' (" << auxid << ")";
  }
  else {
    os << "(null)";
  }
  return os.str();
}
  
 
//*************************************************************************
 
 
std::string excNoAuxStore_format (SG::auxid_t auxid)
{
  std::ostringstream os;
  os << "SG::ExcNoAuxStore: "
     << "Requested aux data item "
     << excFormatName (auxid)
     << " but there is no associated aux data store.";
  return os.str();
}
 
 
std::string excNoAuxStore_format (const char* op)
{
  std::ostringstream os;
  os << "SG::ExcNoAuxStore: "
     << "Operation attempted on container with no associated aux data store: ";
  os << op;
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcBadAuxVar: "
     << "Attempt to retrieve nonexistent aux data item "
     << excFormatName (auxid)
     << ".";
  return os.str();
}
 
 
ExcBadAuxVar::ExcBadAuxVar (SG::auxid_t auxid)
  : std::runtime_error (excBadAuxVar_format (auxid))
{
}
 
 
//*************************************************************************
 
 
std::string excConstAuxData_format (const std::string& op, SG::auxid_t auxid)
{
  std::ostringstream os;
  os << "SG::ExcConstAuxData: "
     << "Non-const operation `" << op << "' performed on const aux data "
     << excFormatName (auxid)
     << ".";
  return os.str();
}
 
 
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::ostringstream os;
  os << "SG::ExcAuxTypeMismatch: "
     << "Type mismatch for aux variable "
     << excFormatName (auxid)
     << "; old type is " << AthContainers_detail::typeinfoName (old_type)
     << " new type is "  << AthContainers_detail::typeinfoName (new_type);
  if (old_alloc_type != new_alloc_type)
  {
    os << ".  Old allocator type is " << old_alloc_type
       << " new allocator type is " << new_alloc_type;
  }
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcInsertionInBaseClass: "
     << "Attempted to do " << op
     << " on a " << AthContainers_detail::typeinfoName (base_type)
     << " base class of " << AthContainers_detail::typeinfoName (complete_type)
     << "; can only be done on the most-derived class.";
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcStoreLocked: "
     << "Attempted to modify auxiliary data in a locked store: ";
  os << excFormatName (auxid);
  return os.str();
}
 
 
std::string excStoreLocked_format (const char* op)
{
  std::ostringstream os;
  os << "SG::ExcStoreLocked: "
     << "Attempted to modify auxiliary data in a locked store: ";
  os << op;
  return os.str();
}
 
 
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::ostringstream os;
  os << "SG::ExcUnknownAuxItem: "
     << "Unknown aux data item ";
  if (!clsname.empty())
    os << clsname << "::";
  os << name;
  if (typ)
    os << " (of type " << AthContainers_detail::typeinfoName (*typ) << ")";
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcDVToELV: "
     << "Can't convert DataVector to vector of ElementLinks: "
     << detail;
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcFlagMismatch: "
     << "Flag mismatch for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type)
     << " between existing " << excFormatFlags (existing_flags)
     << " and requested " << excFormatFlags (requested_flags) << " flags. "
     << "This may occur as a result of not using AtomicDecorator to access an atomic variable.";
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcLinkMismatch: "
     << "Linked variable mismatch for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type)
     << " between existing " << excFormatName (existing_linked_id)
     << " and requested " << excFormatName (requested_linked_id) << " linked variables.";
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcNoLinkedVar: "
     << "Linked variable not found for aux variable "
     << excFormatName (auxid)
     << " of type " << AthContainers_detail::typeinfoName (type);
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcInvalidThinningTarget: "
     << "ThinningHandle target does not exist: "
     << clid << "/" << key;
  return os.str();
}
 
 
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)
{
  std::ostringstream os;
  os << "SG::ExcBadVarName: "
     << "Bad name for auxiliary variable `" << name << "'. "
     << "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.";
  return os.str();
}
 
 
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();
}
 
 
//*************************************************************************
 
 
std::string excOutOfRange_format (const char* what,
                                  size_t i,
                                  size_t size)
{
  std::ostringstream os;
  os << "SG::ExcOutOfRange: "
     << "Range reference out of bounds in " << what << "; "
     << i << " >= " << size;
  return os.str();
}
 
 
ExcOutOfRange::ExcOutOfRange (const char* what,
                              size_t i,
                              size_t size)
  : std::out_of_range (excOutOfRange_format (what, i, size))
{
}
 
void throwOutOfRange (const char* what,
                       size_t i,
                       size_t size)
{
  throw ExcOutOfRange (what, i, size);
}
 
 
} // namespace SG