1///////////////////////////////////////////////////////////////////////////
2//
3// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
4// Digital Ltd. LLC
5//
6// All rights reserved.
7//
8// Redistribution and use in source and binary forms, with or without
9// modification, are permitted provided that the following conditions are
10// met:
11// * Redistributions of source code must retain the above copyright
12// notice, this list of conditions and the following disclaimer.
13// * Redistributions in binary form must reproduce the above
14// copyright notice, this list of conditions and the following disclaimer
15// in the documentation and/or other materials provided with the
16// distribution.
17// * Neither the name of Industrial Light & Magic nor the names of
18// its contributors may be used to endorse or promote products derived
19// from this software without specific prior written permission.
20//
21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//
33///////////////////////////////////////////////////////////////////////////
34
35
36#ifndef INCLUDED_IEXBASEEXC_H
37#define INCLUDED_IEXBASEEXC_H
38
39#include "IexNamespace.h"
40#include "IexExport.h"
41
42//----------------------------------------------------------
43//
44// A general exception base class, and a few
45// useful exceptions derived from the base class.
46//
47//----------------------------------------------------------
48
49#include <string>
50#include <exception>
51#include <sstream>
52
53IEX_INTERNAL_NAMESPACE_HEADER_ENTER
54
55
56//-------------------------------
57// Our most basic exception class
58//-------------------------------
59
60class BaseExc: public std::exception
61{
62 public:
63
64 //----------------------------
65 // Constructors and destructor
66 //----------------------------
67
68 IEX_EXPORT BaseExc (const char *s = nullptr) throw(); // std::string (s)
69 IEX_EXPORT BaseExc (const std::string &s) throw(); // std::string (s)
70 IEX_EXPORT BaseExc (std::stringstream &s) throw(); // std::string (s.str())
71
72 IEX_EXPORT BaseExc (const BaseExc &be) throw();
73 IEX_EXPORT BaseExc (BaseExc &&be) throw();
74 IEX_EXPORT virtual ~BaseExc () throw ();
75
76 IEX_EXPORT BaseExc & operator = (const BaseExc& be) throw ();
77 IEX_EXPORT BaseExc & operator = (BaseExc&& be) throw ();
78
79 //---------------------------------------------------
80 // what() method -- e.what() returns _message.c_str()
81 //---------------------------------------------------
82
83 IEX_EXPORT virtual const char * what () const throw ();
84
85
86 //--------------------------------------------------
87 // Convenient methods to change the exception's text
88 //--------------------------------------------------
89
90 IEX_EXPORT BaseExc & assign (std::stringstream &s); // assign (s.str())
91 IEX_EXPORT BaseExc & operator = (std::stringstream &s);
92
93 IEX_EXPORT BaseExc & append (std::stringstream &s); // append (s.str())
94 IEX_EXPORT BaseExc & operator += (std::stringstream &s);
95
96
97 //--------------------------------------------------
98 // These methods from the base class get obscured by
99 // the definitions above.
100 //--------------------------------------------------
101
102 IEX_EXPORT BaseExc & assign (const char *s);
103 IEX_EXPORT BaseExc & operator = (const char *s);
104
105 IEX_EXPORT BaseExc & append (const char *s);
106 IEX_EXPORT BaseExc & operator += (const char *s);
107
108 //---------------------------------------------------
109 // Access to the string representation of the message
110 //---------------------------------------------------
111
112 IEX_EXPORT const std::string & message () const;
113
114 //--------------------------------------------------
115 // Stack trace for the point at which the exception
116 // was thrown. The stack trace will be an empty
117 // string unless a working stack-tracing routine
118 // has been installed (see below, setStackTracer()).
119 //--------------------------------------------------
120
121 IEX_EXPORT const std::string & stackTrace () const;
122
123 private:
124
125 std::string _message;
126 std::string _stackTrace;
127};
128
129
130//-----------------------------------------------------
131// A macro to save typing when declararing an exception
132// class derived directly or indirectly from BaseExc:
133//-----------------------------------------------------
134
135#define DEFINE_EXC_EXP(exp, name, base) \
136 class name: public base \
137 { \
138 public: \
139 exp name() throw(); \
140 exp name (const char* text) throw(); \
141 exp name (const std::string &text) throw(); \
142 exp name (std::stringstream &text) throw(); \
143 exp name (const name &other) throw(); \
144 exp name (name &&other) throw(); \
145 exp name& operator = (name &other) throw(); \
146 exp name& operator = (name &&other) throw(); \
147 exp ~name() throw(); \
148 };
149
150#define DEFINE_EXC_EXP_IMPL(exp, name, base) \
151exp name::name () throw () : base () {} \
152exp name::name (const char* text) throw () : base (text) {} \
153exp name::name (const std::string& text) throw () : base (text) {} \
154exp name::name (std::stringstream& text) throw () : base (text) {} \
155exp name::name (const name &other) throw() : base (other) {} \
156exp name::name (name &&other) throw() : base (other) {} \
157exp name& name::operator = (name &other) throw() { base::operator=(other); return *this; } \
158exp name& name::operator = (name &&other) throw() { base::operator=(other); return *this; } \
159exp name::~name () throw () {}
160
161// For backward compatibility.
162#define DEFINE_EXC(name, base) DEFINE_EXC_EXP(, name, base)
163
164
165//--------------------------------------------------------
166// Some exceptions which should be useful in most programs
167//--------------------------------------------------------
168DEFINE_EXC_EXP (IEX_EXPORT, ArgExc, BaseExc) // Invalid arguments to a function call
169
170DEFINE_EXC_EXP (IEX_EXPORT, LogicExc, BaseExc) // General error in a program's logic,
171 // for example, a function was called
172 // in a context where the call does
173 // not make sense.
174
175DEFINE_EXC_EXP (IEX_EXPORT, InputExc, BaseExc) // Invalid input data, e.g. from a file
176
177DEFINE_EXC_EXP (IEX_EXPORT, IoExc, BaseExc) // Input or output operation failed
178
179DEFINE_EXC_EXP (IEX_EXPORT, MathExc, BaseExc) // Arithmetic exception; more specific
180 // exceptions derived from this class
181 // are defined in ExcMath.h
182
183DEFINE_EXC_EXP (IEX_EXPORT, ErrnoExc, BaseExc) // Base class for exceptions corresponding
184 // to errno values (see errno.h); more
185 // specific exceptions derived from this
186 // class are defined in ExcErrno.h
187
188DEFINE_EXC_EXP (IEX_EXPORT, NoImplExc, BaseExc) // Missing method exception e.g. from a
189 // call to a method that is only partially
190 // or not at all implemented. A reminder
191 // to lazy software people to get back
192 // to work.
193
194DEFINE_EXC_EXP (IEX_EXPORT, NullExc, BaseExc) // A pointer is inappropriately null.
195
196DEFINE_EXC_EXP (IEX_EXPORT, TypeExc, BaseExc) // An object is an inappropriate type,
197 // i.e. a dynamnic_cast failed.
198
199
200//----------------------------------------------------------------------
201// Stack-tracing support:
202//
203// setStackTracer(st)
204//
205// installs a stack-tracing routine, st, which will be called from
206// class BaseExc's constructor every time an exception derived from
207// BaseExc is thrown. The stack-tracing routine should return a
208// string that contains a printable representation of the program's
209// current call stack. This string will be stored in the BaseExc
210// object; the string is accesible via the BaseExc::stackTrace()
211// method.
212//
213// setStackTracer(0)
214//
215// removes the current stack tracing routine. When an exception
216// derived from BaseExc is thrown, the stack trace string stored
217// in the BaseExc object will be empty.
218//
219// stackTracer()
220//
221// returns a pointer to the current stack-tracing routine, or 0
222// if there is no current stack stack-tracing routine.
223//
224//----------------------------------------------------------------------
225
226typedef std::string (* StackTracer) ();
227
228IEX_EXPORT void setStackTracer (StackTracer stackTracer);
229IEX_EXPORT StackTracer stackTracer ();
230
231
232IEX_INTERNAL_NAMESPACE_HEADER_EXIT
233
234#endif // INCLUDED_IEXBASEEXC_H
235

source code of include/OpenEXR/IexBaseExc.h