223 lines
9.5 KiB
C++
223 lines
9.5 KiB
C++
//
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
// Copyright (c) Contributors to the OpenEXR Project.
|
|
//
|
|
|
|
#ifndef INCLUDED_IEXBASEEXC_H
|
|
#define INCLUDED_IEXBASEEXC_H
|
|
|
|
#include "IexExport.h"
|
|
#include "IexNamespace.h"
|
|
|
|
//----------------------------------------------------------
|
|
//
|
|
// A general exception base class, and a few
|
|
// useful exceptions derived from the base class.
|
|
//
|
|
//----------------------------------------------------------
|
|
|
|
#include <exception>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
IEX_INTERNAL_NAMESPACE_HEADER_ENTER
|
|
|
|
//-------------------------------
|
|
// Our most basic exception class
|
|
//-------------------------------
|
|
|
|
class IEX_EXPORT_TYPE BaseExc : public std::exception
|
|
{
|
|
public:
|
|
//----------------------------
|
|
// Constructors and destructor
|
|
//----------------------------
|
|
|
|
IEX_EXPORT BaseExc (const char* s = nullptr);
|
|
IEX_EXPORT BaseExc (const std::string& s);
|
|
IEX_EXPORT BaseExc (std::string&& s); // not noexcept because of stacktrace
|
|
IEX_EXPORT BaseExc (std::stringstream& s);
|
|
|
|
IEX_EXPORT BaseExc (const BaseExc& be);
|
|
IEX_EXPORT BaseExc (BaseExc&& be) noexcept;
|
|
IEX_EXPORT virtual ~BaseExc () noexcept;
|
|
|
|
IEX_EXPORT BaseExc& operator= (const BaseExc& be);
|
|
IEX_EXPORT BaseExc& operator= (BaseExc&& be) noexcept;
|
|
|
|
//---------------------------------------------------
|
|
// what() method -- e.what() returns _message.c_str()
|
|
//---------------------------------------------------
|
|
|
|
IEX_EXPORT virtual const char* what () const noexcept;
|
|
|
|
//--------------------------------------------------
|
|
// Convenient methods to change the exception's text
|
|
//--------------------------------------------------
|
|
|
|
IEX_EXPORT BaseExc& assign (std::stringstream& s); // assign (s.str())
|
|
IEX_EXPORT BaseExc& operator= (std::stringstream& s);
|
|
|
|
IEX_EXPORT BaseExc& append (std::stringstream& s); // append (s.str())
|
|
IEX_EXPORT BaseExc& operator+= (std::stringstream& s);
|
|
|
|
//--------------------------------------------------
|
|
// These methods from the base class get obscured by
|
|
// the definitions above.
|
|
//--------------------------------------------------
|
|
|
|
IEX_EXPORT BaseExc& assign (const char* s);
|
|
IEX_EXPORT BaseExc& operator= (const char* s);
|
|
|
|
IEX_EXPORT BaseExc& append (const char* s);
|
|
IEX_EXPORT BaseExc& operator+= (const char* s);
|
|
|
|
//---------------------------------------------------
|
|
// Access to the string representation of the message
|
|
//---------------------------------------------------
|
|
|
|
IEX_EXPORT const std::string& message () const noexcept;
|
|
|
|
//--------------------------------------------------
|
|
// Stack trace for the point at which the exception
|
|
// was thrown. The stack trace will be an empty
|
|
// string unless a working stack-tracing routine
|
|
// has been installed (see below, setStackTracer()).
|
|
//--------------------------------------------------
|
|
|
|
IEX_EXPORT const std::string& stackTrace () const noexcept;
|
|
|
|
private:
|
|
std::string _message;
|
|
std::string _stackTrace;
|
|
};
|
|
|
|
//-----------------------------------------------------
|
|
// A macro to save typing when declararing an exception
|
|
// class derived directly or indirectly from BaseExc:
|
|
//-----------------------------------------------------
|
|
|
|
#define DEFINE_EXC_EXP(exp, name, base) \
|
|
class IEX_EXPORT_TYPE name : public base \
|
|
{ \
|
|
public: \
|
|
exp name (); \
|
|
exp name (const char* text); \
|
|
exp name (const std::string& text); \
|
|
exp name (std::string&& text); \
|
|
exp name (std::stringstream& text); \
|
|
exp name (const name& other); \
|
|
exp name (name&& other) noexcept; \
|
|
exp name& operator= (name& other); \
|
|
exp name& operator= (name&& other) noexcept; \
|
|
exp ~name () noexcept; \
|
|
};
|
|
|
|
#define DEFINE_EXC_EXP_IMPL(exp, name, base) \
|
|
exp name::name () : base () \
|
|
{} \
|
|
exp name::name (const char* text) : base (text) \
|
|
{} \
|
|
exp name::name (const std::string& text) : base (text) \
|
|
{} \
|
|
exp name::name (std::string&& text) : base (std::move (text)) \
|
|
{} \
|
|
exp name::name (std::stringstream& text) : base (text) \
|
|
{} \
|
|
exp name::name (const name& other) : base (other) \
|
|
{} \
|
|
exp name::name (name&& other) noexcept : base (other) \
|
|
{} \
|
|
exp name& name::operator= (name& other) \
|
|
{ \
|
|
base::operator= (other); \
|
|
return *this; \
|
|
} \
|
|
exp name& name::operator= (name&& other) noexcept \
|
|
{ \
|
|
base::operator= (other); \
|
|
return *this; \
|
|
} \
|
|
exp name::~name () noexcept \
|
|
{}
|
|
|
|
// For backward compatibility.
|
|
#define DEFINE_EXC(name, base) DEFINE_EXC_EXP (, name, base)
|
|
|
|
//--------------------------------------------------------
|
|
// Some exceptions which should be useful in most programs
|
|
//--------------------------------------------------------
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, ArgExc, BaseExc) // Invalid arguments to a function call
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, LogicExc, BaseExc) // General error in a program's logic,
|
|
// for example, a function was called
|
|
// in a context where the call does
|
|
// not make sense.
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, InputExc, BaseExc) // Invalid input data, e.g. from a file
|
|
|
|
DEFINE_EXC_EXP (IEX_EXPORT, IoExc, BaseExc) // Input or output operation failed
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, MathExc, BaseExc) // Arithmetic exception; more specific
|
|
// exceptions derived from this class
|
|
// are defined in ExcMath.h
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, ErrnoExc, BaseExc) // Base class for exceptions corresponding
|
|
// to errno values (see errno.h); more
|
|
// specific exceptions derived from this
|
|
// class are defined in ExcErrno.h
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, NoImplExc, BaseExc) // Missing method exception e.g. from a
|
|
// call to a method that is only partially
|
|
// or not at all implemented. A reminder
|
|
// to lazy software people to get back
|
|
// to work.
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, NullExc, BaseExc) // A pointer is inappropriately null.
|
|
|
|
DEFINE_EXC_EXP (
|
|
IEX_EXPORT, TypeExc, BaseExc) // An object is an inappropriate type,
|
|
// i.e. a dynamnic_cast failed.
|
|
|
|
//----------------------------------------------------------------------
|
|
// Stack-tracing support:
|
|
//
|
|
// setStackTracer(st)
|
|
//
|
|
// installs a stack-tracing routine, st, which will be called from
|
|
// class BaseExc's constructor every time an exception derived from
|
|
// BaseExc is thrown. The stack-tracing routine should return a
|
|
// string that contains a printable representation of the program's
|
|
// current call stack. This string will be stored in the BaseExc
|
|
// object; the string is accessible via the BaseExc::stackTrace()
|
|
// method.
|
|
//
|
|
// setStackTracer(0)
|
|
//
|
|
// removes the current stack tracing routine. When an exception
|
|
// derived from BaseExc is thrown, the stack trace string stored
|
|
// in the BaseExc object will be empty.
|
|
//
|
|
// stackTracer()
|
|
//
|
|
// returns a pointer to the current stack-tracing routine, or 0
|
|
// if there is no current stack stack-tracing routine.
|
|
//
|
|
//----------------------------------------------------------------------
|
|
|
|
typedef std::string (*StackTracer) ();
|
|
|
|
IEX_EXPORT void setStackTracer (StackTracer stackTracer);
|
|
IEX_EXPORT StackTracer stackTracer ();
|
|
|
|
IEX_INTERNAL_NAMESPACE_HEADER_EXIT
|
|
|
|
#endif // INCLUDED_IEXBASEEXC_H
|