named_string.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_NAMED_STRING_1202231207_HPP
#define OGLPLUS_NAMED_STRING_1202231207_HPP

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_shading_language_include

#include <oglplus/glfunc.hpp>
#include <oglplus/named_string_type.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/string/def.hpp>

namespace oglplus {

class NamedString
{
private:
    String _name;

    NamedString(const NamedString&);
public:
    static void Set(
        NamedStringType type,
        const StrCRef& name,
        const StrCRef& value
    )
    {
        OGLPLUS_GLFUNC(NamedStringARB)(
            GLenum(type),
            GLint(name.size()),
            name.c_str(),
            GLint(value.size()),
            value.c_str()
        );
        OGLPLUS_CHECK_SIMPLE(NamedStringARB);
    }

    static String Get(const StrCRef& name)
    {
        GLint len = 0;
        OGLPLUS_GLFUNC(GetNamedStringivARB)(
            GLint(name.size()),
            name.c_str(),
            GL_NAMED_STRING_LENGTH_ARB,
            &len
        );
        OGLPLUS_CHECK_SIMPLE(GetNamedStringivARB);

        String result(len, '\0');
        OGLPLUS_GLFUNC(GetNamedStringARB)(
            GLint(name.size()),
            name.c_str(),
            len,
            &len,
            &result.front()
        );
        OGLPLUS_CHECK_SIMPLE(GetNamedStringARB);
        return std::move(result);

    }

    static void Delete(const StrCRef& name)
    {
        OGLPLUS_GLFUNC(DeleteNamedStringARB)(
            GLint(name.size()),
            name.c_str()
        );
        OGLPLUS_CHECK_SIMPLE(DeleteNamedStringARB);
    }

    static NamedStringType Type(const StrCRef& name)
    {
        GLint result = 0;
        OGLPLUS_GLFUNC(GetNamedStringivARB)(
            GLint(name.size()),
            name.c_str(),
            GL_NAMED_STRING_TYPE_ARB,
            &result
        );
        OGLPLUS_CHECK_SIMPLE(GetNamedStringivARB);
        return NamedStringType(GLenum(result));
    }

    static bool IsA(const StrCRef& name)
    {
        GLboolean result = OGLPLUS_GLFUNC(IsNamedStringARB)(
            GLint(name.size()),
            name.c_str()
        );
        OGLPLUS_CHECK_SIMPLE(IsNamedStringARB);
        return result == GL_TRUE;
    }

    void Set(NamedStringType type, const StrCRef& value)
    {
        Set(type, _name, value);
    }

    String Get(void) const
    {
        return Get(_name);
    }

    NamedString(NamedString&& tmp)
     : _name(std::move(tmp._name))
    { }

    NamedString(
        NamedStringType type,
        String&& name,
        const StrCRef& value
    ): _name(std::move(name))
    {
        Set(type, value);
    }

    ~NamedString(void)
    {
        if(!_name.empty())
        {
            Delete(_name);
        }
    }
};

class ShaderInclude
 : public NamedString
{
public:
    ShaderInclude(String&& name, const StrCRef& value)
     : NamedString(
        NamedStringType::ShaderInclude,
        std::move(name),
        value
    ){ }

    ShaderInclude(ShaderInclude&& tmp)
     : NamedString(static_cast<NamedString&&>(tmp))
    { }

    void Set(const StrCRef& value)
    {
        return NamedString::Set(NamedStringType::ShaderInclude, value);
    }
};

} // namespace oglplus

#endif // GL_ARB_shading_language_include

#endif // include guard