error.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_ERROR_1107121317_HPP
#define OGLPLUS_ERROR_1107121317_HPP

#include <oglplus/auxiliary/obj_desc.hpp>
#include <oglplus/config.hpp>
#include <stdexcept>
#include <cassert>
#include <list>
#include <map>

#if OGLPLUS_CUSTOM_ERROR_HANDLING
#include <functional>
#endif

#define OGLPLUS_ERROR_INFO_CONTEXT(CONTEXT, CLASS) \
    static const char* _errinf_ctxt(void) \
    { \
        return #CONTEXT; \
    } \
    static const char* _errinf_cls(void) \
    { \
        return #CLASS; \
    }

#define OGLPLUS_ERROR_INFO_REUSE_CONTEXT(SOURCE) \
    using SOURCE::_errinf_ctxt; \
    using SOURCE::_errinf_cls;


// Define a macro that initializes the _glsym member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_GL_SYMBOL
#define OGLPLUS_ERROR_INFO_INIT_GLSYM(SYMBOL)
#else
#define OGLPLUS_ERROR_INFO_INIT_GLSYM(SYMBOL) , SYMBOL
#endif

// Define a macro that initializes the _file member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_FILE
#define OGLPLUS_ERROR_INFO_INIT_FILE(FILEPATH)
#else
#define OGLPLUS_ERROR_INFO_INIT_FILE(FILEPATH) , FILEPATH
#endif

// Define a macro that initializes the _func member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_FUNC
#define OGLPLUS_ERROR_INFO_INIT_FUNC(FUNC)
#else
#define OGLPLUS_ERROR_INFO_INIT_FUNC(FUNC) , FUNC
#endif

// Define a macro that initializes the _line member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_LINE
#define OGLPLUS_ERROR_INFO_INIT_LINE(LINE)
#else
#define OGLPLUS_ERROR_INFO_INIT_LINE(LINE) , LINE
#endif

// Define a macro that initializes the _cls_name member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_CLASS_NAME
#define OGLPLUS_ERROR_INFO_INIT_CLS_NAME(NAME)
#else
#define OGLPLUS_ERROR_INFO_INIT_CLS_NAME(NAME) , NAME
#endif

// Define a macro that initializes the _bind_tgt member of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_BIND_TARGET
#define OGLPLUS_ERROR_INFO_INIT_BIND_TGT(NAME)
#else
#define OGLPLUS_ERROR_INFO_INIT_BIND_TGT(NAME) , NAME
#endif

// Define a macro that initializes the description-related members of ErrorInfo
#if OGLPLUS_ERROR_INFO_NO_OBJECT_DESC
#define OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(GET, PURGE, NAME)
#else
#define OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(GET, PURGE, NAME) \
    , GET, PURGE, GLuint(NAME)
#endif


#define OGLPLUS_ERROR_INFO(CONTEXT) \
oglplus::ErrorInfo(\
    sizeof(decltype(&gl ## CONTEXT)) \
    OGLPLUS_ERROR_INFO_INIT_GLSYM(#CONTEXT) \
    OGLPLUS_ERROR_INFO_INIT_FILE(__FILE__) \
    OGLPLUS_ERROR_INFO_INIT_FUNC(__FUNCTION__) \
    OGLPLUS_ERROR_INFO_INIT_LINE(__LINE__) \
    OGLPLUS_ERROR_INFO_INIT_CLS_NAME("") \
    OGLPLUS_ERROR_INFO_INIT_BIND_TGT(StrLit()) \
    OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(nullptr, nullptr, 0) \
)

#define OGLPLUS_LIMIT_ERROR_INFO(CONTEXT) \
oglplus::ErrorInfo(\
    sizeof(decltype(GL_ ## CONTEXT)) \
    OGLPLUS_ERROR_INFO_INIT_GLSYM(#CONTEXT) \
    OGLPLUS_ERROR_INFO_INIT_FILE(__FILE__) \
    OGLPLUS_ERROR_INFO_INIT_FUNC(__FUNCTION__) \
    OGLPLUS_ERROR_INFO_INIT_LINE(__LINE__) \
    OGLPLUS_ERROR_INFO_INIT_CLS_NAME("") \
    OGLPLUS_ERROR_INFO_INIT_BIND_TGT(StrLit()) \
    OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(nullptr, nullptr, 0) \
)

#define OGLPLUS_ERROR_INFO_AUTO_CTXT() \
oglplus::ErrorInfo(\
    0 \
    OGLPLUS_ERROR_INFO_INIT_GLSYM(_errinf_ctxt()) \
    OGLPLUS_ERROR_INFO_INIT_FILE(__FILE__) \
    OGLPLUS_ERROR_INFO_INIT_FUNC(__FUNCTION__) \
    OGLPLUS_ERROR_INFO_INIT_LINE(__LINE__) \
    OGLPLUS_ERROR_INFO_INIT_CLS_NAME(_errinf_cls())  \
    OGLPLUS_ERROR_INFO_INIT_BIND_TGT(StrLit()) \
    OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(nullptr, nullptr, 0) \
)

#define OGLPLUS_ERROR_INFO_STR(CONTEXT_STR) \
oglplus::ErrorInfo(\
    0 \
    OGLPLUS_ERROR_INFO_INIT_GLSYM(CONTEXT_STR) \
    OGLPLUS_ERROR_INFO_INIT_FILE(__FILE__) \
    OGLPLUS_ERROR_INFO_INIT_FUNC(__FUNCTION__) \
    OGLPLUS_ERROR_INFO_INIT_LINE(__LINE__) \
    OGLPLUS_ERROR_INFO_INIT_CLS_NAME("") \
    OGLPLUS_ERROR_INFO_INIT_BIND_TGT(StrLit()) \
    OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS(nullptr, nullptr, 0) \
)

#define OGLPLUS_OBJECT_ERROR_INFO(CONTEXT, CLASS, TARGET_NAME, NAME) \
oglplus::ErrorInfo(\
    sizeof(decltype(&gl ## CONTEXT)) \
    OGLPLUS_ERROR_INFO_INIT_GLSYM(#CONTEXT) \
    OGLPLUS_ERROR_INFO_INIT_FILE(__FILE__) \
    OGLPLUS_ERROR_INFO_INIT_FUNC(__FUNCTION__) \
    OGLPLUS_ERROR_INFO_INIT_LINE(__LINE__) \
    OGLPLUS_ERROR_INFO_INIT_CLS_NAME(#CLASS) \
    OGLPLUS_ERROR_INFO_INIT_BIND_TGT(TARGET_NAME) \
    OGLPLUS_ERROR_INFO_INIT_OBJ_DECS_FUNCS( \
        &oglplus::aux::ObjectDescRegistry<CLASS##Ops>::_get_desc, \
        &oglplus::aux::ObjectDescRegistry<CLASS##Ops>::_purge_archive,\
        NAME \
    ) \
)

namespace oglplus {


struct ErrorInfo
{
    // the data members of this structure are internal
    // implementation details which are subject to change
    // without any prior notice. Do not use directly.

    const size_t _dummy;

#if !OGLPLUS_ERROR_INFO_NO_GL_SYMBOL
    const char* _glsym;
#endif

#if !OGLPLUS_ERROR_INFO_NO_FILE
    const char* _file;
#endif

#if !OGLPLUS_ERROR_INFO_NO_FUNC
    const char* _func;
#endif

#if !OGLPLUS_ERROR_INFO_NO_LINE
    const unsigned _line;
#endif

#if !OGLPLUS_ERROR_INFO_NO_CLASS_NAME
    const char* _cls_name;
#endif

#if !OGLPLUS_ERROR_INFO_NO_BIND_TARGET
    const StrLit _bind_tgt;
#endif

#if !OGLPLUS_ERROR_INFO_NO_OBJECT_DESC
    const String& (*_get_obj_desc)(GLuint);
    void (*_purge_archive)(void);
    GLuint _obj_name;
#endif

    inline ErrorInfo(
        const size_t dummy
#if !OGLPLUS_ERROR_INFO_NO_GL_SYMBOL
        , const char* glsym
#endif

#if !OGLPLUS_ERROR_INFO_NO_FILE
        , const char* file
#endif

#if !OGLPLUS_ERROR_INFO_NO_FUNC
        , const char* func
#endif

#if !OGLPLUS_ERROR_INFO_NO_LINE
        , const unsigned line
#endif

#if !OGLPLUS_ERROR_INFO_NO_CLASS_NAME
        , const char* cls_name
#endif

#if !OGLPLUS_ERROR_INFO_NO_BIND_TARGET
        , const StrLit& bind_tgt
#endif

#if !OGLPLUS_ERROR_INFO_NO_OBJECT_DESC
        , const String& (*get_obj_desc)(GLuint)
        , void (*purge_archive)(void)
        , GLuint obj_name
#endif
    ): _dummy(dummy)

#if !OGLPLUS_ERROR_INFO_NO_GL_SYMBOL
     , _glsym(glsym)
#endif

#if !OGLPLUS_ERROR_INFO_NO_FILE
     , _file(file)
#endif

#if !OGLPLUS_ERROR_INFO_NO_FUNC
     , _func(func)
#endif

#if !OGLPLUS_ERROR_INFO_NO_LINE
     , _line(line)
#endif

#if !OGLPLUS_ERROR_INFO_NO_CLASS_NAME
     , _cls_name(cls_name)
#endif

#if !OGLPLUS_ERROR_INFO_NO_BIND_TARGET
     , _bind_tgt(bind_tgt)
#endif

#if !OGLPLUS_ERROR_INFO_NO_OBJECT_DESC
     , _get_obj_desc(get_obj_desc)
     , _purge_archive(purge_archive)
     , _obj_name(obj_name)
#endif
    { }
};


const char* ErrorGLSymbol(const ErrorInfo& info);


const char* ErrorFile(const ErrorInfo& info);


const char* ErrorFunc(const ErrorInfo& info);


unsigned ErrorLine(const ErrorInfo& info);


const char* ErrorClassName(const ErrorInfo& info);


const char* ErrorBindTarget(const ErrorInfo& info);


const String& ErrorObjectDescription(const ErrorInfo& info);


class Error
 : public std::runtime_error
{
public:
    typedef std::map<String, String> PropertyMap;

#if !OGLPLUS_ERROR_NO_PROPERTIES
    typedef PropertyMap PropertyMapInit;
#else
    struct PropertyMapInit { };
#endif

    typedef std::list<ErrorInfo> PropagationInfoList;
private:
    GLenum _code;
    ErrorInfo _info;
#if !OGLPLUS_ERROR_NO_PROPERTIES
    PropertyMap _properties;
#endif

#if !OGLPLUS_ERROR_NO_PROPAGATION_INFO
    PropagationInfoList  _propagation;
#endif
    bool _assertion;
public:
    Error(
        GLenum code,
        const char* desc,
        const ErrorInfo& info,
        bool assertion = false
    );

    Error(
        GLenum code,
        const char* desc,
        const ErrorInfo& info,
        PropertyMapInit&& properties
    );

    inline ~Error(void) throw()
    { }


    GLenum Code(void) const
    {
        return _code;
    }


    const ErrorInfo& ThrowInfo(void) const
    {
        return _info;
    }


    const char* GLSymbol(void) const
    {
        return ::oglplus::ErrorGLSymbol(_info);
    }


    const char* File(void) const
    {
        return ::oglplus::ErrorFile(_info);
    }


    const char* Func(void) const
    {
        return ::oglplus::ErrorFunc(_info);
    }


    unsigned Line(void) const
    {
        return ::oglplus::ErrorLine(_info);
    }

    const char* ClassName(void) const
    {
        return ::oglplus::ErrorClassName(_info);
    }

    const char* BindTarget(void) const
    {
        return ::oglplus::ErrorBindTarget(_info);
    }

    const String& ObjectDescription(void) const
    {
        return ::oglplus::ErrorObjectDescription(_info);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || OGLPLUS_ERROR_NO_PROPERTIES

    PropertyMap Properties(void) const
    {
        return PropertyMap();
    }
#else
    const PropertyMap& Properties(void) const
    {
        return _properties;
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || !OGLPLUS_ERROR_NO_PROPERTIES
    template <typename Key, typename Value>
    static void AddPropertyValue(
        PropertyMapInit& properties,
        Key&& key,
        Value&& value
    )
    {
        properties[key] = value;
    }
#else
    template <typename Key, typename Value>
    static void AddPropertyValue(PropertyMapInit&, Key&&, Value&&) { }
#endif

    void SetPropertyValue(const String& key, const String& value);

#if OGLPLUS_DOCUMENTATION_ONLY || OGLPLUS_ERROR_NO_PROPAGATION_INFO

    PropagationInfoList PropagationInfo(void) const
    {
        return PropagationInfoList();
    }
#else
    const PropagationInfoList& PropagationInfo(void) const
    {
        return _propagation;
    }
#endif

    void Trace(const ErrorInfo& info);

    void Cleanup(void) const;
};


class OutOfMemory
 : public Error
{
public:
    OutOfMemory(GLenum code, const char* desc, const ErrorInfo& info)
     : Error(code, desc, info, true)
    { }
};

#if OGLPLUS_DOCUMENTATION_ONLY

class MissingFunction
 : public Error
{ };
#else
class MissingFunction
 : public Error
{
public:
    MissingFunction(GLenum code, const char* msg, const ErrorInfo& info)
     : Error(code, msg, info, true)
    { }
};
#endif


class LimitError
 : public Error
{
private:
    GLuint _value;
    GLuint _limit;
public:
    LimitError(
        GLuint value,
        GLuint limit,
        const GLchar* msg,
        const ErrorInfo& info
    ): Error(GL_INVALID_VALUE, msg, info)
     , _value(value)
     , _limit(limit)
    { }

    GLuint Value(void) const
    {
        return _value;
    }

    GLuint Limit(void) const
    {
        return _limit;
    }
};


class ShaderVariableError
 : public Error
{
private:
    GLint _location;
public:
    ShaderVariableError(
        GLenum code,
        GLint location,
        const GLchar* msg,
        const ErrorInfo& info,
        Error::PropertyMapInit&& properties
    ): Error(code, msg, info, std::move(properties))
     , _location(location)
    { }


    GLint Location(void) const
    {
        return _location;
    }
};

#if OGLPLUS_DOCUMENTATION_ONLY || OGLPLUS_CUSTOM_ERROR_HANDLING


struct ErrorData
{
private:
    GLenum _error_code;
    GLuint _value;
    GLuint _limit;
    const char* _message;
    ErrorInfo _info;
    Error::PropertyMap _properties;
    bool _assertion;
    bool _fatal_error;
    bool _build_error;
    bool _limit_error;
public:
    inline GLenum ErrorCode(void) const
    {
        return _error_code;
    }

    inline GLuint Value(void) const
    {
        return _value;
    }

    inline GLuint Limit(void) const
    {
        return _limit;
    }


    inline const char* Message(void) const
    {
        return _message;
    }

    inline const ErrorInfo& Info(void) const
    {
        return _info;
    }

    inline const Error::PropertyMap& Properties(void) const
    {
        return _properties;
    }

    inline bool Assertion(void) const
    {
        return _assertion;
    }

    inline bool FatalError(void) const
    {
        return _fatal_error;
    }

    inline bool BuildError(void) const
    {
        return _build_error;
    }

    inline bool LimitError(void) const
    {
        return _limit_error;
    }

    inline ErrorData(
        GLenum error_code,
        GLuint value,
        GLuint limit,
        const char* message,
        const ErrorInfo& info,
        Error::PropertyMapInit&& properties,
        bool assertion,
        bool fatal_error,
        bool build_error,
        bool limit_error
    ): _error_code(error_code)
     , _value(value)
     , _limit(limit)
     , _message(message)
     , _info(info)
     , _properties(std::move(properties))
     , _assertion(assertion)
     , _fatal_error(fatal_error)
     , _build_error(build_error)
     , _limit_error(limit_error)
    { }
};


typedef std::function<bool (const ErrorData&)> ErrorHandlerFunc;

namespace aux {

bool _has_error_handler(void);
ErrorHandlerFunc& _get_error_handler(void);

} // namespace aux


class LocalErrorHandler
{
private:
    size_t _installed;

    LocalErrorHandler(const LocalErrorHandler&);
public:
    LocalErrorHandler(ErrorHandlerFunc handler);

    ~LocalErrorHandler(void);
};

#endif // OGLPLUS_CUSTOM_ERROR_HANDLING

template <class Exception>
inline void HandleBuildError(const String& msg, const ErrorInfo& info)
{
#if OGLPLUS_CUSTOM_ERROR_HANDLING
    if(aux::_has_error_handler() && aux::_get_error_handler()(
        ErrorData(
            GL_INVALID_OPERATION,
            0u, 0u,
            msg.c_str(),
            info,
            Error::PropertyMapInit(),
            false,
            false,
            true,
            false
        )
    )) return;
#endif // OGLPLUS_CUSTOM_ERROR_HANDLING
    throw Exception(msg, info);
}

template <class Exception, typename FBStatus>
inline void HandleIncompleteFramebuffer(
    FBStatus status,
    const ErrorInfo& info
)
{
    const GLchar* msg = "Framebuffer is incomplete";
#if OGLPLUS_CUSTOM_ERROR_HANDLING
    if(aux::_has_error_handler() && aux::_get_error_handler()(
        ErrorData(
            GL_INVALID_FRAMEBUFFER_OPERATION,
            0u, 0u,
            msg,
            info,
            Error::PropertyMapInit(),
            false,
            false,
            false,
            true
        )
    )) return;
#endif // OGLPLUS_CUSTOM_ERROR_HANDLING
    throw Exception(status, msg, info);
}

void HandleShaderVariableError(
    GLenum code,
    GLint location,
    const GLchar* msg,
    const ErrorInfo& info,
    Error::PropertyMapInit&& properties
);

void HandleLimitError(GLuint value, GLuint limit, const ErrorInfo& info);

#if !OGLPLUS_NO_VARIADIC_TEMPLATES && !OGLPLUS_NO_GLFUNC_CHECKS
void HandleMissingFunction(const ErrorInfo& info);
#endif // OGLPLUS_NO_VARIADIC_TEMPLATES || OGLPLUS_NO_GLFUNC_CHECKS

void HandleError(
    GLenum code,
    const GLchar* msg,
    const ErrorInfo& info,
    Error::PropertyMapInit&& properties
);

void HandleError(GLenum code, const ErrorInfo& info, bool assertion);

#if OGLPLUS_DOCUMENTATION_ONLY

#define OGLPLUS_IS_ERROR(EXPRESSION)
#endif

#ifndef OGLPLUS_IS_ERROR
#define OGLPLUS_IS_ERROR(EXPRESSION) (EXPRESSION)
#endif

#if OGLPLUS_DOCUMENTATION_ONLY

#define OGLPLUS_CHECK(PARAM)
#endif

#ifndef OGLPLUS_CHECK
#define OGLPLUS_CHECK(PARAM) { \
    GLenum error_code = ::glGetError(); \
    if(error_code != GL_NO_ERROR) HandleError(error_code, PARAM, false); \
}
#endif

#if OGLPLUS_DOCUMENTATION_ONLY

#define OGLPLUS_VERIFY(PARAM)
#endif

#ifndef OGLPLUS_VERIFY
#if !OGPLUS_LOW_PROFILE
#define OGLPLUS_VERIFY(PARAM) { \
    GLenum error_code = ::glGetError(); \
    if(error_code != GL_NO_ERROR) HandleError(error_code, PARAM, true); \
}
#else
#define OGLPLUS_VERIFY(PARAM)
#endif
#endif

#define OGLPLUS_IGNORE(PARAM) ::glGetError();

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/error.ipp>
#endif

#endif // include guard