Exceptions.h

Go to the documentation of this file.

#ifndef __LDK_EXCEPTIONS_H__
#define __LDK_EXCEPTIONS_H__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//


#include "LDK/Object.h"
#include <stdexcept>
#include <string.h>


namespace LDK
{

#ifdef _MSC_VER
#pragma warning (disable : 4275)
#endif
class LDK_API Exception : public Object, public std::exception
{
protected:
    int mLine;
    char mFile[128];
    char* mMsg;
public:
    Exception(int line, const char* file, const char* msg=NULL);

    virtual ~Exception() throw();
    inline int line() const throw() { return mLine; }

    inline const char* file() const throw() { return mFile; }

    virtual const char* what() const throw() { return mMsg; }
};
#ifdef _MSC_VER
#pragma warning (default : 4275)
#endif
class LDK_API RuntimeError : public Exception
{
public:
    inline RuntimeError(int line, const char* file, const char* msg=NULL) : Exception(line,file,msg)
    {}

    inline ~RuntimeError() throw() {}
};
#define LDK_RUNTIME_ERROR(msg) LDK::RuntimeError(__LINE__,__FILE__,msg)

class LDK_API ArgumentError : public RuntimeError
{
public:
    inline ArgumentError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~ArgumentError() throw() {}
};
#define LDK_ARGUMENT_ERROR(msg) LDK::ArgumentError(__LINE__,__FILE__,msg)

class LDK_API IOError : public RuntimeError
{
public:
    inline IOError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~IOError() throw() {}
};
#define LDK_IO_ERROR(msg) LDK::IOError(__LINE__,__FILE__,msg)

class LDK_API EofError : public IOError
{
public:
    inline EofError(int line, const char* file, const char* msg=NULL) : IOError(line,file,msg)
    {}

    inline ~EofError() throw() {}
};
#define LDK_EOF_ERROR(msg) LDK::EofError(__LINE__,__FILE__,msg)

class LDK_API IndexError : public RuntimeError
{
public:
    inline IndexError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~IndexError() throw() {}
};
#define LDK_INDEX_ERROR(msg) LDK::IndexError(__LINE__,__FILE__,msg)

class LDK_API LengthError : public RuntimeError
{
public:
    inline LengthError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~LengthError() throw() {}
};
#define LDK_LENGTH_ERROR(msg) LDK::LengthError(__LINE__,__FILE__,msg)

class LDK_API BadAllocError : public RuntimeError
{
public:
    inline BadAllocError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~BadAllocError() throw() {}
};
#define LDK_BADALLOC_ERROR LDK::BadAllocError(__LINE__,__FILE__)

class LDK_API NullPtrError : public RuntimeError
{
public:
    inline NullPtrError(int line, const char* file, const char* msg=NULL) : RuntimeError(line,file,msg)
    {}

    inline ~NullPtrError() throw() {}
};
#define LDK_NULLPTR_ERROR LDK::NullPtrError(__LINE__,__FILE__,"Null Pointer")

class LDK_API LogicError : public Exception
{
public:
    inline LogicError(int line, const char* file, const char* msg=NULL) : Exception(line,file,msg)
    {}

    inline ~LogicError() throw() {}
};
#define LDK_LOGIC_ERROR(msg) LDK::LogicError(__LINE__,__FILE__,msg)

class LDK_API NotImplimentedError : public LogicError
{
public:
    inline NotImplimentedError(int line, const char* file, const char* msg=NULL) : LogicError(line, file,msg)
    {}

    inline ~NotImplimentedError() throw() {}
};
#define LDK_NOTIMPLIMENTED_ERROR(msg) LDK::NotImplimentedError(__LINE__,__FILE__,msg)

class LDK_API ThreadError : public LogicError
{
public:
    inline ThreadError(int line, const char* file, const char* msg=NULL) : LogicError(line,file,msg)
    {}

    inline ~ThreadError() throw() {}
};
#define LDK_THREAD_ERROR LDK::LogicError(__LINE__,__FILE__,"ThreadError")


}//namespace LDK



#endif //__LDK_EXCEPTIONS_H__

---