object.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_ERROR_OBJECT_1107121317_HPP
#define OGLPLUS_ERROR_OBJECT_1107121317_HPP

#include <oglplus/error/basic.hpp>
#include <oglplus/object/tags.hpp>
#include <oglplus/object/type.hpp>
#include <oglplus/object/name.hpp>

namespace oglplus {

class ObjectError
 : public Error
{
private:
#if !OGLPLUS_ERROR_NO_OBJECT_TYPE
    GLenum _obj_type;
#endif
#if !OGLPLUS_ERROR_NO_BIND_TARGET
    GLenum _bind_tgt;
#endif
#if !OGLPLUS_ERROR_NO_TARGET_NAME
    const char* _tgt_name;
#endif
    int _obj_typeid;
    GLuint _obj_name;
public:
    ObjectError(const char* message);

    ObjectError& ObjectType(oglplus::ObjectType obj_type)
    {
#if !OGLPLUS_ERROR_NO_OBJECT_TYPE
        _obj_type = GLenum(obj_type);
#endif
        (void)obj_type;
        return *this;
    }

    GLenum ObjectType(void) const;

    const char* ObjectTypeName(void) const;

    template <typename BindTarget_>
    ObjectError& BindTarget(BindTarget_ bind_tgt)
    {
#if !OGLPLUS_ERROR_NO_BIND_TARGET
        _bind_tgt = GLenum(bind_tgt);
#endif
#if !OGLPLUS_ERROR_NO_TARGET_NAME
        _tgt_name = EnumValueName(bind_tgt).c_str();
#endif
        (void)bind_tgt;
        return *this;
    }

    GLenum BindTarget(void) const;

    const char* TargetName(void) const;

    template <typename ObjTag>
    ObjectError& Object(oglplus::ObjectName<ObjTag> object)
    {
#if !OGLPLUS_ERROR_NO_OBJECT_TYPE
        _obj_type = GLenum(ObjTypeOps<ObjTag>::ObjectType());
#endif
        _obj_typeid = ObjTag::value;
        _obj_name = GetGLName(object);
        return *this;
    }

    GLint ObjectName(void) const;

    const String& ObjectDesc(void) const;

    template <typename BindTarget_>
    ObjectError& ObjectBinding(BindTarget_ bind_tgt)
    {
        typedef typename ObjectTargetTag<BindTarget_>::Type Tag;
        Object(ObjBindingOps<Tag>::Binding(bind_tgt));
        return BindTarget(bind_tgt);
    }

    template <typename BindTarget_>
    ObjectError& ObjectBinding(BindTarget_ bind_tgt, GLuint index)
    {
        typedef typename ObjectTargetTag<BindTarget_>::Type Tag;
        Object(ObjBindingOps<Tag>::Binding(bind_tgt, index));
        return BindTarget(bind_tgt);
    }
};

class ObjectPairError
 : public ObjectError
{
private:
#if !OGLPLUS_ERROR_NO_OBJECT_TYPE
    GLenum _sub_type;
#endif
    int _sub_typeid;
    GLuint _sub_name;
public:
    ObjectPairError(const char* message);

    ObjectPairError& SubjectType(oglplus::ObjectType sub_type)
    {
#if !OGLPLUS_ERROR_NO_OBJECT_TYPE
        _sub_type = GLenum(sub_type);
#endif
        (void)sub_type;
        return *this;
    }

    GLenum SubjectType(void) const;

    const char* SubjectTypeName(void) const;

    template <typename ObjTag>
    ObjectPairError& Subject(oglplus::ObjectName<ObjTag> subject)
    {
        _sub_typeid = ObjTag::value;
        _sub_name = GetGLName(subject);
        return *this;
    }

    GLint SubjectName(void) const;

    const String& SubjectDesc(void) const;

    template <typename BindTarget_>
    ObjectPairError& SubjectBinding(BindTarget_ bind_tgt)
    {
        typedef typename ObjectTargetTag<BindTarget_>::Type Tag;
        return Subject(ObjBindingOps<Tag>::Binding(bind_tgt));
    }
};

} // namespace oglplus

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

#endif // include guard