Control/AthContainers/AthContainers/exceptions.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_EXCEPTIONS_H
#define ATHCONTAINERS_EXCEPTIONS_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include <stdexcept>
#include <typeinfo>
#include <string>
 
 
namespace SG {
 
 
class ExcNoAuxStore
  : public std::runtime_error
{
public:
  ExcNoAuxStore (SG::auxid_t auxid);
 
 
  ExcNoAuxStore (const char* op);
};
 
 
class ExcBadAuxVar
  : public std::runtime_error
{
public:
  ExcBadAuxVar (SG::auxid_t auxid);
};
 
 
class ExcConstAuxData
  : public std::runtime_error
{
public:
  ExcConstAuxData (const std::string& op, SG::auxid_t auxid = null_auxid);
};
 
 
class ExcUntrackedSetStore
  : public std::runtime_error
{
public:
  ExcUntrackedSetStore();
};
 
 
 
class ExcBadPrivateStore
  : public std::runtime_error
{
public:
  ExcBadPrivateStore (const std::string& op);
};
 
 
 
class ExcAuxTypeMismatch
  : public std::runtime_error
{
public:
  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);
};
 
 
 
class ExcInsertionInBaseClass
  : public std::runtime_error
{
public:
  ExcInsertionInBaseClass (const char* op,
                           const std::type_info& base_type,
                           const std::type_info& complete_type);
};
 
 
class ExcStoreLocked
  : public std::runtime_error
{
public:
  ExcStoreLocked (SG::auxid_t auxid);
 
 
  ExcStoreLocked (const char* op);
};
 
 
class ExcNonowningContainer
  : public std::runtime_error
{
public:
  ExcNonowningContainer();
};
 
 
[[noreturn]]
void throwExcNonowningContainer();
 
 
class ExcUnknownAuxItem
  : public std::runtime_error
{
public:
  ExcUnknownAuxItem (const std::string& name,
                     const std::string& clsname = "",
                     const std::type_info* typ = 0);
};
 
 
[[noreturn]]
void throwExcUnknownAuxItem (const std::string& name,
                             const std::string& clsname = "",
                             const std::type_info* typ = 0);
 
 
class ExcDVToELV
  : public std::runtime_error
{
public:
  ExcDVToELV (const std::string& detail);
};
 
 
class ExcViewVectorNotView
  : public std::runtime_error
{
public:
  ExcViewVectorNotView();
};
 
 
[[noreturn]]
void throwExcViewVectorNotView();
 
 
class ExcMissingViewVectorCLID
  : public std::runtime_error
{
public:
  ExcMissingViewVectorCLID (const std::type_info& ti);
};
 
 
[[noreturn]]
void throwExcMissingViewVectorCLID (const std::type_info& ti);
 
 
class ExcMissingBaseInfo
  : public std::runtime_error
{
public:
  ExcMissingBaseInfo (const std::type_info& ti);
};
 
 
[[noreturn]]
void throwExcMissingBaseInfo (const std::type_info& ti);
 
 
class ExcInsertMoveOwnershipMismatch
  : public std::runtime_error
{
public:
  ExcInsertMoveOwnershipMismatch();
};
 
 
class ExcFlagMismatch
  : public std::runtime_error
{
public:
  ExcFlagMismatch (SG::auxid_t auxid,
                   const std::type_info& type,
                   SG::AuxVarFlags existing_flags,
                   SG::AuxVarFlags requested_flags);
};
 
 
class ExcLinkMismatch
  : public std::runtime_error
{
public:
  ExcLinkMismatch (SG::auxid_t auxid,
                   const std::type_info& type,
                   SG::auxid_t existing_linked_id,
                   SG::auxid_t requested_linked_id);
};
 
 
class ExcNoLinkedVar
  : public std::runtime_error
{
public:
  ExcNoLinkedVar (SG::auxid_t auxid,
                  const std::type_info& type);
};
 
 
class ExcInvalidThinningTarget
  : public std::runtime_error
{
public:
  ExcInvalidThinningTarget (unsigned int clid,
                            const std::string& key);
};
 
 
class ExcBadIterSwap
  : public std::runtime_error
{
public:
  ExcBadIterSwap();
};
 
 
class ExcAllocOwnership
  : public std::runtime_error
{
public:
  ExcAllocOwnership();
};
 
 
[[noreturn]]
void throwExcAllocOwnership();
 
 
class ExcBadVarName
  : public std::runtime_error
{
public:
  ExcBadVarName (const std::string& name);
};
 
 
class ExcJaggedVecOverlappingCopy
  : public std::runtime_error
{
public:
  ExcJaggedVecOverlappingCopy();
};
 
 
[[noreturn]]
void throwJaggedVecOverlappingCopy();
 
 
class ExcOutOfRange
  : public std::out_of_range
{
public:
  ExcOutOfRange (const char* what,
                 size_t i,
                 size_t size);
};
 
 
[[noreturn]]
void throwExcOutOfRange (const char* what,
                         size_t i,
                         size_t size);
 
 
} // namespace SG
 
 
#endif // not ATHCONTAINERS_EXCEPTIONS_H