Magick++  7.0.8
Convert, Edit, Or Compose Bitmap Images
Exception.cpp
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-2017
5 //
6 // Implementation of Exception and derived classes
7 //
8 
9 #define MAGICKCORE_IMPLEMENTATION 1
10 #define MAGICK_PLUSPLUS_IMPLEMENTATION 1
11 
12 #include "Magick++/Include.h"
13 #include <string>
14 #include <errno.h>
15 #include <string.h>
16 
17 using namespace std;
18 
19 #include "Magick++/Exception.h"
20 
21 Magick::Exception::Exception(const std::string& what_)
22  : std::exception(),
23  _what(what_),
24  _nested((Exception *) NULL)
25 {
26 }
27 
28 Magick::Exception::Exception(const std::string& what_,
29  Exception* nested_)
30  : std::exception(),
31  _what(what_),
32  _nested(nested_)
33 {
34 }
35 
37  : exception(original_),
38  _what(original_._what),
39  _nested((Exception *) NULL)
40 {
41 }
42 
44 {
45  if (_nested != (Exception *) NULL)
46  delete _nested;
47 }
48 
50  const Magick::Exception& original_)
51 {
52  if (this != &original_)
53  this->_what=original_._what;
54  return(*this);
55 }
56 
57 const char* Magick::Exception::what() const throw()
58 {
59  return(_what.c_str());
60 }
61 
63 {
64  return(_nested);
65 }
66 
67 void Magick::Exception::nested(Exception* nested_) throw()
68 {
69  _nested=nested_;
70 }
71 
72 Magick::Error::Error(const std::string& what_)
73  : Exception(what_)
74 {
75 }
76 
77 Magick::Error::Error(const std::string& what_,Exception *nested_)
78  : Exception(what_,nested_)
79 {
80 }
81 
83 {
84 }
85 
86 Magick::ErrorBlob::ErrorBlob(const std::string& what_)
87  : Error(what_)
88 {
89 }
90 
91 Magick::ErrorBlob::ErrorBlob(const std::string& what_,Exception *nested_)
92  : Error(what_,nested_)
93 {
94 }
95 
97 {
98 }
99 
100 Magick::ErrorCache::ErrorCache(const std::string& what_)
101  : Error(what_)
102 {
103 }
104 
105 Magick::ErrorCache::ErrorCache(const std::string& what_,Exception *nested_)
106  : Error(what_,nested_)
107 {
108 }
109 
111 {
112 }
113 
114 Magick::ErrorCoder::ErrorCoder(const std::string& what_)
115  : Error(what_)
116 {
117 }
118 
119 Magick::ErrorCoder::ErrorCoder(const std::string& what_,Exception *nested_)
120  : Error(what_,nested_)
121 {
122 }
123 
125 {
126 }
127 
128 Magick::ErrorConfigure::ErrorConfigure(const std::string& what_)
129  : Error(what_)
130 {
131 }
132 
133 Magick::ErrorConfigure::ErrorConfigure(const std::string& what_,
134  Exception *nested_)
135  : Error(what_,nested_)
136 {
137 }
138 
140 {
141 }
142 
144  : Error(what_)
145 {
146 }
147 
149  Exception *nested_)
150  : Error(what_,nested_)
151 {
152 }
153 
155 {
156 }
157 
158 Magick::ErrorDelegate::ErrorDelegate(const std::string& what_)
159  : Error(what_)
160 {
161 }
162 
163 Magick::ErrorDelegate::ErrorDelegate(const std::string& what_,
164  Exception *nested_)
165  : Error(what_,nested_)
166 {
167 }
168 
170 {
171 }
172 
173 Magick::ErrorDraw::ErrorDraw(const std::string& what_)
174  : Error(what_)
175 {
176 }
177 
178 Magick::ErrorDraw::ErrorDraw(const std::string& what_,Exception *nested_)
179  : Error(what_,nested_)
180 {
181 }
182 
184 {
185 }
186 
187 Magick::ErrorFileOpen::ErrorFileOpen(const std::string& what_)
188  : Error(what_)
189 {
190 }
191 
193 {
194 }
195 
196 Magick::ErrorFileOpen::ErrorFileOpen(const std::string& what_,
197  Exception *nested_)
198  : Error(what_,nested_)
199 {
200 }
201 
202 
203 Magick::ErrorImage::ErrorImage(const std::string& what_)
204  : Error(what_)
205 {
206 }
207 
208 Magick::ErrorImage::ErrorImage(const std::string& what_,Exception *nested_)
209  : Error(what_,nested_)
210 {
211 }
212 
214 {
215 }
216 
218  : Error(what_)
219 {
220 }
221 
223  Exception *nested_)
224  : Error(what_,nested_)
225 {
226 }
227 
229 {
230 }
231 
232 Magick::ErrorModule::ErrorModule(const std::string& what_)
233  : Error(what_)
234 {
235 }
236 
237 Magick::ErrorModule::ErrorModule(const std::string& what_,Exception *nested_)
238  : Error(what_,nested_)
239 {
240 }
241 
243 {
244 }
245 
246 Magick::ErrorMonitor::ErrorMonitor(const std::string& what_)
247  : Error(what_)
248 {
249 }
250 
251 Magick::ErrorMonitor::ErrorMonitor(const std::string& what_,Exception *nested_)
252  : Error(what_,nested_)
253 {
254 }
255 
257 {
258 }
259 
260 Magick::ErrorOption::ErrorOption(const std::string& what_)
261  : Error(what_)
262 {
263 }
264 
265 Magick::ErrorOption::ErrorOption(const std::string& what_,Exception *nested_)
266  : Error(what_,nested_)
267 {
268 }
269 
271 {
272 }
273 
274 Magick::ErrorPolicy::ErrorPolicy(const std::string& what_)
275  : Error(what_)
276 {
277 }
278 
279 Magick::ErrorPolicy::ErrorPolicy(const std::string& what_,Exception *nested_)
280  : Error(what_,nested_)
281 {
282 }
283 
285 {
286 }
287 
288 
289 Magick::ErrorRegistry::ErrorRegistry(const std::string& what_)
290  : Error(what_)
291 {
292 }
293 
294 Magick::ErrorRegistry::ErrorRegistry(const std::string& what_,
295  Exception *nested_)
296  : Error(what_,nested_)
297 {
298 }
299 
301 {
302 }
303 
305  : Error(what_)
306 {
307 }
308 
310  Exception *nested_)
311  : Error(what_,nested_)
312 {
313 }
314 
316 {
317 }
318 
319 Magick::ErrorStream::ErrorStream(const std::string& what_)
320  : Error(what_)
321 {
322 }
323 
324 Magick::ErrorStream::ErrorStream(const std::string& what_,Exception *nested_)
325  : Error(what_,nested_)
326 {
327 }
328 
330 {
331 }
332 
333 Magick::ErrorType::ErrorType(const std::string& what_)
334  : Error(what_)
335 {
336 }
337 
338 Magick::ErrorType::ErrorType(const std::string& what_,Exception *nested_)
339  : Error(what_,nested_)
340 {
341 }
342 
344 {
345 }
346 
347 Magick::ErrorUndefined::ErrorUndefined(const std::string& what_)
348  : Error(what_)
349 {
350 }
351 
352 Magick::ErrorUndefined::ErrorUndefined(const std::string& what_,
353  Exception *nested_)
354  : Error(what_,nested_)
355 {
356 }
357 
359 {
360 }
361 
362 Magick::ErrorXServer::ErrorXServer(const std::string& what_)
363  : Error(what_)
364 {
365 }
366 
367 Magick::ErrorXServer::ErrorXServer(const std::string& what_,Exception *nested_)
368  : Error(what_,nested_)
369 {
370 }
371 
373 {
374 }
375 
376 Magick::Warning::Warning(const std::string& what_)
377  : Exception(what_)
378 {
379 }
380 
381 Magick::Warning::Warning(const std::string& what_,Exception *nested_)
382  : Exception(what_,nested_)
383 {
384 }
385 
387 {
388 }
389 
390 Magick::WarningBlob::WarningBlob(const std::string& what_)
391  : Warning(what_)
392 {
393 }
394 
395 Magick::WarningBlob::WarningBlob(const std::string& what_,Exception *nested_)
396  : Warning(what_,nested_)
397 {
398 }
399 
401 {
402 }
403 
404 Magick::WarningCache::WarningCache(const std::string& what_)
405  : Warning(what_)
406 {
407 }
408 
409 Magick::WarningCache::WarningCache(const std::string& what_,Exception *nested_)
410  : Warning(what_,nested_)
411 {
412 }
413 
415 {
416 }
417 
418 Magick::WarningCoder::WarningCoder(const std::string& what_)
419  : Warning(what_)
420 {
421 }
422 
423 Magick::WarningCoder::WarningCoder(const std::string& what_,Exception *nested_)
424  : Warning(what_,nested_)
425 {
426 }
427 
429 {
430 }
431 
433  : Warning(what_)
434 {
435 }
436 
438  Exception *nested_)
439  : Warning(what_,nested_)
440 {
441 }
442 
444 {
445 }
446 
448  : Warning(what_)
449 {
450 }
451 
453  Exception *nested_)
454  : Warning(what_,nested_)
455 {
456 }
457 
459 {
460 }
461 
463  : Warning(what_)
464 {
465 }
466 
468  Exception *nested_)
469  : Warning(what_,nested_)
470 {
471 }
472 
474 {
475 }
476 
477 Magick::WarningDraw::WarningDraw(const std::string& what_)
478  : Warning(what_)
479 {
480 }
481 
482 Magick::WarningDraw::WarningDraw(const std::string& what_,Exception *nested_)
483  : Warning(what_,nested_)
484 {
485 }
486 
488 {
489 }
490 
492  : Warning(what_)
493 {
494 }
495 
497  Exception *nested_)
498  : Warning(what_,nested_)
499 {
500 }
501 
503 {
504 }
505 
506 Magick::WarningImage::WarningImage(const std::string& what_)
507  : Warning(what_)
508 {
509 }
510 
511 Magick::WarningImage::WarningImage(const std::string& what_,Exception *nested_)
512  : Warning(what_,nested_)
513 {
514 }
515 
517 {
518 }
519 
521  const std::string& what_)
522  : Warning(what_)
523 {
524 }
525 
527  const std::string& what_,Exception *nested_)
528  : Warning(what_,nested_)
529 {
530 }
531 
533 {
534 }
535 
536 Magick::WarningModule::WarningModule(const std::string& what_)
537  : Warning(what_)
538 {
539 }
540 
541 Magick::WarningModule::WarningModule(const std::string& what_,
542  Exception *nested_)
543  : Warning(what_,nested_)
544 {
545 }
546 
547 
549 {
550 }
551 
552 Magick::WarningMonitor::WarningMonitor(const std::string& what_)
553  : Warning(what_)
554 {
555 }
556 
557 Magick::WarningMonitor::WarningMonitor(const std::string& what_,
558  Exception *nested_)
559  : Warning(what_,nested_)
560 {
561 }
562 
564 {
565 }
566 
567 Magick::WarningOption::WarningOption(const std::string& what_)
568  : Warning(what_)
569 {
570 }
571 
572 Magick::WarningOption::WarningOption(const std::string& what_,
573  Exception *nested_)
574  : Warning(what_,nested_)
575 {
576 }
577 
579 {
580 }
581 
583  : Warning(what_)
584 {
585 }
586 
588  Exception *nested_)
589  : Warning(what_,nested_)
590 {
591 }
592 
594 {
595 }
596 
597 Magick::WarningPolicy::WarningPolicy(const std::string& what_)
598  : Warning(what_)
599 {
600 }
601 
602 Magick::WarningPolicy::WarningPolicy(const std::string& what_,
603  Exception *nested_)
604  : Warning(what_,nested_)
605 {
606 }
607 
609 {
610 }
611 
613  : Warning(what_)
614 {
615 }
616 
618  Exception *nested_)
619  : Warning(what_,nested_)
620 {
621 }
622 
624 {
625 }
626 
627 Magick::WarningStream::WarningStream(const std::string& what_)
628  : Warning(what_)
629 {
630 }
631 
632 Magick::WarningStream::WarningStream(const std::string& what_,
633  Exception *nested_)
634  : Warning(what_,nested_)
635 {
636 }
637 
639 {
640 }
641 
642 Magick::WarningType::WarningType(const std::string& what_)
643  : Warning(what_)
644 {
645 }
646 
647 Magick::WarningType::WarningType(const std::string& what_,Exception *nested_)
648  : Warning(what_,nested_)
649 {
650 }
651 
653 {
654 }
655 
657  : Warning(what_)
658 {
659 }
660 
662  Exception *nested_)
663  : Warning(what_,nested_)
664 {
665 }
666 
668 {
669 }
670 
671 Magick::WarningXServer::WarningXServer(const std::string& what_)
672  : Warning(what_)
673 {
674 }
675 
676 Magick::WarningXServer::WarningXServer(const std::string& what_,
677  Exception *nested_)
678  : Warning(what_,nested_)
679 {
680 }
681 
683 {
684 }
685 
686 std::string Magick::formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
687 {
688  // Format error message ImageMagick-style
689  std::string message=GetClientName();
690  if (exception_->reason != (char *) NULL)
691  {
692  message+=std::string(": ");
693  message+=std::string(exception_->reason);
694  }
695 
696  if (exception_->description != (char *) NULL)
697  message += " (" + std::string(exception_->description) + ")";
698  return(message);
699 }
700 
701 Magick::Exception* Magick::createException(const MagickCore::ExceptionInfo *exception_)
702 {
703  std::string message=formatExceptionMessage(exception_);
704  switch (exception_->severity)
705  {
706  case MagickCore::BlobError:
707  case MagickCore::BlobFatalError:
708  return new ErrorBlob(message);
709  case MagickCore::BlobWarning:
710  return new WarningBlob(message);
711  case MagickCore::CacheError:
712  case MagickCore::CacheFatalError:
713  return new ErrorCache(message);
714  case MagickCore::CacheWarning:
715  return new WarningCache(message);
716  case MagickCore::CoderError:
717  case MagickCore::CoderFatalError:
718  return new ErrorCoder(message);
719  case MagickCore::CoderWarning:
720  return new WarningCoder(message);
721  case MagickCore::ConfigureError:
722  case MagickCore::ConfigureFatalError:
723  return new ErrorConfigure(message);
724  case MagickCore::ConfigureWarning:
725  return new WarningConfigure(message);
726  case MagickCore::CorruptImageError:
727  case MagickCore::CorruptImageFatalError:
728  return new ErrorCorruptImage(message);
729  case MagickCore::CorruptImageWarning:
730  return new WarningCorruptImage(message);
731  case MagickCore::DelegateError:
732  case MagickCore::DelegateFatalError:
733  return new ErrorDelegate(message);
734  case MagickCore::DelegateWarning:
735  return new WarningDelegate(message);
736  case MagickCore::DrawError:
737  case MagickCore::DrawFatalError:
738  return new ErrorDraw(message);
739  case MagickCore::DrawWarning:
740  return new WarningDraw(message);
741  case MagickCore::FileOpenError:
742  case MagickCore::FileOpenFatalError:
743  return new ErrorFileOpen(message);
744  case MagickCore::FileOpenWarning:
745  return new WarningFileOpen(message);
746  case MagickCore::ImageError:
747  case MagickCore::ImageFatalError:
748  return new ErrorImage(message);
749  case MagickCore::ImageWarning:
750  return new WarningImage(message);
751  case MagickCore::MissingDelegateError:
752  case MagickCore::MissingDelegateFatalError:
753  return new ErrorMissingDelegate(message);
754  case MagickCore::MissingDelegateWarning:
755  return new WarningMissingDelegate(message);
756  case MagickCore::ModuleError:
757  case MagickCore::ModuleFatalError:
758  return new ErrorModule(message);
759  case MagickCore::ModuleWarning:
760  return new WarningModule(message);
761  case MagickCore::MonitorError:
762  case MagickCore::MonitorFatalError:
763  return new ErrorMonitor(message);
764  case MagickCore::MonitorWarning:
765  return new WarningMonitor(message);
766  case MagickCore::OptionError:
767  case MagickCore::OptionFatalError:
768  return new ErrorOption(message);
769  case MagickCore::OptionWarning:
770  return new WarningOption(message);
771  case MagickCore::PolicyWarning:
772  return new WarningPolicy(message);
773  case MagickCore::PolicyError:
774  case MagickCore::PolicyFatalError:
775  return new ErrorPolicy(message);
776  case MagickCore::RegistryError:
777  case MagickCore::RegistryFatalError:
778  return new ErrorRegistry(message);
779  case MagickCore::RegistryWarning:
780  return new WarningRegistry(message);
781  case MagickCore::ResourceLimitError:
782  case MagickCore::ResourceLimitFatalError:
783  return new ErrorResourceLimit(message);
784  case MagickCore::ResourceLimitWarning:
785  return new WarningResourceLimit(message);
786  case MagickCore::StreamError:
787  case MagickCore::StreamFatalError:
788  return new ErrorStream(message);
789  case MagickCore::StreamWarning:
790  return new WarningStream(message);
791  case MagickCore::TypeError:
792  case MagickCore::TypeFatalError:
793  return new ErrorType(message);
794  case MagickCore::TypeWarning:
795  return new WarningType(message);
796  case MagickCore::UndefinedException:
797  default:
798  return new ErrorUndefined(message);
799  case MagickCore::XServerError:
800  case MagickCore::XServerFatalError:
801  return new ErrorXServer(message);
802  case MagickCore::XServerWarning:
803  return new WarningXServer(message);
804  }
805 }
806 
808  const MagickCore::ExceptionType severity_,const char* reason_,
809  const char* description_)
810 {
811  // Just return if there is no reported error
812  if (severity_ == MagickCore::UndefinedException)
813  return;
814 
816  ThrowException(exceptionInfo,severity_,reason_,description_);
817  ThrowPPException(false);
818 }
819 
820 MagickPPExport void Magick::throwException(ExceptionInfo *exception_,
821  const bool quiet_)
822 {
823  const ExceptionInfo
824  *p;
825 
826  Exception
827  *nestedException,
828  *q;
829 
830  MagickCore::ExceptionType
831  severity;
832 
833  size_t
834  index;
835 
836  std::string
837  message;
838 
839  // Just return if there is no reported error
840  if (exception_->severity == MagickCore::UndefinedException)
841  return;
842 
843  message=formatExceptionMessage(exception_);
844  nestedException=(Exception *) NULL;
845  q=(Exception *) NULL;
846  LockSemaphoreInfo(exception_->semaphore);
847  if (exception_->exceptions != (void *) NULL)
848  {
849  index=GetNumberOfElementsInLinkedList((LinkedListInfo *)
850  exception_->exceptions);
851  while(index > 0)
852  {
853  p=(const ExceptionInfo *) GetValueFromLinkedList((LinkedListInfo *)
854  exception_->exceptions,--index);
855  if ((p->severity != exception_->severity) || (LocaleCompare(p->reason,
856  exception_->reason) != 0) || (LocaleCompare(p->description,
857  exception_->description) != 0))
858  {
859  if (nestedException == (Exception *) NULL)
860  {
861  nestedException=createException(p);
862  q=nestedException;
863  }
864  else
865  {
866  Exception
867  *r;
868 
869  r=createException(p);
870  q->nested(r);
871  q=r;
872  }
873  }
874  }
875  }
876  severity=exception_->severity;
877  UnlockSemaphoreInfo(exception_->semaphore);
878 
879  if ((quiet_) && (severity < MagickCore::ErrorException))
880  {
881  delete nestedException;
882  return;
883  }
884 
885  DestroyExceptionInfo(exception_);
886 
887  switch (severity)
888  {
889  case MagickCore::BlobError:
890  case MagickCore::BlobFatalError:
891  throw ErrorBlob(message,nestedException);
892  case MagickCore::BlobWarning:
893  throw WarningBlob(message,nestedException);
894  case MagickCore::CacheError:
895  case MagickCore::CacheFatalError:
896  throw ErrorCache(message,nestedException);
897  case MagickCore::CacheWarning:
898  throw WarningCache(message,nestedException);
899  case MagickCore::CoderError:
900  case MagickCore::CoderFatalError:
901  throw ErrorCoder(message,nestedException);
902  case MagickCore::CoderWarning:
903  throw WarningCoder(message,nestedException);
904  case MagickCore::ConfigureError:
905  case MagickCore::ConfigureFatalError:
906  throw ErrorConfigure(message,nestedException);
907  case MagickCore::ConfigureWarning:
908  throw WarningConfigure(message,nestedException);
909  case MagickCore::CorruptImageError:
910  case MagickCore::CorruptImageFatalError:
911  throw ErrorCorruptImage(message,nestedException);
912  case MagickCore::CorruptImageWarning:
913  throw WarningCorruptImage(message,nestedException);
914  case MagickCore::DelegateError:
915  case MagickCore::DelegateFatalError:
916  throw ErrorDelegate(message,nestedException);
917  case MagickCore::DelegateWarning:
918  throw WarningDelegate(message,nestedException);
919  case MagickCore::DrawError:
920  case MagickCore::DrawFatalError:
921  throw ErrorDraw(message,nestedException);
922  case MagickCore::DrawWarning:
923  throw WarningDraw(message,nestedException);
924  case MagickCore::FileOpenError:
925  case MagickCore::FileOpenFatalError:
926  throw ErrorFileOpen(message,nestedException);
927  case MagickCore::FileOpenWarning:
928  throw WarningFileOpen(message,nestedException);
929  case MagickCore::ImageError:
930  case MagickCore::ImageFatalError:
931  throw ErrorImage(message,nestedException);
932  case MagickCore::ImageWarning:
933  throw WarningImage(message,nestedException);
934  case MagickCore::MissingDelegateError:
935  case MagickCore::MissingDelegateFatalError:
936  throw ErrorMissingDelegate(message,nestedException);
937  case MagickCore::MissingDelegateWarning:
938  throw WarningMissingDelegate(message,nestedException);
939  case MagickCore::ModuleError:
940  case MagickCore::ModuleFatalError:
941  throw ErrorModule(message,nestedException);
942  case MagickCore::ModuleWarning:
943  throw WarningModule(message,nestedException);
944  case MagickCore::MonitorError:
945  case MagickCore::MonitorFatalError:
946  throw ErrorMonitor(message,nestedException);
947  case MagickCore::MonitorWarning:
948  throw WarningMonitor(message,nestedException);
949  case MagickCore::OptionError:
950  case MagickCore::OptionFatalError:
951  throw ErrorOption(message,nestedException);
952  case MagickCore::OptionWarning:
953  throw WarningOption(message,nestedException);
954  case MagickCore::PolicyWarning:
955  throw WarningPolicy(message,nestedException);
956  case MagickCore::PolicyError:
957  case MagickCore::PolicyFatalError:
958  throw ErrorPolicy(message,nestedException);
959  case MagickCore::RegistryError:
960  case MagickCore::RegistryFatalError:
961  throw ErrorRegistry(message,nestedException);
962  case MagickCore::RegistryWarning:
963  throw WarningRegistry(message,nestedException);
964  case MagickCore::ResourceLimitError:
965  case MagickCore::ResourceLimitFatalError:
966  throw ErrorResourceLimit(message,nestedException);
967  case MagickCore::ResourceLimitWarning:
968  throw WarningResourceLimit(message,nestedException);
969  case MagickCore::StreamError:
970  case MagickCore::StreamFatalError:
971  throw ErrorStream(message,nestedException);
972  case MagickCore::StreamWarning:
973  throw WarningStream(message,nestedException);
974  case MagickCore::TypeError:
975  case MagickCore::TypeFatalError:
976  throw ErrorType(message,nestedException);
977  case MagickCore::TypeWarning:
978  throw WarningType(message,nestedException);
979  case MagickCore::UndefinedException:
980  default:
981  throw ErrorUndefined(message,nestedException);
982  case MagickCore::XServerError:
983  case MagickCore::XServerFatalError:
984  throw ErrorXServer(message,nestedException);
985  case MagickCore::XServerWarning:
986  throw WarningXServer(message,nestedException);
987  }
988 }
virtual const char * what() const
Definition: Exception.cpp:57
WarningMissingDelegate(const std::string &what_)
Definition: Exception.cpp:520
WarningXServer(const std::string &what_)
Definition: Exception.cpp:671
WarningConfigure(const std::string &what_)
Definition: Exception.cpp:432
ErrorDelegate(const std::string &what_)
Definition: Exception.cpp:158
ErrorImage(const std::string &what_)
Definition: Exception.cpp:203
WarningDraw(const std::string &what_)
Definition: Exception.cpp:477
WarningCoder(const std::string &what_)
Definition: Exception.cpp:418
WarningMonitor(const std::string &what_)
Definition: Exception.cpp:552
ErrorFileOpen(const std::string &what_)
Definition: Exception.cpp:187
Error(const std::string &what_)
Definition: Exception.cpp:72
ErrorUndefined(const std::string &what_)
Definition: Exception.cpp:347
WarningOption(const std::string &what_)
Definition: Exception.cpp:567
WarningRegistry(const std::string &what_)
Definition: Exception.cpp:582
STL namespace.
WarningDelegate(const std::string &what_)
Definition: Exception.cpp:462
WarningStream(const std::string &what_)
Definition: Exception.cpp:627
WarningPolicy(const std::string &what_)
Definition: Exception.cpp:597
const Exception * nested() const
Definition: Exception.cpp:62
std::string formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:686
ErrorRegistry(const std::string &what_)
Definition: Exception.cpp:289
MagickPPExport void throwException(MagickCore::ExceptionInfo *exception_, const bool quiet_=false)
WarningResourceLimit(const std::string &what_)
Definition: Exception.cpp:612
WarningModule(const std::string &what_)
Definition: Exception.cpp:536
WarningUndefined(const std::string &what_)
Definition: Exception.cpp:656
WarningBlob(const std::string &what_)
Definition: Exception.cpp:390
ErrorCache(const std::string &what_)
Definition: Exception.cpp:100
#define MagickPPExport
Definition: Include.h:274
Warning(const std::string &what_)
Definition: Exception.cpp:376
ErrorOption(const std::string &what_)
Definition: Exception.cpp:260
ErrorStream(const std::string &what_)
Definition: Exception.cpp:319
WarningCorruptImage(const std::string &what_)
Definition: Exception.cpp:447
MagickPPExport void throwExceptionExplicit(const MagickCore::ExceptionType severity_, const char *reason_, const char *description_=(char *) NULL)
Definition: Exception.cpp:807
WarningCache(const std::string &what_)
Definition: Exception.cpp:404
ErrorXServer(const std::string &what_)
Definition: Exception.cpp:362
ErrorPolicy(const std::string &what_)
Definition: Exception.cpp:274
ErrorBlob(const std::string &what_)
Definition: Exception.cpp:86
ErrorCorruptImage(const std::string &what_)
Definition: Exception.cpp:143
#define ThrowPPException(quiet)
Definition: Include.h:1552
WarningFileOpen(const std::string &what_)
Definition: Exception.cpp:491
ErrorResourceLimit(const std::string &what_)
Definition: Exception.cpp:304
ErrorCoder(const std::string &what_)
Definition: Exception.cpp:114
virtual ~Exception()
Definition: Exception.cpp:43
ErrorType(const std::string &what_)
Definition: Exception.cpp:333
WarningImage(const std::string &what_)
Definition: Exception.cpp:506
ErrorModule(const std::string &what_)
Definition: Exception.cpp:232
ErrorDraw(const std::string &what_)
Definition: Exception.cpp:173
Exception & operator=(const Exception &original_)
Definition: Exception.cpp:49
#define GetPPException
Definition: Include.h:1533
ErrorMonitor(const std::string &what_)
Definition: Exception.cpp:246
Exception * createException(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:701
Exception(const std::string &what_)
Definition: Exception.cpp:21
ErrorMissingDelegate(const std::string &what_)
Definition: Exception.cpp:217
WarningType(const std::string &what_)
Definition: Exception.cpp:642
ErrorConfigure(const std::string &what_)
Definition: Exception.cpp:128