Exception.h

Go to the documentation of this file.

#ifndef __EXCEPTION_H__
#define __EXCEPTION_H__

//#include <Base/Base.h>
#include <exception>
#include <string>

/* MACROS FOR THROWING EXCEPTIONS */


#ifdef _MSC_VER

#define THROW(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        throw myexcp; \
    }
#define THROWM(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        throw myexcp; \
    }
#define THROWMF_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        throw myexcp; \
    }

#define THROWT(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMT(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMFT_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __FUNCSIG__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }

#elif defined(__GNUC__)

#define THROW(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        throw myexcp; \
    }
#define THROWM(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        throw myexcp; \
    }
#define THROWMF_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        throw myexcp; \
    }

#define THROWT(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMT(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMFT_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __PRETTY_FUNCTION__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }

#else

#define THROW(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        throw myexcp; \
    }
#define THROWM(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        throw myexcp; \
    }
#define THROWMF_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        throw myexcp; \
    }

#define THROWT(exception) \
    { \
        exception myexcp; \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMT(exception, message) \
    { \
        exception myexcp(message); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }
#define THROWMFT_FILEEXCEPTION(message, filenameorfileinfo) \
    { \
        FileException myexcp(message, filenameorfileinfo); \
        myexcp.setDebugInformation(__FILE__, __LINE__, __func__); \
        myexcp.setTranslatable(true); \
        throw myexcp; \
    }


#endif

#define FC_THROWM(_exception, _msg) \
    do \
    { \
        std::stringstream ss; \
        ss << _msg; \
        THROWM(_exception, ss.str().c_str()); \
    } while (0)

#define THROW_CON_ERR_IF(_condition_, _msg_) \
    if (_condition_) \
        throw Base::ConstructionError(_msg_);

#define THROW_FAIL_NDONE_IF(_condition_, _msg_) \
    if (_condition_) \
        throw Base::FailedNotDone(_msg_);

namespace Base
{
class LX_BASE_EXPORT Exception
{
public:
    Exception(const char* sMessage, const char* detail);
    Exception(void);
    Exception(const Exception& inst);
    virtual ~Exception() throw() {}

    Exception& operator=(const Exception& inst);

    virtual const char* what(void) const throw();
    virtual const char* detail(void) const throw();

    void ReportException(void) const;

    inline void SetMessage(const char* sMessage);

    inline std::string getFile() const;
    inline int getLine() const;
    inline std::string getFunction() const;
    inline bool getTranslatable() const;
    inline bool getReported() const { return _isReported; }

    inline void setDebugInformation(const std::string& file, const int line, const std::string& function);
    inline void setTranslatable(bool translatable);
    inline void setReported(bool reported) { _isReported = reported; }

protected:
#ifdef _MSC_VER
#pragma warning(disable : 4251)
#endif
    std::string _sErrMsg;
    std::string _sErrDetail;
    std::string _file{ "" };
    int _line{ -1 };
    std::string _function{ "" };
    bool _isTranslatable{ false };
    mutable bool _isReported{ false };
};


class LX_BASE_EXPORT AbortException : public Exception
{
public:
    AbortException(const char* sMessage);
    AbortException();
    AbortException(const AbortException& inst);
    virtual ~AbortException() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT MemoryException : public Exception
{
public:
    MemoryException();
    MemoryException(const MemoryException& inst);
    virtual ~MemoryException() throw() {}
};


inline void Exception::SetMessage(const char* sMessage)
{
    _sErrMsg = sMessage;
}

class LX_BASE_EXPORT ConstructionError : public Exception
{
public:
    ConstructionError(const char* sMessage);
    ConstructionError();
    ConstructionError(const ConstructionError& inst);
    virtual ~ConstructionError() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT FailedNotDone : public Exception
{
public:
    FailedNotDone(const char* sMessage);
    FailedNotDone();
    FailedNotDone(const FailedNotDone& inst);
    virtual ~FailedNotDone() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT ItemNotFound : public Exception
{
public:
    ItemNotFound(const char* sMessage);
    ItemNotFound();
    ItemNotFound(const ItemNotFound& inst);
    virtual ~ItemNotFound() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT OutOfRange : public Exception
{
public:
    OutOfRange(const char* sMessage);
    OutOfRange();
    OutOfRange(const OutOfRange& inst);
    virtual ~OutOfRange() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT NotaNumber : public Exception
{
public:
    NotaNumber(const char* sMessage);
    NotaNumber();
    NotaNumber(const NotaNumber& inst);
    virtual ~NotaNumber() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT FileException : public Exception
{
public:
    FileException(const char* sMessage);
    FileException();
    FileException(const FileException& inst);
    virtual ~FileException() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT VectorWithNullMagnitude : public Exception
{
public:
    VectorWithNullMagnitude(const char* sMessage);
    VectorWithNullMagnitude();
    VectorWithNullMagnitude(const VectorWithNullMagnitude& inst);
    virtual ~VectorWithNullMagnitude() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT BadArguments : public Exception
{
public:
    BadArguments(const char* sMessage);
    BadArguments();
    BadArguments(const BadArguments& inst);
    virtual ~BadArguments() throw() {}
    virtual const char* what() const throw();
};

class LX_BASE_EXPORT GuidInUseException : public Base::Exception
{
public:
    GuidInUseException() { _sErrMsg = "GUID in use"; }

    GuidInUseException(const char* sMessage) : Base::Exception(sMessage, "") {}
};



class LX_BASE_EXPORT RuntimeError : public Base::Exception
{
public:
    RuntimeError();
    RuntimeError(const char* sMessage);
    RuntimeError(const std::string& sMessage);
    virtual ~RuntimeError() throw() {}

};

class LX_BASE_EXPORT ValueError : public Base::Exception
{
public:
    ValueError();
    ValueError(const char* sMessage);
    ValueError(const std::string& sMessage);
    virtual ~ValueError() throw() {}
};

class LX_BASE_EXPORT CADKernelError : public Base::Exception
{
public:
    CADKernelError();
    CADKernelError(const char* sMessage);
    CADKernelError(const std::string& sMessage);
    virtual ~CADKernelError() throw() {}
};

class LX_BASE_EXPORT TypeError : public Exception
{
public:
    TypeError();
    TypeError(const char* sMessage);
    TypeError(const std::string& sMessage);
    virtual ~TypeError() throw() {}
};

class LX_BASE_EXPORT NotImplementedError : public Exception
{
public:
    NotImplementedError();
    NotImplementedError(const char* sMessage);
    NotImplementedError(const std::string& sMessage);
    virtual ~NotImplementedError() throw() {}
};


class LX_BASE_EXPORT DivisionByZeroError : public Exception
{
public:
    DivisionByZeroError();
    DivisionByZeroError(const char* sMessage);
    DivisionByZeroError(const std::string& sMessage);
    virtual ~DivisionByZeroError() throw() {}
};

}  // namespace Base

#if !defined No_Exception && !defined No_Standard_OutOfRange
#define OutOfRange_Raise_if(CONDITION, MESSAGE) \
    if (CONDITION) \
        throw Base::OutOfRange(MESSAGE);
#else
#define OutOfRange_Raise_if(CONDITION, MESSAGE)
#endif

#if !defined No_Exception && !defined No_Standard_ConstructionError
#define ConstructionError_Raise_if(CONDITION, MESSAGE) \
    if (CONDITION) \
        throw Base::ConstructionError(MESSAGE);
#else
#define ConstructionError_Raise_if(CONDITION, MESSAGE)
#endif

#if !defined No_Exception && !defined No_gp_VectorWithNullMagnitude
#define VectorWithNullMagnitude_Raise_if(CONDITION, MESSAGE) \
    if (CONDITION) \
        throw Base::VectorWithNullMagnitude(MESSAGE);
#else
#define VectorWithNullMagnitude_Raise_if(CONDITION, MESSAGE)
#endif

#if !defined No_Exception
#define NotaNumber_if(CONDITION, MESSAGE) \
    if (CONDITION) \
        throw Base::NotaNumber(MESSAGE);
#else
#define NotaNumber_if(CONDITION, MESSAGE)
#endif


#endif  // __EXCEPTION_H__