api/Magick++/Exception_8h_source.html

// 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

{


   24  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

  //


   66  class MagickPPExport Error: public Exception

  {

  public:

    explicit Error(const std::string& what_);

    explicit Error(const std::string& what_,Exception *nested_);

    ~Error() throw();

  };


   74  class MagickPPExport ErrorBlob: public Error

  {

  public:

    explicit ErrorBlob(const std::string& what_);

    explicit ErrorBlob(const std::string& what_,Exception *nested_);

    ~ErrorBlob() throw();

  };


   82  class MagickPPExport ErrorCache: public Error

  {

  public:

    explicit ErrorCache(const std::string& what_);

    explicit ErrorCache(const std::string& what_,Exception *nested_);

    ~ErrorCache() throw();

  };


   90  class MagickPPExport ErrorCoder: public Error

  {

  public:

    explicit ErrorCoder(const std::string& what_);

    explicit ErrorCoder(const std::string& what_,Exception *nested_);

    ~ErrorCoder() throw();

  };


   98  class MagickPPExport ErrorConfigure: public Error

  {

  public:

    explicit ErrorConfigure(const std::string& what_);

    explicit ErrorConfigure(const std::string& what_,Exception *nested_);

    ~ErrorConfigure() throw();

  };


  106  class MagickPPExport ErrorCorruptImage: public Error

  {

  public:

    explicit ErrorCorruptImage(const std::string& what_);

    explicit ErrorCorruptImage(const std::string& what_,Exception *nested_);

    ~ErrorCorruptImage() throw();

  };


  114  class MagickPPExport ErrorDelegate: public Error

  {

  public:

    explicit ErrorDelegate(const std::string& what_);

    explicit ErrorDelegate(const std::string& what_,Exception *nested_);

    ~ErrorDelegate() throw();

  };


  122  class MagickPPExport ErrorDraw: public Error

  {

  public:

    explicit ErrorDraw(const std::string& what_);

    explicit ErrorDraw(const std::string& what_,Exception *nested_);

    ~ErrorDraw() throw();

  };


  130  class MagickPPExport ErrorFileOpen: public Error

  {

  public:

    explicit ErrorFileOpen(const std::string& what_);

    explicit ErrorFileOpen(const std::string& what_,Exception *nested_);

    ~ErrorFileOpen() throw();

  };


  138  class MagickPPExport ErrorImage: public Error

  {

  public:

    explicit ErrorImage(const std::string& what_);

    explicit ErrorImage(const std::string& what_,Exception *nested_);

    ~ErrorImage() throw();

  };


  146  class MagickPPExport ErrorMissingDelegate: public Error

  {

  public:

    explicit ErrorMissingDelegate(const std::string& what_);

    explicit ErrorMissingDelegate(const std::string& what_,Exception *nested_);

    ~ErrorMissingDelegate() throw();

  };


  154  class MagickPPExport ErrorModule: public Error

  {

  public:

    explicit ErrorModule(const std::string& what_);

    explicit ErrorModule(const std::string& what_,Exception *nested_);

    ~ErrorModule() throw();

  };


  162  class MagickPPExport ErrorMonitor: public Error

  {

  public:

    explicit ErrorMonitor(const std::string& what_);

    explicit ErrorMonitor(const std::string& what_,Exception *nested_);

    ~ErrorMonitor() throw();

  };


  170  class MagickPPExport ErrorOption: public Error

  {

  public:

    explicit ErrorOption(const std::string& what_);

    explicit ErrorOption(const std::string& what_,Exception *nested_);

    ~ErrorOption() throw();

  };


  178  class MagickPPExport ErrorPolicy: public Error

  {

  public:

    explicit ErrorPolicy(const std::string& what_);

    explicit ErrorPolicy(const std::string& what_,Exception *nested_);

    ~ErrorPolicy() throw();

  };


  186  class MagickPPExport ErrorRegistry: public Error

  {

  public:

    explicit ErrorRegistry(const std::string& what_);

    explicit ErrorRegistry(const std::string& what_,Exception *nested_);

    ~ErrorRegistry() throw();

  };


  194  class MagickPPExport ErrorResourceLimit: public Error

  {

  public:

    explicit ErrorResourceLimit(const std::string& what_);

    explicit ErrorResourceLimit(const std::string& what_,Exception *nested_);

    ~ErrorResourceLimit() throw();

  };


  202  class MagickPPExport ErrorStream: public Error

  {

  public:

    explicit ErrorStream(const std::string& what_);

    explicit ErrorStream(const std::string& what_,Exception *nested_);

    ~ErrorStream() throw();

  };


  210  class MagickPPExport ErrorType: public Error

  {

  public:

    explicit ErrorType(const std::string& what_);

    explicit ErrorType(const std::string& what_,Exception *nested_);

    ~ErrorType() throw();

  };


  218  class MagickPPExport ErrorUndefined: public Error

  {

  public:

    explicit ErrorUndefined(const std::string& what_);

    explicit ErrorUndefined(const std::string& what_,Exception *nested_);

    ~ErrorUndefined() throw();

  };


  226  class MagickPPExport ErrorXServer: public Error

  {

  public:

    explicit ErrorXServer(const std::string& what_);

    explicit ErrorXServer(const std::string& what_,Exception *nested_);

    ~ErrorXServer() throw();

  };


  //

  // Warnings

  //


  238  class MagickPPExport Warning: public Exception

  {

  public:

    explicit Warning(const std::string& what_);

    explicit Warning(const std::string& what_,Exception *nested_);

    ~Warning() throw();

  };


  246  class MagickPPExport WarningBlob: public Warning

  {

  public:

    explicit WarningBlob(const std::string& what_);

    explicit WarningBlob(const std::string& what_,Exception *nested_);

    ~WarningBlob() throw();

  };


  254  class MagickPPExport WarningCache: public Warning

  {

  public:

    explicit WarningCache(const std::string& what_);

    explicit WarningCache(const std::string& what_,Exception *nested_);

    ~WarningCache() throw();

  };


  262  class MagickPPExport WarningCoder: public Warning

  {

  public:

    explicit WarningCoder(const std::string& what_);

    explicit WarningCoder(const std::string& what_,Exception *nested_);

    ~WarningCoder() throw();

  };


  270  class MagickPPExport WarningConfigure: public Warning

  {

  public:

    explicit WarningConfigure(const std::string& what_);

    explicit WarningConfigure(const std::string& what_,Exception *nested_);

    ~WarningConfigure() throw();

  };


  278  class MagickPPExport WarningCorruptImage: public Warning

  {

  public:

    explicit WarningCorruptImage(const std::string& what_);

    explicit WarningCorruptImage(const std::string& what_,Exception *nested_);

    ~WarningCorruptImage() throw();

  };


  286  class MagickPPExport WarningDelegate: public Warning

  {

  public:

    explicit WarningDelegate(const std::string& what_);

    explicit WarningDelegate(const std::string& what_,Exception *nested_);

    ~WarningDelegate() throw();

  };


  294  class MagickPPExport WarningDraw : public Warning

  {

  public:

    explicit WarningDraw(const std::string& what_);

    explicit WarningDraw(const std::string& what_,Exception *nested_);

    ~WarningDraw() throw();

  };


  302  class MagickPPExport WarningFileOpen: public Warning

  {

  public:

    explicit WarningFileOpen(const std::string& what_);

    explicit WarningFileOpen(const std::string& what_,Exception *nested_);

    ~WarningFileOpen() throw();

  };


  310  class MagickPPExport WarningImage: public Warning

  {

  public:

    explicit WarningImage(const std::string& what_);

    explicit WarningImage(const std::string& what_,Exception *nested_);

    ~WarningImage() throw();

  };


  318  class MagickPPExport WarningMissingDelegate: public Warning

  {

  public:

    explicit WarningMissingDelegate(const std::string& what_);

    explicit WarningMissingDelegate(const std::string& what_,

      Exception *nested_);

    ~WarningMissingDelegate() throw();

  };


  327  class MagickPPExport WarningModule: public Warning

  {

  public:

    explicit WarningModule(const std::string& what_);

    explicit WarningModule(const std::string& what_,Exception *nested_);

    ~WarningModule() throw();

  };


  335  class MagickPPExport WarningMonitor: public Warning

  {

  public:

    explicit WarningMonitor(const std::string& what_);

    explicit WarningMonitor(const std::string& what_,Exception *nested_);

    ~WarningMonitor() throw();

  };


  343  class MagickPPExport WarningOption: public Warning

  {

  public:

    explicit WarningOption(const std::string& what_);

    explicit WarningOption(const std::string& what_,Exception *nested_);

    ~WarningOption() throw();

  };


  351  class MagickPPExport WarningPolicy: public Warning

  {

  public:

    explicit WarningPolicy(const std::string& what_);

    explicit WarningPolicy(const std::string& what_,Exception *nested_);

    ~WarningPolicy() throw();

  };


  359  class MagickPPExport WarningRegistry: public Warning

  {

  public:

    explicit WarningRegistry(const std::string& what_);

    explicit WarningRegistry(const std::string& what_,Exception *nested_);

    ~WarningRegistry() throw();

  };


  367  class MagickPPExport WarningResourceLimit: public Warning

  {

  public:

    explicit WarningResourceLimit(const std::string& what_);

    explicit WarningResourceLimit(const std::string& what_,Exception *nested_);

    ~WarningResourceLimit() throw();

  };


  375  class MagickPPExport WarningStream: public Warning

  {

  public:

    explicit WarningStream(const std::string& what_);

    explicit WarningStream(const std::string& what_,Exception *nested_);

    ~WarningStream() throw();

  };


  383  class MagickPPExport WarningType: public Warning

  {

  public:

    explicit WarningType(const std::string& what_);

    explicit WarningType(const std::string& what_,Exception *nested_);

    ~WarningType() throw();

  };


  391  class MagickPPExport WarningUndefined: public Warning

  {

  public:

    explicit WarningUndefined(const std::string& what_);

    explicit WarningUndefined(const std::string& what_,Exception *nested_);

    ~WarningUndefined() throw();

  };


  399  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::Exception
Definition Exception.h:25