Exception.h

Go to the documentation of this file.

#ifndef __EXCEPTION_H__
#define __EXCEPTION_H__

//#include <Base/Base.h>
#include <Base/base_defines.h>

#include <exception>
#include <string>



#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 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);

protected:
#ifdef _MSC_VER
#pragma warning(disable : 4251)
#endif
    std::string _sErrMsg;
    std::string _sErrDetail;
};


class 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 BASE_EXPORT MemoryException : public Exception
{
public:
    MemoryException();
    MemoryException(const MemoryException& inst);
    virtual ~MemoryException() throw() {}
};


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

class 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 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 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 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 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 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 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 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 BASE_EXPORT GuidInUseException : public Base::Exception
{
public:
    GuidInUseException() { _sErrMsg = "GUID in use"; }

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

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