VRS - The Virtual Rendering System

version 3.3

errorhandler.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2007 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: errorhandler.h 6136 2007-11-14 11:56:35Z Konstantin_Baumann $

#ifndef VRS_ERRORHANDLER_H
#define VRS_ERRORHANDLER_H

#include <vrs/config.h>
#include <vrs/exception.h>

namespace VRS {

class VRS_CORE_API ErrorHandler {
public:
    enum KindOfError { PROGRAM_ERROR, ARGUMENT_ERROR, WARNING, NOIMPL };
    enum KindOfAction { DO_ABORT, DO_EXIT, DO_CONTINUE, THROW_EXCEPTION };
    typedef void (*Function)(int errortype, const char* expr, 
                             const char* file, int line, const char* text);

    static Function setHandler(int errortype, Function funct);
    static int setAction(int errortype, int action);

    static void callHandler(int errortype, const char* expr, const char* file, int line);

    static std::ostream& newErrorOutputStringStream();
    static std::string getLastError();


        static void enableErrorLogging(bool enable);
};

} // namespace VRS


//
// GNU even exports the name of the current function at preprocessing time
//
#ifdef __GNUC__
# define VRS_WHICH_FUNCTION __PRETTY_FUNCTION__ << std::endl << "\t"
#else // __GNUC__
# define VRS_WHICH_FUNCTION ""
#endif // __GNUC__

#define VRS_CONSTRUCT_ERRORHANDLER(ERROR_TYPE, ERROR_MSG, MSG) \
    { \
        std::ostream& s = ::VRS::ErrorHandler::newErrorOutputStringStream(); \
        s << VRS_WHICH_FUNCTION << MSG; \
        ::VRS::ErrorHandler::callHandler(::VRS::ErrorHandler::ERROR_TYPE, #ERROR_MSG, __FILE__, __LINE__); \
    }

#ifdef NDEBUG
# define VRS_NO_INTERNAL_WARNING
# define VRS_NO_INTERNAL_ERROR
# define VRS_NO_CHECKARG
#endif // NDEBUG

//the reason for ((void)0): it forces the user of the macro to put a
//semicolon after it. 

//
// Check Arg Macro
//
#ifdef VRS_NO_CHECKARG
# define VRS_CheckArg(EXPR, MSG) ((void)0)
#else // VRS_NO_CHECKARG
# define VRS_CheckArg(EXPR, MSG) if(!(EXPR)) { VRS_CONSTRUCT_ERRORHANDLER(ARGUMENT_ERROR, EXPR, MSG); } ((void)0)
#endif // VRS_NO_CHECKARG


//
// Error Macro
//
#ifdef VRS_NO_ERROR
# define VRS_Error(EXPR, MSG) ((void)0)
#else // VRS_NO_ERROR
# define VRS_Error(EXPR, MSG) if(!(EXPR)) { VRS_CONSTRUCT_ERRORHANDLER(PROGRAM_ERROR, EXPR, MSG); } ((void)0)
#endif // VRS_NO_ERROR

//
// Internal Error Macro
//
#ifdef VRS_NO_INTERNAL_ERROR
# define VRS_InternalError(EXPR, MSG) ((void)0)
#else // VRS_NO_INTERNAL_ERROR
# define VRS_InternalError(EXPR, MSG) if(!(EXPR)) { VRS_CONSTRUCT_ERRORHANDLER(PROGRAM_ERROR, EXPR, MSG); } ((void)0)
#endif // VRS_NO_INTERNAL_ERROR

//
// Assertion Macro (deprecated!!!; use VRS_CheckArg() or VRS_Error() instead)
//
#define VRS_Assertion(EXPR, MSG) VRS_Error(EXPR, MSG)
#define VRS_RangeAssertion(VAL, MINV, MAXV) \
    VRS_Assertion(((MINV) <= (VAL)) && ((VAL) < (MAXV)), "range error: [" << (MINV) << ", " << (MAXV) << "), " << (VAL))


//
// Warning Macro
//

#ifdef VRS_NO_WARNING
# define VRS_Warning(EXPR, MSG) ((void)0)
#else // VRS_NO_WARNING
# define VRS_Warning(EXPR, MSG) if(!(EXPR)) { VRS_CONSTRUCT_ERRORHANDLER(WARNING, EXPR, MSG); } ((void)0)
#endif // VRS_NO_WARNING

//
// WarnOnce Macro. When such a warning occurs, the warning expression will be not tested a second time
//

#ifdef VRS_NO_WARNING
# define VRS_WarnOnce(EXPR, MSG) ((void)0)
#else // VRS_NO_WARNING
# define VRS_WarnOnce(EXPR, MSG) \
    {   static bool haveWarned = false; \
        if (!haveWarned) { \
            if(!(EXPR)) { \
                VRS_CONSTRUCT_ERRORHANDLER(WARNING, EXPR, MSG); \
                haveWarned = true; \
            } \
        } \
    } ((void)0)
#endif // VRS_NO_WARNING


//
// Internal Warning Macro
//
#ifdef VRS_NO_INTERNAL_WARNING
# define VRS_InternalWarning(EXPR, MSG) ((void)0)
#else // VRS_NO_INTERNAL_WARNING
# define VRS_InternalWarning(EXPR, MSG) if(!(EXPR)) { VRS_CONSTRUCT_ERRORHANDLER(WARNING, EXPR, MSG); } ((void)0)
#endif // VRS_NO_INTERNAL_WARNING

//
// InternalWarnOnce Macro. When such a warning occurs, the warning expression will be not tested a second time
//

#ifdef VRS_NO_INTERNAL_WARNING
# define VRS_InternalWarnOnce(EXPR, MSG) ((void)0)
#else // VRS_NO_INTERNAL_WARNING
# define VRS_InternalWarnOnce(EXPR, MSG) \
    {   static bool haveWarned = false; \
        if (!haveWarned) { \
            if(!(EXPR)) { \
                VRS_CONSTRUCT_ERRORHANDLER(WARNING, EXPR, MSG); \
                haveWarned = true; \
            } \
        } \
    } ((void)0)
#endif // VRS_NO_INTERNAL_WARNING


//
// NoImplementation Macro
//
#ifdef VRS_NO_NOIMPL
# define VRS_NoImpl(MSG) ((void)0)
#else // VRS_NO_NOIMPL
# define VRS_NoImpl(MSG) VRS_CONSTRUCT_ERRORHANDLER(NOIMPL, "Not implemented", MSG); ((void)0)
#endif // VRS_NO_NOIMPL


//
// Type Casting Functions and Macros
//
template<class S, class T>
inline T* VRS_CastImpl(const S* s, T*) {
    return dynamic_cast<T*>(const_cast<S*>(s));
}

#ifdef VRS_NO_INTERNAL_ERROR

    template<class S, class T>
    inline T* VRS_GuardedCastImpl(const S* s, T* dummy) {
        return static_cast<T*>(const_cast<S*>(s));
    }

#else // VRS_NO_INTERNAL_ERROR

    template<class S, class T>
    inline T* VRS_GuardedCastImpl(const S* s, T* dummy) {
        VRS_CheckArg(s, "tried to cast null pointer of type " << S::ClassNameVRS());
        T* t = VRS_CastImpl(s, dummy);
        VRS_InternalError(t, "guarded cast failed: type " << S::ClassNameVRS() << " cannot be cast to type " << T::ClassNameVRS());
        return t;
    }

#endif // VRS_NO_INTERNAL_ERROR

#define VRS_Cast(TYPE, POINTER) VRS_CastImpl(POINTER, (TYPE*) 0)

#define VRS_GuardedCast(TYPE, POINTER) VRS_GuardedCastImpl(POINTER, (TYPE*) 0)

#endif // VRS_ERRORHANDLER_H

---

Generated on Sun May 19 06:00:27 2013 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact