Exception.h
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.
//
// Definition of Magick::Exception and derived classes
// Magick::Warning* and Magick::Error*. Derived from C++ STD
// 'exception' class for convenience.
//
// These classes form part of the Magick++ user interface.
//
#if !defined(Magick_Exception_header)
#define Magick_Exception_header
#include "Magick++/Include.h"
#include <string>
#include <exception>
namespace Magick
{
class MagickPPExport Exception: public std::exception
{
public:
// Construct with message string
Exception(const std::string& what_);
// Construct with message string and nested exception
Exception(const std::string& what_, Exception* nested_);
// Copy constructor
Exception(const Exception& original_);
// Destructor
virtual ~Exception() throw();
// Assignment operator
Exception& operator=(const Exception& original_);
// Get string identifying exception
virtual const char* what() const throw();
// Get nested exception
const Exception* nested() const throw();
//
// No user-serviceable parts beyond this point
//
void nested(Exception* nested_) throw();
private:
std::string _what;
Exception* _nested;
};
//
// Error exceptions
//
class MagickPPExport Error: public Exception
{
public:
explicit Error(const std::string& what_);
explicit Error(const std::string& what_,Exception *nested_);
~Error() throw();
};
class MagickPPExport ErrorBlob: public Error
{
public:
explicit ErrorBlob(const std::string& what_);
explicit ErrorBlob(const std::string& what_,Exception *nested_);
~ErrorBlob() throw();
};
class MagickPPExport ErrorCache: public Error
{
public:
explicit ErrorCache(const std::string& what_);
explicit ErrorCache(const std::string& what_,Exception *nested_);
~ErrorCache() throw();
};
class MagickPPExport ErrorCoder: public Error
{
public:
explicit ErrorCoder(const std::string& what_);
explicit ErrorCoder(const std::string& what_,Exception *nested_);
~ErrorCoder() throw();
};
class MagickPPExport ErrorConfigure: public Error
{
public:
explicit ErrorConfigure(const std::string& what_);
explicit ErrorConfigure(const std::string& what_,Exception *nested_);
~ErrorConfigure() throw();
};
class MagickPPExport ErrorCorruptImage: public Error
{
public:
explicit ErrorCorruptImage(const std::string& what_);
explicit ErrorCorruptImage(const std::string& what_,Exception *nested_);
~ErrorCorruptImage() throw();
};
class MagickPPExport ErrorDelegate: public Error
{
public:
explicit ErrorDelegate(const std::string& what_);
explicit ErrorDelegate(const std::string& what_,Exception *nested_);
~ErrorDelegate() throw();
};
class MagickPPExport ErrorDraw: public Error
{
public:
explicit ErrorDraw(const std::string& what_);
explicit ErrorDraw(const std::string& what_,Exception *nested_);
~ErrorDraw() throw();
};
class MagickPPExport ErrorFileOpen: public Error
{
public:
explicit ErrorFileOpen(const std::string& what_);
explicit ErrorFileOpen(const std::string& what_,Exception *nested_);
~ErrorFileOpen() throw();
};
class MagickPPExport ErrorImage: public Error
{
public:
explicit ErrorImage(const std::string& what_);
explicit ErrorImage(const std::string& what_,Exception *nested_);
~ErrorImage() throw();
};
class MagickPPExport ErrorMissingDelegate: public Error
{
public:
explicit ErrorMissingDelegate(const std::string& what_);
explicit ErrorMissingDelegate(const std::string& what_,Exception *nested_);
~ErrorMissingDelegate() throw();
};
class MagickPPExport ErrorModule: public Error
{
public:
explicit ErrorModule(const std::string& what_);
explicit ErrorModule(const std::string& what_,Exception *nested_);
~ErrorModule() throw();
};
class MagickPPExport ErrorMonitor: public Error
{
public:
explicit ErrorMonitor(const std::string& what_);
explicit ErrorMonitor(const std::string& what_,Exception *nested_);
~ErrorMonitor() throw();
};
class MagickPPExport ErrorOption: public Error
{
public:
explicit ErrorOption(const std::string& what_);
explicit ErrorOption(const std::string& what_,Exception *nested_);
~ErrorOption() throw();
};
class MagickPPExport ErrorPolicy: public Error
{
public:
explicit ErrorPolicy(const std::string& what_);
explicit ErrorPolicy(const std::string& what_,Exception *nested_);
~ErrorPolicy() throw();
};
class MagickPPExport ErrorRegistry: public Error
{
public:
explicit ErrorRegistry(const std::string& what_);
explicit ErrorRegistry(const std::string& what_,Exception *nested_);
~ErrorRegistry() throw();
};
class MagickPPExport ErrorResourceLimit: public Error
{
public:
explicit ErrorResourceLimit(const std::string& what_);
explicit ErrorResourceLimit(const std::string& what_,Exception *nested_);
~ErrorResourceLimit() throw();
};
class MagickPPExport ErrorStream: public Error
{
public:
explicit ErrorStream(const std::string& what_);
explicit ErrorStream(const std::string& what_,Exception *nested_);
~ErrorStream() throw();
};
class MagickPPExport ErrorType: public Error
{
public:
explicit ErrorType(const std::string& what_);
explicit ErrorType(const std::string& what_,Exception *nested_);
~ErrorType() throw();
};
class MagickPPExport ErrorUndefined: public Error
{
public:
explicit ErrorUndefined(const std::string& what_);
explicit ErrorUndefined(const std::string& what_,Exception *nested_);
~ErrorUndefined() throw();
};
class MagickPPExport ErrorXServer: public Error
{
public:
explicit ErrorXServer(const std::string& what_);
explicit ErrorXServer(const std::string& what_,Exception *nested_);
~ErrorXServer() throw();
};
//
// Warnings
//
class MagickPPExport Warning: public Exception
{
public:
explicit Warning(const std::string& what_);
explicit Warning(const std::string& what_,Exception *nested_);
~Warning() throw();
};
class MagickPPExport WarningBlob: public Warning
{
public:
explicit WarningBlob(const std::string& what_);
explicit WarningBlob(const std::string& what_,Exception *nested_);
~WarningBlob() throw();
};
class MagickPPExport WarningCache: public Warning
{
public:
explicit WarningCache(const std::string& what_);
explicit WarningCache(const std::string& what_,Exception *nested_);
~WarningCache() throw();
};
class MagickPPExport WarningCoder: public Warning
{
public:
explicit WarningCoder(const std::string& what_);
explicit WarningCoder(const std::string& what_,Exception *nested_);
~WarningCoder() throw();
};
class MagickPPExport WarningConfigure: public Warning
{
public:
explicit WarningConfigure(const std::string& what_);
explicit WarningConfigure(const std::string& what_,Exception *nested_);
~WarningConfigure() throw();
};
class MagickPPExport WarningCorruptImage: public Warning
{
public:
explicit WarningCorruptImage(const std::string& what_);
explicit WarningCorruptImage(const std::string& what_,Exception *nested_);
~WarningCorruptImage() throw();
};
class MagickPPExport WarningDelegate: public Warning
{
public:
explicit WarningDelegate(const std::string& what_);
explicit WarningDelegate(const std::string& what_,Exception *nested_);
~WarningDelegate() throw();
};
class MagickPPExport WarningDraw : public Warning
{
public:
explicit WarningDraw(const std::string& what_);
explicit WarningDraw(const std::string& what_,Exception *nested_);
~WarningDraw() throw();
};
class MagickPPExport WarningFileOpen: public Warning
{
public:
explicit WarningFileOpen(const std::string& what_);
explicit WarningFileOpen(const std::string& what_,Exception *nested_);
~WarningFileOpen() throw();
};
class MagickPPExport WarningImage: public Warning
{
public:
explicit WarningImage(const std::string& what_);
explicit WarningImage(const std::string& what_,Exception *nested_);
~WarningImage() throw();
};
class MagickPPExport WarningMissingDelegate: public Warning
{
public:
explicit WarningMissingDelegate(const std::string& what_);
explicit WarningMissingDelegate(const std::string& what_,
Exception *nested_);
~WarningMissingDelegate() throw();
};
class MagickPPExport WarningModule: public Warning
{
public:
explicit WarningModule(const std::string& what_);
explicit WarningModule(const std::string& what_,Exception *nested_);
~WarningModule() throw();
};
class MagickPPExport WarningMonitor: public Warning
{
public:
explicit WarningMonitor(const std::string& what_);
explicit WarningMonitor(const std::string& what_,Exception *nested_);
~WarningMonitor() throw();
};
class MagickPPExport WarningOption: public Warning
{
public:
explicit WarningOption(const std::string& what_);
explicit WarningOption(const std::string& what_,Exception *nested_);
~WarningOption() throw();
};
class MagickPPExport WarningPolicy: public Warning
{
public:
explicit WarningPolicy(const std::string& what_);
explicit WarningPolicy(const std::string& what_,Exception *nested_);
~WarningPolicy() throw();
};
class MagickPPExport WarningRegistry: public Warning
{
public:
explicit WarningRegistry(const std::string& what_);
explicit WarningRegistry(const std::string& what_,Exception *nested_);
~WarningRegistry() throw();
};
class MagickPPExport WarningResourceLimit: public Warning
{
public:
explicit WarningResourceLimit(const std::string& what_);
explicit WarningResourceLimit(const std::string& what_,Exception *nested_);
~WarningResourceLimit() throw();
};
class MagickPPExport WarningStream: public Warning
{
public:
explicit WarningStream(const std::string& what_);
explicit WarningStream(const std::string& what_,Exception *nested_);
~WarningStream() throw();
};
class MagickPPExport WarningType: public Warning
{
public:
explicit WarningType(const std::string& what_);
explicit WarningType(const std::string& what_,Exception *nested_);
~WarningType() throw();
};
class MagickPPExport WarningUndefined: public Warning
{
public:
explicit WarningUndefined(const std::string& what_);
explicit WarningUndefined(const std::string& what_,Exception *nested_);
~WarningUndefined() throw();
};
class MagickPPExport WarningXServer: public Warning
{
public:
explicit WarningXServer(const std::string& what_);
explicit WarningXServer(const std::string& what_,Exception *nested_);
~WarningXServer() throw();
};
//
// No user-serviceable components beyond this point.
//
std::string formatExceptionMessage(
const MagickCore::ExceptionInfo *exception_);
Exception* createException(const MagickCore::ExceptionInfo *exception_);
// Throw exception based on raw data
extern MagickPPExport void throwExceptionExplicit(
const MagickCore::ExceptionType severity_,const char* reason_,
const char* description_=(char *) NULL);
// Thow exception based on ImageMagick's ExceptionInfo
extern MagickPPExport void throwException(
MagickCore::ExceptionInfo *exception_,const bool quiet_=false);
} // namespace Magick
#endif // Magick_Exception_header
Magick::WarningFileOpen
Definition: Exception.h:302
Magick::WarningCoder
Definition: Exception.h:262
Magick::ErrorImage
Definition: Exception.h:138
Magick::WarningRegistry
Definition: Exception.h:359
Magick::WarningMissingDelegate
Definition: Exception.h:318
Magick::ErrorDraw
Definition: Exception.h:122
Magick::WarningXServer
Definition: Exception.h:399
Magick::Error
Definition: Exception.h:66
Magick::ErrorDelegate
Definition: Exception.h:114
Magick::ErrorMonitor
Definition: Exception.h:162
Magick::ErrorFileOpen
Definition: Exception.h:130
Magick::ErrorOption
Definition: Exception.h:170
Magick::ErrorConfigure
Definition: Exception.h:98
Magick::WarningUndefined
Definition: Exception.h:391
Magick::WarningMonitor
Definition: Exception.h:335
Magick::WarningPolicy
Definition: Exception.h:351
Magick::formatExceptionMessage
std::string formatExceptionMessage(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:687
Magick::throwException
MagickPPExport void throwException(MagickCore::ExceptionInfo *exception_, const bool quiet_=false)
Magick::ErrorBlob
Definition: Exception.h:74
Magick::WarningOption
Definition: Exception.h:343
Magick::WarningBlob
Definition: Exception.h:246
Magick::ErrorResourceLimit
Definition: Exception.h:194
Magick::ErrorRegistry
Definition: Exception.h:186
Magick::ErrorCorruptImage
Definition: Exception.h:106
Magick::ErrorXServer
Definition: Exception.h:226
MagickPPExport
#define MagickPPExport
Definition: Include.h:297
Magick::Warning
Definition: Exception.h:238
Magick::Exception
Definition: Exception.h:24
Magick::WarningCache
Definition: Exception.h:254
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::WarningResourceLimit
Definition: Exception.h:367
Magick::ErrorPolicy
Definition: Exception.h:178
Magick::WarningType
Definition: Exception.h:383
Magick::ErrorCoder
Definition: Exception.h:90
Include.h
Magick::ErrorMissingDelegate
Definition: Exception.h:146
Magick::WarningImage
Definition: Exception.h:310
Magick::WarningDelegate
Definition: Exception.h:286
Magick::ErrorType
Definition: Exception.h:210
Magick
Definition: Blob.h:17
Magick::WarningConfigure
Definition: Exception.h:270
Magick::WarningModule
Definition: Exception.h:327
Magick::ErrorStream
Definition: Exception.h:202
Magick::ErrorUndefined
Definition: Exception.h:218
Magick::createException
Exception * createException(const MagickCore::ExceptionInfo *exception_)
Definition: Exception.cpp:702
Magick::ErrorCache
Definition: Exception.h:82
Magick::WarningDraw
Definition: Exception.h:294
Magick::WarningStream
Definition: Exception.h:375