basic.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_ERROR_BASIC_1107121317_HPP
#define OGLPLUS_ERROR_BASIC_1107121317_HPP

#include <oglplus/config/error.hpp>
#include <oglplus/error/code.hpp>
#include <oglplus/string/def.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/string/empty.hpp>
#include <stdexcept>
#include <cassert>

namespace oglplus {


class Error
 : public std::runtime_error
{
private:
    GLenum _code;
#if !OGLPLUS_ERROR_NO_FILE
    const char* _file;
#endif
#if !OGLPLUS_ERROR_NO_FUNC
    const char* _func;
#endif
#if !OGLPLUS_ERROR_NO_LINE
    unsigned _line;
#endif

#if !OGLPLUS_ERROR_NO_GL_LIB
    const char* _gllib_name;
#endif

#if !OGLPLUS_ERROR_NO_GL_FUNC
    const char* _glfunc_name;
#endif

#if !OGLPLUS_ERROR_NO_GL_SYMBOL
    const char* _enumpar_name;
    GLenum _enumpar;
    GLint _index;
#endif

public:
    static const char* Message(GLenum);

    Error(const char* message);

    ~Error(void) throw() { }

    Error& NoInfo(void) { return *this; }

    Error& Code(GLenum code)
    {
        _code = code;
        return *this;
    }

    ErrorCode Code(void) const { return ErrorCode(_code); }

    Error& SourceFile(const char* file)
    {
#if !OGLPLUS_ERROR_NO_FILE
        _file = file;
#endif
        (void)file;
        return *this;
    }


    const char* SourceFile(void) const;

    Error& SourceFunc(const char* func)
    {
#if !OGLPLUS_ERROR_NO_FUNC
        _func = func;
#endif
        (void)func;
        return *this;
    }


    const char* SourceFunc(void) const;

    Error& SourceLine(unsigned line)
    {
#if !OGLPLUS_ERROR_NO_LINE
        _line = line;
#endif
        (void)line;
        return *this;
    }


    unsigned SourceLine(void) const;

    Error& GLLib(const char* lib_name)
    {
#if !OGLPLUS_ERROR_NO_GL_LIB
        _gllib_name = lib_name;
#endif
        (void)lib_name;
        return *this;
    }

    const char* GLLib(void) const;

    Error& GLFunc(const char* func_name)
    {
#if !OGLPLUS_ERROR_NO_GL_FUNC
        _glfunc_name = func_name;
#endif
        (void)func_name;
        return *this;
    }


    const char* GLFunc(void) const;

    template <typename Enum_>
    Error& EnumParam(Enum_ param)
    {
#if !OGLPLUS_ERROR_NO_GL_SYMBOL
        _enumpar = GLenum(param);
        _enumpar_name = EnumValueName(param).c_str();
#endif
        (void)param;
        return *this;
    }

    Error& EnumParam(GLenum param, const char* param_name)
    {
#if !OGLPLUS_ERROR_NO_GL_SYMBOL
        _enumpar = param;
        _enumpar_name = param_name;
#endif
        (void)param;
        (void)param_name;
        return *this;
    }


    GLenum EnumParam(void) const;


    const char* EnumParamName(void) const;

    Error& Index(GLuint index)
    {
#if !OGLPLUS_ERROR_NO_GL_SYMBOL
        _index = GLint(index);
#endif
        (void)index;
        return *this;
    }


    GLint Index(void) const;

    virtual GLfloat Value(void) const { return GLfloat(0); }

    virtual GLfloat Limit(void) const { return GLfloat(0); }

    virtual GLenum BindTarget(void) const { return GLenum(0); }

    virtual const char* TargetName(void) const { return nullptr; }


    virtual GLenum ObjectType(void) const { return GLenum(0); }


    virtual const char* ObjectTypeName(void) const { return nullptr; }


    virtual GLint ObjectName(void) const { return -1; }


    virtual const std::string& ObjectDesc(void) const
    {
        return EmptyStdString();
    }


    virtual GLenum SubjectType(void) const { return GLenum(0); }


    virtual const char* SubjectTypeName(void) const { return nullptr; }


    virtual GLint SubjectName(void) const { return -1; }


    virtual const std::string& SubjectDesc(void) const
    {
        return EmptyStdString();
    }


    virtual const char* Identifier(void) const { return nullptr; }


    virtual const String& Log(void) const { return EmptyString(); }
};

template <typename ErrorType>
inline void HandleError(ErrorType& error)
{
    throw error;
}

#define OGLPLUS_ERROR_CONTEXT(GLFUNC, CLASS) \
    static const char* _errinf_glfn(void) \
    { \
        return #GLFUNC; \
    } \
    static const char* _errinf_cls(void) \
    { \
        return #CLASS; \
    }

#define OGLPLUS_ERROR_REUSE_CONTEXT(SOURCE) \
    using SOURCE::_errinf_glfn; \
    using SOURCE::_errinf_cls;

// Macro for generic error handling
#define OGLPLUS_HANDLE_ERROR_IF(\
    CONDITION,\
    ERROR_CODE,\
    MESSAGE,\
    ERROR,\
    ERROR_INFO\
)\
{\
    GLenum error_code = ERROR_CODE;\
    if(CONDITION)\
    {\
        ERROR error(MESSAGE);\
        (void)error\
            .ERROR_INFO\
            .SourceFile(__FILE__)\
            .SourceFunc(__FUNCTION__)\
            .SourceLine(__LINE__)\
            .Code(error_code);\
        HandleError(error);\
    }\
}

#define OGLPLUS_GLFUNC_CHECK(FUNC_NAME, ERROR, ERROR_INFO)\
    OGLPLUS_HANDLE_ERROR_IF(\
        error_code != GL_NO_ERROR,\
        glGetError(),\
        ERROR::Message(error_code),\
        ERROR,\
        ERROR_INFO.GLFunc(FUNC_NAME)\
    )

#define OGLPLUS_CHECK(GLFUNC, ERROR, ERROR_INFO) \
    OGLPLUS_GLFUNC_CHECK(#GLFUNC, ERROR, ERROR_INFO)

#define OGLPLUS_CHECK_CTXT(ERROR, ERROR_INFO) \
    OGLPLUS_GLFUNC_CHECK(_errinf_glfn(), ERROR, ERROR_INFO)

#define OGLPLUS_CHECK_SIMPLE(GLFUNC) \
    OGLPLUS_CHECK(GLFUNC, Error, NoInfo())

#if !OGLPLUS_LOW_PROFILE
#define OGLPLUS_VERIFY(GLFUNC, ERROR, ERROR_INFO) \
    OGLPLUS_CHECK(GLFUNC, ERROR, ERROR_INFO)
#else
#define OGLPLUS_VERIFY(GLFUNC, ERROR, ERROR_INFO)
#endif

#define OGLPLUS_VERIFY_SIMPLE(GLFUNC) \
    OGLPLUS_CHECK(GLFUNC, Error, NoInfo())

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

} // namespace oglplus

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

#endif // include guard