1 /////////////////////////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2002, 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 37 #ifndef INCLUDED_IEXBASEEXC_H 38 #define INCLUDED_IEXBASEEXC_H 39 40 41 //---------------------------------------------------------- 42 // 43 // A general exception base class, and a few 44 // useful exceptions derived from the base class. 45 // 46 //---------------------------------------------------------- 47 48 #include <string> 49 #include <exception> 50 #include <sstream> 51 52 namespace Iex { 53 54 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER 55 // Tell MS VC++ to suppress exception specification warnings 56 #pragma warning(disable:4290) 57 #endif 58 59 //------------------------------- 60 // Our most basic exception class 61 //------------------------------- 62 63 class BaseExc: public std::string, public std::exception 64 { 65 public: 66 67 //---------------------------- 68 // Constructors and destructor 69 //---------------------------- 70 71 BaseExc (const char *s = 0) throw(); // std::string (s) 72 BaseExc (const std::string &s) throw(); // std::string (s) 73 BaseExc (std::stringstream &s) throw(); // std::string (s.str()) 74 75 BaseExc (const BaseExc &be) throw(); 76 virtual ~BaseExc () throw (); 77 78 //-------------------------------------------- 79 // what() method -- e.what() returns e.c_str() 80 //-------------------------------------------- 81 82 virtual const char * what () const throw (); 83 84 85 //-------------------------------------------------- 86 // Convenient methods to change the exception's text 87 //-------------------------------------------------- 88 89 BaseExc & assign (std::stringstream &s); // assign (s.str()) 90 BaseExc & operator = (std::stringstream &s); 91 92 BaseExc & append (std::stringstream &s); // append (s.str()) 93 BaseExc & operator += (std::stringstream &s); 94 95 96 //-------------------------------------------------- 97 // These methods from the base class get obscured by 98 // the definitions above. 99 //-------------------------------------------------- 100 101 BaseExc & assign (const char *s); 102 BaseExc & operator = (const char *s); 103 104 BaseExc & append (const char *s); 105 BaseExc & operator += (const char *s); 106 107 108 //-------------------------------------------------- 109 // Stack trace for the point at which the exception 110 // was thrown. The stack trace will be an empty 111 // string unless a working stack-tracing routine 112 // has been installed (see below, setStackTracer()). 113 //-------------------------------------------------- 114 115 const std::string & stackTrace () const; 116 117 private: 118 119 std::string _stackTrace; 120 }; 121 122 123 //----------------------------------------------------- 124 // A macro to save typing when declararing an exception 125 // class derived directly or indirectly from BaseExc: 126 //----------------------------------------------------- 127 128 #define DEFINE_EXC(name, base) \ 129 class name: public base \ 130 { \ 131 public: \ 132 name (const char* text=0) throw(): base (text) {} \ 133 name (const std::string &text) throw(): base (text) {} \ 134 name (std::stringstream &text) throw(): base (text) {} \ 135 }; 136 137 138 //-------------------------------------------------------- 139 // Some exceptions which should be useful in most programs 140 //-------------------------------------------------------- 141 142 DEFINE_EXC (ArgExc, BaseExc) // Invalid arguments to a function call 143 144 DEFINE_EXC (LogicExc, BaseExc) // General error in a program's logic, 145 // for example, a function was called 146 // in a context where the call does 147 // not make sense. 148 149 DEFINE_EXC (InputExc, BaseExc) // Invalid input data, e.g. from a file 150 151 DEFINE_EXC (IoExc, BaseExc) // Input or output operation failed 152 153 DEFINE_EXC (MathExc, BaseExc) // Arithmetic exception; more specific 154 // exceptions derived from this class 155 // are defined in ExcMath.h 156 157 DEFINE_EXC (ErrnoExc, BaseExc) // Base class for exceptions corresponding 158 // to errno values (see errno.h); more 159 // specific exceptions derived from this 160 // class are defined in ExcErrno.h 161 162 DEFINE_EXC (NoImplExc, BaseExc) // Missing method exception e.g. from a 163 // call to a method that is only partially 164 // or not at all implemented. A reminder 165 // to lazy software people to get back 166 // to work. 167 168 DEFINE_EXC (NullExc, BaseExc) // A pointer is inappropriately null. 169 170 DEFINE_EXC (TypeExc, BaseExc) // An object is an inappropriate type, 171 // i.e. a dynamnic_cast failed. 172 173 174 //---------------------------------------------------------------------- 175 // Stack-tracing support: 176 // 177 // setStackTracer(st) 178 // 179 // installs a stack-tracing routine, st, which will be called from 180 // class BaseExc's constructor every time an exception derived from 181 // BaseExc is thrown. The stack-tracing routine should return a 182 // string that contains a printable representation of the program's 183 // current call stack. This string will be stored in the BaseExc 184 // object; the string is accesible via the BaseExc::stackTrace() 185 // method. 186 // 187 // setStackTracer(0) 188 // 189 // removes the current stack tracing routine. When an exception 190 // derived from BaseExc is thrown, the stack trace string stored 191 // in the BaseExc object will be empty. 192 // 193 // stackTracer() 194 // 195 // returns a pointer to the current stack-tracing routine, or 0 196 // if there is no current stack stack-tracing routine. 197 // 198 //---------------------------------------------------------------------- 199 200 typedef std::string (* StackTracer) (); 201 202 void setStackTracer (StackTracer stackTracer); 203 StackTracer stackTracer (); 204 205 206 //----------------- 207 // Inline functions 208 //----------------- 209 210 inline BaseExc & 211 BaseExc::operator = (std::stringstream &s) 212 { 213 return assign (s); 214 } 215 216 217 inline BaseExc & 218 BaseExc::operator += (std::stringstream &s) 219 { 220 return append (s); 221 } 222 223 224 inline BaseExc & 225 BaseExc::assign (const char *s) 226 { 227 std::string::assign(s); 228 return *this; 229 } 230 231 232 inline BaseExc & 233 BaseExc::operator = (const char *s) 234 { 235 return assign(s); 236 } 237 238 239 inline BaseExc & 240 BaseExc::append (const char *s) 241 { 242 std::string::append(s); 243 return *this; 244 } 245 246 247 inline BaseExc & 248 BaseExc::operator += (const char *s) 249 { 250 return append(s); 251 } 252 253 254 inline const std::string & 255 BaseExc::stackTrace () const 256 { 257 return _stackTrace; 258 } 259 260 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER 261 #pragma warning(default:4290) 262 #endif 263 264 } // namespace Iex 265 266 #endif 267
