Exceptions.h

/***********************************************************************
    created:    20/2/2004
    author:     Paul D Turner, Frederico Jeronimo (fjeronimo)

    purpose:    Defines exceptions used within the system
*************************************************************************/
/***************************************************************************
*   Copyright (C) 2004 - 2009 Paul D Turner & The CEGUI Development Team
*
*   Permission is hereby granted, free of charge, to any person obtaining
*   a copy of this software and associated documentation files (the
*   "Software"), to deal in the Software without restriction, including
*   without limitation the rights to use, copy, modify, merge, publish,
*   distribute, sublicense, and/or sell copies of the Software, and to
*   permit persons to whom the Software is furnished to do so, subject to
*   the following conditions:
*
*   The above copyright notice and this permission notice shall be
*   included in all copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
*   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
*   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
*   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
*   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
*   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
*   OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#ifndef _CEGUIExceptions_h_
#define _CEGUIExceptions_h_

#include "CEGUI/Base.h"
#include "CEGUI/String.h"
#include <exception>

#if defined(_MSC_VER)
#   pragma warning(push)
#   pragma warning(disable : 4275)
#endif


// Start of CEGUI namespace section
namespace CEGUI
{
class  CEGUIEXPORT Exception :
    public std::exception,
    public AllocatedObject<Exception>
{
public:
    virtual ~Exception(void) throw();

    const String& getMessage(void) const
        { return d_message; }

    const String& getName() const
        { return d_name; }

    const String& getFileName(void) const
        { return d_filename; }

    int getLine(void) const
        { return d_line; }

    const String& getFunctionName(void) const
        { return d_function; }

    // override from std::exception.
    const char* what() const throw();

    static void setStdErrEnabled(bool enabled);

    static bool isStdErrEnabled();

protected:
    static bool d_stdErrEnabled;

    Exception(const String& message = "",
              const String& name = "CEGUI::Exception",
              const String& filename = "",
              int line = 0,
              const String& function = "");

    String d_message;
    String d_name;
    String d_filename;
    int d_line;
    String d_function;
    String d_what;
};

//----------------------------------------------------------------------------//

class CEGUIEXPORT GenericException : public Exception
{
public:
    GenericException(const String& message,
                     const String& file = "unknown", int line = 0,
                     const String& function = "unknown") :
        Exception(message, "CEGUI::GenericException", file, line, function)
    {}
};

#define GenericException(message)  \
    GenericException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT UnknownObjectException : public Exception
{
public:
    UnknownObjectException(const String& message,
                           const String& file = "unknown", int line = 0,
                           const String& function = "unknown") :
        Exception(message, "CEGUI::UnknownObjectException", file, line, function)
    {}
};

#define UnknownObjectException(message)  \
    UnknownObjectException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT InvalidRequestException : public Exception
{
public:
    InvalidRequestException(const String& message,
                            const String& file = "unknown", int line = 0,
                            const String& function = "unknown") :
        Exception(message, "CEGUI::InvalidRequestException", file, line, function)
    {}
};

#define InvalidRequestException(message)  \
    InvalidRequestException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT FileIOException : public Exception
{
public:
    FileIOException(const String& message,
                    const String& file = "unknown", int line = 0,
                    const String& function = "unknown") :
        Exception(message, "CEGUI::FileIOException", file, line, function)
    {}
};

#define FileIOException(message)  \
    FileIOException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT RendererException : public Exception
{
public:
    RendererException(const String& message,
                      const String& file = "unknown", int line = 0,
                      const String& function = "unknown") :
        Exception(message, "CEGUI::RendererException", file, line, function)
    {}
};

#define RendererException(message)  \
    ::CEGUI::RendererException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT AlreadyExistsException : public Exception
{
public:
    AlreadyExistsException(const String& message,
                           const String& file = "unknown", int line = 0,
                           const String& function = "unknown") :
        Exception(message, "CEGUI::AlreadyExistsException", file, line, function)
    {}
};

#define AlreadyExistsException(message)  \
    AlreadyExistsException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT MemoryException : public Exception
{
public:
    MemoryException(const String& message,
                    const String& file = "unknown", int line = 0,
                    const String& function = "unknown") :
        Exception(message, "CEGUI::MemoryException", file, line, function)
    {}
};

#define MemoryException(message)  \
    MemoryException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT NullObjectException : public Exception
{
public:
    NullObjectException(const String& message,
                        const String& file = "unknown", int line = 0,
                        const String& function = "unknown") :
        Exception(message, "CEGUI::NullObjectException", file, line, function)
    {}
};

#define NullObjectException(message)  \
    NullObjectException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT ObjectInUseException : public Exception
{
public:
    ObjectInUseException(const String& message,
                         const String& file = "unknown", int line = 0,
                         const String& function = "unknown") :
        Exception(message, "CEGUI::ObjectInUseException", file, line, function)
    {}
};

#define ObjectInUseException(message)  \
    ObjectInUseException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)

//----------------------------------------------------------------------------//

class CEGUIEXPORT ScriptException : public Exception
{
public:
    ScriptException(const String& message,
                    const String& file = "unknown", int line = 0,
                    const String& function = "unknown") :
        Exception(message, "CEGUI::ScriptException", file, line, function)
    {}
};

#define ScriptException(message)  \
    ScriptException(message, __FILE__, __LINE__, CEGUI_FUNCTION_NAME)


//----------------------------------------------------------------------------//

} // End of  CEGUI namespace section

#if defined(_MSC_VER)
#   pragma warning(pop)
#endif

#endif // end of guard _CEGUIExceptions_h_