Exception.cpp
Go to the documentation of this file.
// This may look like C code, but it is really -*- C++ -*-
//
// Copyright Bob Friesenhahn, 1999, 2000, 2001, 2002, 2003
//
// Copyright @ 2014 ImageMagick Studio LLC, a non-profit organization
// dedicated to making software imaging solutions freely available.
//
// Implementation of Exception and derived classes
//
#define MAGICKCORE_IMPLEMENTATION 1
#define MAGICK_PLUSPLUS_IMPLEMENTATION 1
#include "Magick++/Include.h"
#include <string>
#include <errno.h>
#include <string.h>
using namespace std;
#include "Magick++/Exception.h"
Magick::Exception::Exception(const std::string& what_)
: std::exception(),
_what(what_),
_nested((Exception *) NULL)
{
}
Magick::Exception::Exception(const std::string& what_,
Exception* nested_)
: std::exception(),
_what(what_),
_nested(nested_)
{
}
Magick::Exception::Exception(const Magick::Exception& original_)
: exception(original_),
_what(original_._what),
_nested((Exception *) NULL)
{
}
Magick::Exception::~Exception() throw()
{
delete _nested;
}
Magick::Exception& Magick::Exception::operator=(
const Magick::Exception& original_)
{
if (this != &original_)
this->_what=original_._what;
return(*this);
}
const char* Magick::Exception::what() const throw()
{
return(_what.c_str());
}
const Magick::Exception* Magick::Exception::nested() const throw()
{
return(_nested);
}
void Magick::Exception::nested(Exception* nested_) throw()
{
_nested=nested_;
}
Magick::Error::Error(const std::string& what_)
: Exception(what_)
{
}
Magick::Error::Error(const std::string& what_,Exception *nested_)
: Exception(what_,nested_)
{
}
Magick::Error::~Error() throw()
{
}
Magick::ErrorBlob::ErrorBlob(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorBlob::ErrorBlob(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorBlob::~ErrorBlob() throw()
{
}
Magick::ErrorCache::ErrorCache(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorCache::ErrorCache(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorCache::~ErrorCache() throw()
{
}
Magick::ErrorCoder::ErrorCoder(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorCoder::ErrorCoder(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorCoder::~ErrorCoder() throw()
{
}
Magick::ErrorConfigure::ErrorConfigure(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorConfigure::ErrorConfigure(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorConfigure::~ErrorConfigure() throw()
{
}
Magick::ErrorCorruptImage::ErrorCorruptImage(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorCorruptImage::ErrorCorruptImage(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorCorruptImage::~ErrorCorruptImage() throw()
{
}
Magick::ErrorDelegate::ErrorDelegate(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorDelegate::ErrorDelegate(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorDelegate::~ErrorDelegate()throw()
{
}
Magick::ErrorDraw::ErrorDraw(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorDraw::ErrorDraw(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorDraw::~ErrorDraw() throw()
{
}
Magick::ErrorFileOpen::ErrorFileOpen(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorFileOpen::~ErrorFileOpen() throw()
{
}
Magick::ErrorFileOpen::ErrorFileOpen(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorImage::ErrorImage(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorImage::ErrorImage(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorImage::~ErrorImage() throw()
{
}
Magick::ErrorMissingDelegate::ErrorMissingDelegate(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorMissingDelegate::ErrorMissingDelegate(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorMissingDelegate::~ErrorMissingDelegate() throw ()
{
}
Magick::ErrorModule::ErrorModule(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorModule::ErrorModule(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorModule::~ErrorModule() throw()
{
}
Magick::ErrorMonitor::ErrorMonitor(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorMonitor::ErrorMonitor(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorMonitor::~ErrorMonitor() throw()
{
}
Magick::ErrorOption::ErrorOption(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorOption::ErrorOption(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorOption::~ErrorOption() throw()
{
}
Magick::ErrorPolicy::ErrorPolicy(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorPolicy::ErrorPolicy(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorPolicy::~ErrorPolicy() throw()
{
}
Magick::ErrorRegistry::ErrorRegistry(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorRegistry::ErrorRegistry(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorRegistry::~ErrorRegistry() throw()
{
}
Magick::ErrorResourceLimit::ErrorResourceLimit(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorResourceLimit::ErrorResourceLimit(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorResourceLimit::~ErrorResourceLimit() throw()
{
}
Magick::ErrorStream::ErrorStream(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorStream::ErrorStream(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorStream::~ErrorStream() throw()
{
}
Magick::ErrorType::ErrorType(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorType::ErrorType(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorType::~ErrorType() throw()
{
}
Magick::ErrorUndefined::ErrorUndefined(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorUndefined::ErrorUndefined(const std::string& what_,
Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorUndefined::~ErrorUndefined() throw()
{
}
Magick::ErrorXServer::ErrorXServer(const std::string& what_)
: Error(what_)
{
}
Magick::ErrorXServer::ErrorXServer(const std::string& what_,Exception *nested_)
: Error(what_,nested_)
{
}
Magick::ErrorXServer::~ErrorXServer() throw ()
{
}
Magick::Warning::Warning(const std::string& what_)
: Exception(what_)
{
}
Magick::Warning::Warning(const std::string& what_,Exception *nested_)
: Exception(what_,nested_)
{
}
Magick::Warning::~Warning() throw()
{
}
Magick::WarningBlob::WarningBlob(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningBlob::WarningBlob(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningBlob::~WarningBlob() throw()
{
}
Magick::WarningCache::WarningCache(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningCache::WarningCache(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningCache::~WarningCache() throw()
{
}
Magick::WarningCoder::WarningCoder(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningCoder::WarningCoder(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningCoder::~WarningCoder() throw()
{
}
Magick::WarningConfigure::WarningConfigure(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningConfigure::WarningConfigure(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningConfigure::~WarningConfigure() throw()
{
}
Magick::WarningCorruptImage::WarningCorruptImage(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningCorruptImage::WarningCorruptImage(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningCorruptImage::~WarningCorruptImage() throw()
{
}
Magick::WarningDelegate::WarningDelegate(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningDelegate::WarningDelegate(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningDelegate::~WarningDelegate() throw()
{
}
Magick::WarningDraw::WarningDraw(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningDraw::WarningDraw(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningDraw::~WarningDraw() throw()
{
}
Magick::WarningFileOpen::WarningFileOpen(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningFileOpen::WarningFileOpen(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningFileOpen::~WarningFileOpen() throw()
{
}
Magick::WarningImage::WarningImage(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningImage::WarningImage(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningImage::~WarningImage() throw()
{
}
Magick::WarningMissingDelegate::WarningMissingDelegate(
const std::string& what_)
: Warning(what_)
{
}
Magick::WarningMissingDelegate::WarningMissingDelegate(
const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningMissingDelegate::~WarningMissingDelegate() throw()
{
}
Magick::WarningModule::WarningModule(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningModule::WarningModule(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningModule::~WarningModule() throw()
{
}
Magick::WarningMonitor::WarningMonitor(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningMonitor::WarningMonitor(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningMonitor::~WarningMonitor() throw()
{
}
Magick::WarningOption::WarningOption(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningOption::WarningOption(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningOption::~WarningOption() throw()
{
}
Magick::WarningRegistry::WarningRegistry(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningRegistry::WarningRegistry(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningRegistry::~WarningRegistry() throw()
{
}
Magick::WarningPolicy::WarningPolicy(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningPolicy::WarningPolicy(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningPolicy::~WarningPolicy() throw()
{
}
Magick::WarningResourceLimit::WarningResourceLimit(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningResourceLimit::WarningResourceLimit(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningResourceLimit::~WarningResourceLimit() throw()
{
}
Magick::WarningStream::WarningStream(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningStream::WarningStream(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningStream::~WarningStream() throw()
{
}
Magick::WarningType::WarningType(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningType::WarningType(const std::string& what_,Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningType::~WarningType() throw()
{
}
Magick::WarningUndefined::WarningUndefined(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningUndefined::WarningUndefined(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningUndefined::~WarningUndefined() throw()
{
}
Magick::WarningXServer::WarningXServer(const std::string& what_)
: Warning(what_)
{
}
Magick::WarningXServer::WarningXServer(const std::string& what_,
Exception *nested_)
: Warning(what_,nested_)
{
}
Magick::WarningXServer::~WarningXServer() throw()
{
}
std::string Magick::formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
{
// Format error message ImageMagick-style
std::string message=GetClientName();
if (exception_->reason != (char *) NULL)
{
message+=std::string(": ");
message+=std::string(exception_->reason);
}
if (exception_->description != (char *) NULL)
message += " (" + std::string(exception_->description) + ")";
return(message);
}
Magick::Exception* Magick::createException(const MagickCore::ExceptionInfo *exception_)
{
std::string message=formatExceptionMessage(exception_);
switch (exception_->severity)
{
case MagickCore::BlobError:
case MagickCore::BlobFatalError:
return new ErrorBlob(message);
case MagickCore::BlobWarning:
return new WarningBlob(message);
case MagickCore::CacheError:
case MagickCore::CacheFatalError:
return new ErrorCache(message);
case MagickCore::CacheWarning:
return new WarningCache(message);
case MagickCore::CoderError:
case MagickCore::CoderFatalError:
return new ErrorCoder(message);
case MagickCore::CoderWarning:
return new WarningCoder(message);
case MagickCore::ConfigureError:
case MagickCore::ConfigureFatalError:
return new ErrorConfigure(message);
case MagickCore::ConfigureWarning:
return new WarningConfigure(message);
case MagickCore::CorruptImageError:
case MagickCore::CorruptImageFatalError:
return new ErrorCorruptImage(message);
case MagickCore::CorruptImageWarning:
return new WarningCorruptImage(message);
case MagickCore::DelegateError:
case MagickCore::DelegateFatalError:
return new ErrorDelegate(message);
case MagickCore::DelegateWarning:
return new WarningDelegate(message);
case MagickCore::DrawError:
case MagickCore::DrawFatalError:
return new ErrorDraw(message);
case MagickCore::DrawWarning:
return new WarningDraw(message);
case MagickCore::FileOpenError:
case MagickCore::FileOpenFatalError:
return new ErrorFileOpen(message);
case MagickCore::FileOpenWarning:
return new WarningFileOpen(message);
case MagickCore::ImageError:
case MagickCore::ImageFatalError:
return new ErrorImage(message);
case MagickCore::ImageWarning:
return new WarningImage(message);
case MagickCore::MissingDelegateError:
case MagickCore::MissingDelegateFatalError:
return new ErrorMissingDelegate(message);
case MagickCore::MissingDelegateWarning:
return new WarningMissingDelegate(message);
case MagickCore::ModuleError:
case MagickCore::ModuleFatalError:
return new ErrorModule(message);
case MagickCore::ModuleWarning:
return new WarningModule(message);
case MagickCore::MonitorError:
case MagickCore::MonitorFatalError:
return new ErrorMonitor(message);
case MagickCore::MonitorWarning:
return new WarningMonitor(message);
case MagickCore::OptionError:
case MagickCore::OptionFatalError:
return new ErrorOption(message);
case MagickCore::OptionWarning:
return new WarningOption(message);
case MagickCore::PolicyWarning:
return new WarningPolicy(message);
case MagickCore::PolicyError:
case MagickCore::PolicyFatalError:
return new ErrorPolicy(message);
case MagickCore::RegistryError:
case MagickCore::RegistryFatalError:
return new ErrorRegistry(message);
case MagickCore::RegistryWarning:
return new WarningRegistry(message);
case MagickCore::ResourceLimitError:
case MagickCore::ResourceLimitFatalError:
return new ErrorResourceLimit(message);
case MagickCore::ResourceLimitWarning:
return new WarningResourceLimit(message);
case MagickCore::StreamError:
case MagickCore::StreamFatalError:
return new ErrorStream(message);
case MagickCore::StreamWarning:
return new WarningStream(message);
case MagickCore::TypeError:
case MagickCore::TypeFatalError:
return new ErrorType(message);
case MagickCore::TypeWarning:
return new WarningType(message);
case MagickCore::UndefinedException:
default:
return new ErrorUndefined(message);
case MagickCore::XServerError:
case MagickCore::XServerFatalError:
return new ErrorXServer(message);
case MagickCore::XServerWarning:
return new WarningXServer(message);
}
}
MagickPPExport void Magick::throwExceptionExplicit(
const MagickCore::ExceptionType severity_,const char* reason_,
const char* description_)
{
// Just return if there is no reported error
if (severity_ == MagickCore::UndefinedException)
return;
GetPPException;
ThrowException(exceptionInfo,severity_,reason_,description_);
ThrowPPException(false);
}
MagickPPExport void Magick::throwException(ExceptionInfo *exception_,
const bool quiet_)
{
const ExceptionInfo
*p;
Exception
*nestedException,
*q;
MagickCore::ExceptionType
severity;
size_t
index;
std::string
message;
// Just return if there is no reported error
if (exception_->severity == MagickCore::UndefinedException)
return;
message=formatExceptionMessage(exception_);
nestedException=(Exception *) NULL;
q=(Exception *) NULL;
LockSemaphoreInfo(exception_->semaphore);
if (exception_->exceptions != (void *) NULL)
{
index=GetNumberOfElementsInLinkedList((LinkedListInfo *)
exception_->exceptions);
while(index > 0)
{
p=(const ExceptionInfo *) GetValueFromLinkedList((LinkedListInfo *)
exception_->exceptions,--index);
if ((p->severity != exception_->severity) || (LocaleCompare(p->reason,
exception_->reason) != 0) || (LocaleCompare(p->description,
exception_->description) != 0))
{
if (nestedException == (Exception *) NULL)
{
nestedException=createException(p);
q=nestedException;
}
else
{
Exception
*r;
r=createException(p);
q->nested(r);
q=r;
}
}
}
}
severity=exception_->severity;
UnlockSemaphoreInfo(exception_->semaphore);
if ((quiet_) && (severity < MagickCore::ErrorException))
{
delete nestedException;
return;
}
DestroyExceptionInfo(exception_);
switch (severity)
{
case MagickCore::BlobError:
case MagickCore::BlobFatalError:
throw ErrorBlob(message,nestedException);
case MagickCore::BlobWarning:
throw WarningBlob(message,nestedException);
case MagickCore::CacheError:
case MagickCore::CacheFatalError:
throw ErrorCache(message,nestedException);
case MagickCore::CacheWarning:
throw WarningCache(message,nestedException);
case MagickCore::CoderError:
case MagickCore::CoderFatalError:
throw ErrorCoder(message,nestedException);
case MagickCore::CoderWarning:
throw WarningCoder(message,nestedException);
case MagickCore::ConfigureError:
case MagickCore::ConfigureFatalError:
throw ErrorConfigure(message,nestedException);
case MagickCore::ConfigureWarning:
throw WarningConfigure(message,nestedException);
case MagickCore::CorruptImageError:
case MagickCore::CorruptImageFatalError:
throw ErrorCorruptImage(message,nestedException);
case MagickCore::CorruptImageWarning:
throw WarningCorruptImage(message,nestedException);
case MagickCore::DelegateError:
case MagickCore::DelegateFatalError:
throw ErrorDelegate(message,nestedException);
case MagickCore::DelegateWarning:
throw WarningDelegate(message,nestedException);
case MagickCore::DrawError:
case MagickCore::DrawFatalError:
throw ErrorDraw(message,nestedException);
case MagickCore::DrawWarning:
throw WarningDraw(message,nestedException);
case MagickCore::FileOpenError:
case MagickCore::FileOpenFatalError:
throw ErrorFileOpen(message,nestedException);
case MagickCore::FileOpenWarning:
throw WarningFileOpen(message,nestedException);
case MagickCore::ImageError:
case MagickCore::ImageFatalError:
throw ErrorImage(message,nestedException);
case MagickCore::ImageWarning:
throw WarningImage(message,nestedException);
case MagickCore::MissingDelegateError:
case MagickCore::MissingDelegateFatalError:
throw ErrorMissingDelegate(message,nestedException);
case MagickCore::MissingDelegateWarning:
throw WarningMissingDelegate(message,nestedException);
case MagickCore::ModuleError:
case MagickCore::ModuleFatalError:
throw ErrorModule(message,nestedException);
case MagickCore::ModuleWarning:
throw WarningModule(message,nestedException);
case MagickCore::MonitorError:
case MagickCore::MonitorFatalError:
throw ErrorMonitor(message,nestedException);
case MagickCore::MonitorWarning:
throw WarningMonitor(message,nestedException);
case MagickCore::OptionError:
case MagickCore::OptionFatalError:
throw ErrorOption(message,nestedException);
case MagickCore::OptionWarning:
throw WarningOption(message,nestedException);
case MagickCore::PolicyWarning:
throw WarningPolicy(message,nestedException);
case MagickCore::PolicyError:
case MagickCore::PolicyFatalError:
throw ErrorPolicy(message,nestedException);
case MagickCore::RegistryError:
case MagickCore::RegistryFatalError:
throw ErrorRegistry(message,nestedException);
case MagickCore::RegistryWarning:
throw WarningRegistry(message,nestedException);
case MagickCore::ResourceLimitError:
case MagickCore::ResourceLimitFatalError:
throw ErrorResourceLimit(message,nestedException);
case MagickCore::ResourceLimitWarning:
throw WarningResourceLimit(message,nestedException);
case MagickCore::StreamError:
case MagickCore::StreamFatalError:
throw ErrorStream(message,nestedException);
case MagickCore::StreamWarning:
throw WarningStream(message,nestedException);
case MagickCore::TypeError:
case MagickCore::TypeFatalError:
throw ErrorType(message,nestedException);
case MagickCore::TypeWarning:
throw WarningType(message,nestedException);
case MagickCore::UndefinedException:
default:
throw ErrorUndefined(message,nestedException);
case MagickCore::XServerError:
case MagickCore::XServerFatalError:
throw ErrorXServer(message,nestedException);
case MagickCore::XServerWarning:
throw WarningXServer(message,nestedException);
}
}
Magick::Exception::what
virtual const char * what() const
Definition: Exception.cpp:58
Magick::WarningMissingDelegate::WarningMissingDelegate
WarningMissingDelegate(const std::string &what_)
Definition: Exception.cpp:521
Magick::WarningFileOpen
Definition: Exception.h:302
Magick::WarningXServer::WarningXServer
WarningXServer(const std::string &what_)
Definition: Exception.cpp:672
Magick::ErrorPolicy::~ErrorPolicy
~ErrorPolicy()
Definition: Exception.cpp:285
Magick::WarningCoder
Definition: Exception.h:262
Magick::WarningConfigure::WarningConfigure
WarningConfigure(const std::string &what_)
Definition: Exception.cpp:433
Magick::ErrorImage
Definition: Exception.h:138
Magick::ErrorDelegate::ErrorDelegate
ErrorDelegate(const std::string &what_)
Definition: Exception.cpp:159
Magick::ErrorImage::ErrorImage
ErrorImage(const std::string &what_)
Definition: Exception.cpp:204
Magick::WarningRegistry
Definition: Exception.h:359
Magick::WarningDraw::WarningDraw
WarningDraw(const std::string &what_)
Definition: Exception.cpp:478
Magick::WarningMissingDelegate
Definition: Exception.h:318
Magick::WarningCoder::WarningCoder
WarningCoder(const std::string &what_)
Definition: Exception.cpp:419
Magick::ErrorDraw
Definition: Exception.h:122
Magick::WarningXServer
Definition: Exception.h:399
Magick::Error
Definition: Exception.h:66
Magick::WarningCorruptImage::~WarningCorruptImage
~WarningCorruptImage()
Definition: Exception.cpp:459
Magick::ErrorDelegate
Definition: Exception.h:114
Magick::WarningMonitor::WarningMonitor
WarningMonitor(const std::string &what_)
Definition: Exception.cpp:553
Magick::ErrorFileOpen::ErrorFileOpen
ErrorFileOpen(const std::string &what_)
Definition: Exception.cpp:188
Magick::ErrorOption::~ErrorOption
~ErrorOption()
Definition: Exception.cpp:271
Magick::Error::Error
Error(const std::string &what_)
Definition: Exception.cpp:73
Magick::ErrorMonitor
Definition: Exception.h:162
Magick::ErrorUndefined::ErrorUndefined
ErrorUndefined(const std::string &what_)
Definition: Exception.cpp:348
Magick::WarningOption::WarningOption
WarningOption(const std::string &what_)
Definition: Exception.cpp:568
Magick::ErrorType::~ErrorType
~ErrorType()
Definition: Exception.cpp:344
Magick::WarningRegistry::WarningRegistry
WarningRegistry(const std::string &what_)
Definition: Exception.cpp:583
Magick::ErrorFileOpen
Definition: Exception.h:130
std
STL namespace.
Magick::ErrorFileOpen::~ErrorFileOpen
~ErrorFileOpen()
Definition: Exception.cpp:193
Magick::WarningUndefined::~WarningUndefined
~WarningUndefined()
Definition: Exception.cpp:668
Magick::ErrorRegistry::~ErrorRegistry
~ErrorRegistry()
Definition: Exception.cpp:301
Magick::WarningOption::~WarningOption
~WarningOption()
Definition: Exception.cpp:579
Magick::WarningCache::~WarningCache
~WarningCache()
Definition: Exception.cpp:415
Magick::WarningDelegate::WarningDelegate
WarningDelegate(const std::string &what_)
Definition: Exception.cpp:463
Magick::ErrorOption
Definition: Exception.h:170
Magick::ErrorConfigure
Definition: Exception.h:98
Magick::WarningDraw::~WarningDraw
~WarningDraw()
Definition: Exception.cpp:488
Magick::ErrorXServer::~ErrorXServer
~ErrorXServer()
Definition: Exception.cpp:373
Magick::WarningStream::WarningStream
WarningStream(const std::string &what_)
Definition: Exception.cpp:628
Magick::WarningFileOpen::~WarningFileOpen
~WarningFileOpen()
Definition: Exception.cpp:503
Magick::WarningMonitor
Definition: Exception.h:335
Magick::WarningPolicy::WarningPolicy
WarningPolicy(const std::string &what_)
Definition: Exception.cpp:598
Magick::Exception::nested
const Exception * nested() const
Definition: Exception.cpp:63
Magick::WarningPolicy
Definition: Exception.h:351
Magick::formatExceptionMessage
std::string formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:687
Magick::ErrorMissingDelegate::~ErrorMissingDelegate
~ErrorMissingDelegate()
Definition: Exception.cpp:229
Magick::ErrorRegistry::ErrorRegistry
ErrorRegistry(const std::string &what_)
Definition: Exception.cpp:290
Magick::ErrorCache::~ErrorCache
~ErrorCache()
Definition: Exception.cpp:111
Magick::throwException
MagickPPExport void throwException(MagickCore::ExceptionInfo *exception_, const bool quiet_=false)
Magick::ErrorBlob
Definition: Exception.h:74
Magick::WarningResourceLimit::WarningResourceLimit
WarningResourceLimit(const std::string &what_)
Definition: Exception.cpp:613
Magick::WarningOption
Definition: Exception.h:343
Magick::WarningPolicy::~WarningPolicy
~WarningPolicy()
Definition: Exception.cpp:609
Magick::WarningModule::WarningModule
WarningModule(const std::string &what_)
Definition: Exception.cpp:537
Magick::WarningBlob
Definition: Exception.h:246
Magick::WarningModule::~WarningModule
~WarningModule()
Definition: Exception.cpp:549
Magick::ErrorResourceLimit
Definition: Exception.h:194
Magick::ErrorRegistry
Definition: Exception.h:186
Magick::ErrorCorruptImage
Definition: Exception.h:106
Magick::WarningUndefined::WarningUndefined
WarningUndefined(const std::string &what_)
Definition: Exception.cpp:657
Magick::WarningBlob::WarningBlob
WarningBlob(const std::string &what_)
Definition: Exception.cpp:391
Magick::ErrorCache::ErrorCache
ErrorCache(const std::string &what_)
Definition: Exception.cpp:101
Magick::ErrorXServer
Definition: Exception.h:226
MagickPPExport
#define MagickPPExport
Definition: Include.h:297
Magick::ErrorUndefined::~ErrorUndefined
~ErrorUndefined()
Definition: Exception.cpp:359
Magick::Warning::Warning
Warning(const std::string &what_)
Definition: Exception.cpp:377
Magick::Warning
Definition: Exception.h:238
Magick::Exception
Definition: Exception.h:24
Magick::WarningCache
Definition: Exception.h:254
Magick::WarningResourceLimit::~WarningResourceLimit
~WarningResourceLimit()
Definition: Exception.cpp:624
Magick::WarningDelegate::~WarningDelegate
~WarningDelegate()
Definition: Exception.cpp:474
Magick::ErrorOption::ErrorOption
ErrorOption(const std::string &what_)
Definition: Exception.cpp:261
Magick::ErrorStream::ErrorStream
ErrorStream(const std::string &what_)
Definition: Exception.cpp:320
Magick::WarningCorruptImage::WarningCorruptImage
WarningCorruptImage(const std::string &what_)
Definition: Exception.cpp:448
Magick::ErrorModule
Definition: Exception.h:154
Magick::WarningCorruptImage
Definition: Exception.h:278
Magick::throwExceptionExplicit
MagickPPExport void throwExceptionExplicit(const MagickCore::ExceptionType severity_, const char *reason_, const char *description_=(char *) NULL)
Definition: Exception.cpp:808
Magick::ErrorResourceLimit::~ErrorResourceLimit
~ErrorResourceLimit()
Definition: Exception.cpp:316
Magick::WarningResourceLimit
Definition: Exception.h:367
Magick::WarningCache::WarningCache
WarningCache(const std::string &what_)
Definition: Exception.cpp:405
Magick::ErrorXServer::ErrorXServer
ErrorXServer(const std::string &what_)
Definition: Exception.cpp:363
Magick::ErrorPolicy::ErrorPolicy
ErrorPolicy(const std::string &what_)
Definition: Exception.cpp:275
Magick::ErrorPolicy
Definition: Exception.h:178
Magick::ErrorBlob::ErrorBlob
ErrorBlob(const std::string &what_)
Definition: Exception.cpp:87
Magick::ErrorCorruptImage::ErrorCorruptImage
ErrorCorruptImage(const std::string &what_)
Definition: Exception.cpp:144
Magick::WarningType
Definition: Exception.h:383
Magick::ErrorDraw::~ErrorDraw
~ErrorDraw()
Definition: Exception.cpp:184
ThrowPPException
#define ThrowPPException(quiet)
Definition: Include.h:1580
Magick::ErrorBlob::~ErrorBlob
~ErrorBlob()
Definition: Exception.cpp:97
Magick::ErrorCoder
Definition: Exception.h:90
Magick::ErrorImage::~ErrorImage
~ErrorImage()
Definition: Exception.cpp:214
Include.h
Magick::WarningFileOpen::WarningFileOpen
WarningFileOpen(const std::string &what_)
Definition: Exception.cpp:492
Magick::ErrorMissingDelegate
Definition: Exception.h:146
Magick::ErrorResourceLimit::ErrorResourceLimit
ErrorResourceLimit(const std::string &what_)
Definition: Exception.cpp:305
Magick::WarningImage
Definition: Exception.h:310
Magick::ErrorCoder::ErrorCoder
ErrorCoder(const std::string &what_)
Definition: Exception.cpp:115
Magick::Warning::~Warning
~Warning()
Definition: Exception.cpp:387
Magick::Exception::~Exception
virtual ~Exception()
Definition: Exception.cpp:45
Magick::WarningDelegate
Definition: Exception.h:286
Magick::ErrorDelegate::~ErrorDelegate
~ErrorDelegate()
Definition: Exception.cpp:170
Magick::ErrorType
Definition: Exception.h:210
Magick::ErrorMonitor::~ErrorMonitor
~ErrorMonitor()
Definition: Exception.cpp:257
Magick::WarningMissingDelegate::~WarningMissingDelegate
~WarningMissingDelegate()
Definition: Exception.cpp:533
Magick::Error::~Error
~Error()
Definition: Exception.cpp:83
Magick::ErrorType::ErrorType
ErrorType(const std::string &what_)
Definition: Exception.cpp:334
Magick::ErrorModule::~ErrorModule
~ErrorModule()
Definition: Exception.cpp:243
Magick::ErrorCoder::~ErrorCoder
~ErrorCoder()
Definition: Exception.cpp:125
Magick::WarningImage::WarningImage
WarningImage(const std::string &what_)
Definition: Exception.cpp:507
Magick::ErrorConfigure::~ErrorConfigure
~ErrorConfigure()
Definition: Exception.cpp:140
Magick::ErrorModule::ErrorModule
ErrorModule(const std::string &what_)
Definition: Exception.cpp:233
Magick::WarningBlob::~WarningBlob
~WarningBlob()
Definition: Exception.cpp:401
Magick::WarningXServer::~WarningXServer
~WarningXServer()
Definition: Exception.cpp:683
Magick::ErrorDraw::ErrorDraw
ErrorDraw(const std::string &what_)
Definition: Exception.cpp:174
Magick::WarningConfigure
Definition: Exception.h:270
Magick::Exception::operator=
Exception & operator=(const Exception &original_)
Definition: Exception.cpp:50
Magick::WarningModule
Definition: Exception.h:327
Magick::WarningStream::~WarningStream
~WarningStream()
Definition: Exception.cpp:639
Magick::ErrorStream
Definition: Exception.h:202
Magick::WarningRegistry::~WarningRegistry
~WarningRegistry()
Definition: Exception.cpp:594
GetPPException
#define GetPPException
Definition: Include.h:1561
Magick::ErrorUndefined
Definition: Exception.h:218
Magick::WarningType::~WarningType
~WarningType()
Definition: Exception.cpp:653
Exception.h
Magick::ErrorMonitor::ErrorMonitor
ErrorMonitor(const std::string &what_)
Definition: Exception.cpp:247
Magick::WarningMonitor::~WarningMonitor
~WarningMonitor()
Definition: Exception.cpp:564
Magick::ErrorStream::~ErrorStream
~ErrorStream()
Definition: Exception.cpp:330
Magick::createException
Exception * createException(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:702
Magick::ErrorCache
Definition: Exception.h:82
Magick::Exception::Exception
Exception(const std::string &what_)
Definition: Exception.cpp:23
Magick::ErrorMissingDelegate::ErrorMissingDelegate
ErrorMissingDelegate(const std::string &what_)
Definition: Exception.cpp:218
Magick::WarningType::WarningType
WarningType(const std::string &what_)
Definition: Exception.cpp:643
Magick::ErrorConfigure::ErrorConfigure
ErrorConfigure(const std::string &what_)
Definition: Exception.cpp:129
Magick::WarningConfigure::~WarningConfigure
~WarningConfigure()
Definition: Exception.cpp:444
Magick::ErrorCorruptImage::~ErrorCorruptImage
~ErrorCorruptImage()
Definition: Exception.cpp:155
Magick::WarningDraw
Definition: Exception.h:294
Magick::WarningImage::~WarningImage
~WarningImage()
Definition: Exception.cpp:517
Magick::WarningStream
Definition: Exception.h:375
Magick::WarningCoder::~WarningCoder
~WarningCoder()
Definition: Exception.cpp:429