Magick++: Exception.h Source File

Magick++ 7.0.10

Exception.h
Go to the documentation of this file.
1 // This may look like C code, but it is really -*- C++ -*-
2 //
3 // Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
4 // Copyright Dirk Lemstra 2014-2015
5 //
6 // Definition of Magick::Exception and derived classes
7 // Magick::Warning* and Magick::Error*. Derived from C++ STD
8 // 'exception' class for convenience.
9 //
10 // These classes form part of the Magick++ user interface.
11 //
12
13 #if !defined(Magick_Exception_header)
14 #define Magick_Exception_header
15
16 #include "Magick++/Include.h"
17 #include <string>
18 #include <exception>
19
20 namespace Magick
21 {
22 class MagickPPExport Exception: public std::exception
23 {
24 public:
25
26 // Construct with message string
27 Exception(const std::string& what_);
28
29 // Construct with message string and nested exception
30 Exception(const std::string& what_, Exception* nested_);
31
32 // Copy constructor
33 Exception(const Exception& original_);
34
35 // Destructor
36 virtual ~Exception() throw();
37
38 // Assignment operator
39 Exception& operator=(const Exception& original_);
40
41 // Get string identifying exception
42 virtual const char* what() const throw();
43
44 // Get nested exception
45 const Exception* nested() const throw();
46
48 //
49 // No user-serviceable parts beyond this point
50 //
52
53 void nested(Exception* nested_) throw();
54
55 private:
56 std::string _what;
57 Exception* _nested;
58 };
59
60 //
61 // Error exceptions
62 //
63
64 class MagickPPExport Error: public Exception
65 {
66 public:
67 explicit Error(const std::string& what_);
68 explicit Error(const std::string& what_,Exception *nested_);
69 ~Error() throw();
70 };
71
72 class MagickPPExport ErrorBlob: public Error
73 {
74 public:
75 explicit ErrorBlob(const std::string& what_);
76 explicit ErrorBlob(const std::string& what_,Exception *nested_);
77 ~ErrorBlob() throw();
78 };
79
80 class MagickPPExport ErrorCache: public Error
81 {
82 public:
83 explicit ErrorCache(const std::string& what_);
84 explicit ErrorCache(const std::string& what_,Exception *nested_);
85 ~ErrorCache() throw();
86 };
87
88 class MagickPPExport ErrorCoder: public Error
89 {
90 public:
91 explicit ErrorCoder(const std::string& what_);
92 explicit ErrorCoder(const std::string& what_,Exception *nested_);
93 ~ErrorCoder() throw();
94 };
95
96 class MagickPPExport ErrorConfigure: public Error
97 {
98 public:
99 explicit ErrorConfigure(const std::string& what_);
100 explicit ErrorConfigure(const std::string& what_,Exception *nested_);
101 ~ErrorConfigure() throw();
102 };
103
104 class MagickPPExport ErrorCorruptImage: public Error
105 {
106 public:
107 explicit ErrorCorruptImage(const std::string& what_);
108 explicit ErrorCorruptImage(const std::string& what_,Exception *nested_);
109 ~ErrorCorruptImage() throw();
110 };
111
112 class MagickPPExport ErrorDelegate: public Error
113 {
114 public:
115 explicit ErrorDelegate(const std::string& what_);
116 explicit ErrorDelegate(const std::string& what_,Exception *nested_);
117 ~ErrorDelegate() throw();
118 };
119
120 class MagickPPExport ErrorDraw: public Error
121 {
122 public:
123 explicit ErrorDraw(const std::string& what_);
124 explicit ErrorDraw(const std::string& what_,Exception *nested_);
125 ~ErrorDraw() throw();
126 };
127
128 class MagickPPExport ErrorFileOpen: public Error
129 {
130 public:
131 explicit ErrorFileOpen(const std::string& what_);
132 explicit ErrorFileOpen(const std::string& what_,Exception *nested_);
133 ~ErrorFileOpen() throw();
134 };
135
136 class MagickPPExport ErrorImage: public Error
137 {
138 public:
139 explicit ErrorImage(const std::string& what_);
140 explicit ErrorImage(const std::string& what_,Exception *nested_);
141 ~ErrorImage() throw();
142 };
143
144 class MagickPPExport ErrorMissingDelegate: public Error
145 {
146 public:
147 explicit ErrorMissingDelegate(const std::string& what_);
148 explicit ErrorMissingDelegate(const std::string& what_,Exception *nested_);
149 ~ErrorMissingDelegate() throw();
150 };
151
152 class MagickPPExport ErrorModule: public Error
153 {
154 public:
155 explicit ErrorModule(const std::string& what_);
156 explicit ErrorModule(const std::string& what_,Exception *nested_);
157 ~ErrorModule() throw();
158 };
159
160 class MagickPPExport ErrorMonitor: public Error
161 {
162 public:
163 explicit ErrorMonitor(const std::string& what_);
164 explicit ErrorMonitor(const std::string& what_,Exception *nested_);
165 ~ErrorMonitor() throw();
166 };
167
168 class MagickPPExport ErrorOption: public Error
169 {
170 public:
171 explicit ErrorOption(const std::string& what_);
172 explicit ErrorOption(const std::string& what_,Exception *nested_);
173 ~ErrorOption() throw();
174 };
175
176 class MagickPPExport ErrorPolicy: public Error
177 {
178 public:
179 explicit ErrorPolicy(const std::string& what_);
180 explicit ErrorPolicy(const std::string& what_,Exception *nested_);
181 ~ErrorPolicy() throw();
182 };
183
184 class MagickPPExport ErrorRegistry: public Error
185 {
186 public:
187 explicit ErrorRegistry(const std::string& what_);
188 explicit ErrorRegistry(const std::string& what_,Exception *nested_);
189 ~ErrorRegistry() throw();
190 };
191
192 class MagickPPExport ErrorResourceLimit: public Error
193 {
194 public:
195 explicit ErrorResourceLimit(const std::string& what_);
196 explicit ErrorResourceLimit(const std::string& what_,Exception *nested_);
197 ~ErrorResourceLimit() throw();
198 };
199
200 class MagickPPExport ErrorStream: public Error
201 {
202 public:
203 explicit ErrorStream(const std::string& what_);
204 explicit ErrorStream(const std::string& what_,Exception *nested_);
205 ~ErrorStream() throw();
206 };
207
208 class MagickPPExport ErrorType: public Error
209 {
210 public:
211 explicit ErrorType(const std::string& what_);
212 explicit ErrorType(const std::string& what_,Exception *nested_);
213 ~ErrorType() throw();
214 };
215
216 class MagickPPExport ErrorUndefined: public Error
217 {
218 public:
219 explicit ErrorUndefined(const std::string& what_);
220 explicit ErrorUndefined(const std::string& what_,Exception *nested_);
221 ~ErrorUndefined() throw();
222 };
223
224 class MagickPPExport ErrorXServer: public Error
225 {
226 public:
227 explicit ErrorXServer(const std::string& what_);
228 explicit ErrorXServer(const std::string& what_,Exception *nested_);
229 ~ErrorXServer() throw();
230 };
231
232 //
233 // Warnings
234 //
235
236 class MagickPPExport Warning: public Exception
237 {
238 public:
239 explicit Warning(const std::string& what_);
240 explicit Warning(const std::string& what_,Exception *nested_);
241 ~Warning() throw();
242 };
243
244 class MagickPPExport WarningBlob: public Warning
245 {
246 public:
247 explicit WarningBlob(const std::string& what_);
248 explicit WarningBlob(const std::string& what_,Exception *nested_);
249 ~WarningBlob() throw();
250 };
251
252 class MagickPPExport WarningCache: public Warning
253 {
254 public:
255 explicit WarningCache(const std::string& what_);
256 explicit WarningCache(const std::string& what_,Exception *nested_);
257 ~WarningCache() throw();
258 };
259
260 class MagickPPExport WarningCoder: public Warning
261 {
262 public:
263 explicit WarningCoder(const std::string& what_);
264 explicit WarningCoder(const std::string& what_,Exception *nested_);
265 ~WarningCoder() throw();
266 };
267
268 class MagickPPExport WarningConfigure: public Warning
269 {
270 public:
271 explicit WarningConfigure(const std::string& what_);
272 explicit WarningConfigure(const std::string& what_,Exception *nested_);
273 ~WarningConfigure() throw();
274 };
275
276 class MagickPPExport WarningCorruptImage: public Warning
277 {
278 public:
279 explicit WarningCorruptImage(const std::string& what_);
280 explicit WarningCorruptImage(const std::string& what_,Exception *nested_);
281 ~WarningCorruptImage() throw();
282 };
283
284 class MagickPPExport WarningDelegate: public Warning
285 {
286 public:
287 explicit WarningDelegate(const std::string& what_);
288 explicit WarningDelegate(const std::string& what_,Exception *nested_);
289 ~WarningDelegate() throw();
290 };
291
292 class MagickPPExport WarningDraw : public Warning
293 {
294 public:
295 explicit WarningDraw(const std::string& what_);
296 explicit WarningDraw(const std::string& what_,Exception *nested_);
297 ~WarningDraw() throw();
298 };
299
300 class MagickPPExport WarningFileOpen: public Warning
301 {
302 public:
303 explicit WarningFileOpen(const std::string& what_);
304 explicit WarningFileOpen(const std::string& what_,Exception *nested_);
305 ~WarningFileOpen() throw();
306 };
307
308 class MagickPPExport WarningImage: public Warning
309 {
310 public:
311 explicit WarningImage(const std::string& what_);
312 explicit WarningImage(const std::string& what_,Exception *nested_);
313 ~WarningImage() throw();
314 };
315
316 class MagickPPExport WarningMissingDelegate: public Warning
317 {
318 public:
319 explicit WarningMissingDelegate(const std::string& what_);
320 explicit WarningMissingDelegate(const std::string& what_,
321 Exception *nested_);
322 ~WarningMissingDelegate() throw();
323 };
324
325 class MagickPPExport WarningModule: public Warning
326 {
327 public:
328 explicit WarningModule(const std::string& what_);
329 explicit WarningModule(const std::string& what_,Exception *nested_);
330 ~WarningModule() throw();
331 };
332
333 class MagickPPExport WarningMonitor: public Warning
334 {
335 public:
336 explicit WarningMonitor(const std::string& what_);
337 explicit WarningMonitor(const std::string& what_,Exception *nested_);
338 ~WarningMonitor() throw();
339 };
340
341 class MagickPPExport WarningOption: public Warning
342 {
343 public:
344 explicit WarningOption(const std::string& what_);
345 explicit WarningOption(const std::string& what_,Exception *nested_);
346 ~WarningOption() throw();
347 };
348
349 class MagickPPExport WarningPolicy: public Warning
350 {
351 public:
352 explicit WarningPolicy(const std::string& what_);
353 explicit WarningPolicy(const std::string& what_,Exception *nested_);
354 ~WarningPolicy() throw();
355 };
356
357 class MagickPPExport WarningRegistry: public Warning
358 {
359 public:
360 explicit WarningRegistry(const std::string& what_);
361 explicit WarningRegistry(const std::string& what_,Exception *nested_);
362 ~WarningRegistry() throw();
363 };
364
365 class MagickPPExport WarningResourceLimit: public Warning
366 {
367 public:
368 explicit WarningResourceLimit(const std::string& what_);
369 explicit WarningResourceLimit(const std::string& what_,Exception *nested_);
370 ~WarningResourceLimit() throw();
371 };
372
373 class MagickPPExport WarningStream: public Warning
374 {
375 public:
376 explicit WarningStream(const std::string& what_);
377 explicit WarningStream(const std::string& what_,Exception *nested_);
378 ~WarningStream() throw();
379 };
380
381 class MagickPPExport WarningType: public Warning
382 {
383 public:
384 explicit WarningType(const std::string& what_);
385 explicit WarningType(const std::string& what_,Exception *nested_);
386 ~WarningType() throw();
387 };
388
389 class MagickPPExport WarningUndefined: public Warning
390 {
391 public:
392 explicit WarningUndefined(const std::string& what_);
393 explicit WarningUndefined(const std::string& what_,Exception *nested_);
394 ~WarningUndefined() throw();
395 };
396
397 class MagickPPExport WarningXServer: public Warning
398 {
399 public:
400 explicit WarningXServer(const std::string& what_);
401 explicit WarningXServer(const std::string& what_,Exception *nested_);
402 ~WarningXServer() throw();
403 };
404
405 //
406 // No user-serviceable components beyond this point.
407 //
408
409 std::string formatExceptionMessage(
410 const MagickCore::ExceptionInfo *exception_);
411
412 Exception* createException(const MagickCore::ExceptionInfo *exception_);
413
414 // Throw exception based on raw data
415 extern MagickPPExport void throwExceptionExplicit(
416 const MagickCore::ExceptionType severity_,const char* reason_,
417 const char* description_=(char *) NULL);
418
419 // Thow exception based on ImageMagick's ExceptionInfo
420 extern MagickPPExport void throwException(
421 MagickCore::ExceptionInfo *exception_,const bool quiet_=false);
422
423 } // namespace Magick
424
425 #endif // Magick_Exception_header
Magick::WarningFileOpen
Definition: Exception.h:300
Magick::WarningCoder
Definition: Exception.h:260
Magick::ErrorImage
Definition: Exception.h:136
Magick::WarningRegistry
Definition: Exception.h:357
Magick::WarningMissingDelegate
Definition: Exception.h:316
Magick::ErrorDraw
Definition: Exception.h:120
Magick::WarningXServer
Definition: Exception.h:397
Magick::Error
Definition: Exception.h:64
Magick::ErrorDelegate
Definition: Exception.h:112
Magick::ErrorMonitor
Definition: Exception.h:160
Magick::ErrorFileOpen
Definition: Exception.h:128
Magick::ErrorOption
Definition: Exception.h:168
Magick::ErrorConfigure
Definition: Exception.h:96
Magick::WarningUndefined
Definition: Exception.h:389
Magick::WarningMonitor
Definition: Exception.h:333
Magick::WarningPolicy
Definition: Exception.h:349
Magick::formatExceptionMessage
std::string formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:685
Magick::throwException
MagickPPExport void throwException(MagickCore::ExceptionInfo *exception_, const bool quiet_=false)
Magick::ErrorBlob
Definition: Exception.h:72
Magick::WarningOption
Definition: Exception.h:341
Magick::WarningBlob
Definition: Exception.h:244
Magick::ErrorResourceLimit
Definition: Exception.h:192
Magick::ErrorRegistry
Definition: Exception.h:184
Magick::ErrorCorruptImage
Definition: Exception.h:104
Magick::ErrorXServer
Definition: Exception.h:224
MagickPPExport
#define MagickPPExport
Definition: Include.h:281
Magick::Warning
Definition: Exception.h:236
Magick::Exception
Definition: Exception.h:22
Magick::WarningCache
Definition: Exception.h:252
Magick::ErrorModule
Definition: Exception.h:152
Magick::WarningCorruptImage
Definition: Exception.h:276
Magick::throwExceptionExplicit
MagickPPExport void throwExceptionExplicit(const MagickCore::ExceptionType severity_, const char *reason_, const char *description_=(char *) NULL)
Definition: Exception.cpp:806
Magick::WarningResourceLimit
Definition: Exception.h:365
Magick::ErrorPolicy
Definition: Exception.h:176
Magick::WarningType
Definition: Exception.h:381
Magick::ErrorCoder
Definition: Exception.h:88
Include.h
Magick::ErrorMissingDelegate
Definition: Exception.h:144
Magick::WarningImage
Definition: Exception.h:308
Magick::WarningDelegate
Definition: Exception.h:284
Magick::ErrorType
Definition: Exception.h:208
Magick
Definition: Blob.h:15
Magick::WarningConfigure
Definition: Exception.h:268
Magick::WarningModule
Definition: Exception.h:325
Magick::ErrorStream
Definition: Exception.h:200
Magick::ErrorUndefined
Definition: Exception.h:216
Magick::createException
Exception * createException(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:700
Magick::ErrorCache
Definition: Exception.h:80
Magick::WarningDraw
Definition: Exception.h:292
Magick::WarningStream
Definition: Exception.h:373