limited_value.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_LIMITED_VALUE_1107121519_HPP
#define OGLPLUS_LIMITED_VALUE_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/limit.hpp>
#include <cassert>

namespace oglplus {

template <GLenum Query>
class LimitedCount;

template <GLenum Query>
GLuint LimitedCountMax(const LimitedCount<Query>& lim_count);


template <GLenum Query>
class LimitedCount
{
private:
    GLuint _value;

    static GLuint _query_limit(void)
    {
        GLint limit = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(Query, &limit);
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return GLuint(limit);
    }

    static GLuint _limit(void)
    {
        static GLuint limit = _query_limit();
        return limit;
    }
protected:
    LimitedCount(GLuint value, const char* query_name)
     : _value(value)
    {
        OGLPLUS_HANDLE_ERROR_IF(
            _value >= _limit(),
            GL_INVALID_VALUE,
            LimitError::Message(),
            LimitError,
            Value(_value).
            Limit(_limit()).
            EnumParam(Query, query_name)
        );
    }
public:

    LimitedCount& operator = (const LimitedCount& other)
    {
        _value = other._value;
        assert(_value < _limit());
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    template <typename Type>
    explicit operator Type(void) const;
#endif

    template <typename Type>
#if !OGLPLUS_NO_EXPLICIT_CONVERSION_OPERATORS
    explicit operator Type(void) const
#else
    operator Type(void) const
#endif
    {
        return Type(_value);
    }

    friend GLuint LimitedCountMax<Query>(const LimitedCount&);

    friend bool operator == (LimitedCount a, LimitedCount b)
    {
        return a._value == b._value;
    }

    friend bool operator != (LimitedCount a, LimitedCount b)
    {
        return a._value != b._value;
    }

    friend bool operator <= (LimitedCount a, LimitedCount b)
    {
        return a._value <= b._value;
    }

    friend bool operator <  (LimitedCount a, LimitedCount b)
    {
        return a._value <  b._value;
    }

    friend bool operator >= (LimitedCount a, LimitedCount b)
    {
        return a._value >= b._value;
    }

    friend bool operator >  (LimitedCount a, LimitedCount b)
    {
        return a._value >  b._value;
    }
};

template <GLenum Query>
inline GLuint LimitedCountMax(const LimitedCount<Query>& lim_count)
{
    return lim_count._limit();
}

inline GLuint LimitedCountMax(GLuint lim_count)
{
    return lim_count;
}

#define OGLPLUS_DECLARE_LIMITED_COUNT_TYPE(NAME, QUERY) \
class NAME \
 : public LimitedCount<GL_ ## QUERY> \
{ \
public: \
    typedef GLuint _value_type; \
    NAME(GLuint value = 0) \
     : LimitedCount<GL_ ## QUERY>(value, #QUERY) \
    { } \
};

} // namespace oglplus

#endif // include guard