enumerations.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_ENUMERATIONS_1107121519_HPP
#define OGLPLUS_ENUMERATIONS_1107121519_HPP

#include <oglplus/config/compiler.hpp>
#include <oglplus/config/enums.hpp>
#include <oglplus/string/def.hpp>
#include <oglplus/string/ref.hpp>
#include <oglplus/detail/enum_class.hpp>
#include <oglplus/detail/base_range.hpp>
#include <vector>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY


StrCRef EnumValueName(Enum enum_value);


template <typename Enumeration>
Range<Enum> EnumValueRange(void);

#else

namespace enums {

template <typename Enum>
struct EnumBaseType
{
    typedef GLenum Type;
};

inline StrCRef ValueName_(GLenum*, GLenum)
{
    return StrCRef();
}

template <typename EnumType>
inline StrCRef EnumValueName(EnumType enum_value)
{
#if !OGLPLUS_NO_ENUM_VALUE_NAMES
    typedef typename EnumBaseType<EnumType>::Type BaseType;
    return ValueName_(
        (EnumType*)nullptr,
        BaseType(enum_value)
    );
#else
    OGLPLUS_FAKE_USE(enum_value);
    return StrCRef();
#endif
}

template <typename EnumType>
inline aux::CastIterRange<
    const typename EnumBaseType<EnumType>::Type*,
    EnumType
> EnumValueRange(void)
{
#if !OGLPLUS_NO_ENUM_VALUE_RANGES
    return ValueRange_((EnumType*)nullptr);
#else
    const typename EnumBaseType<EnumType>::Type *x = nullptr;
    return aux::CastIterRange<
        const typename EnumBaseType<EnumType>::Type*,
        EnumType
    >(x, x);

#endif
}

} // namespace enums
using enums::EnumValueName;
using enums::EnumValueRange;

namespace aux {

template <typename Enum, bool Copy>
class EnumArray;


template <typename Enum>
class EnumArray<Enum, false>
{
private:
    std::size_t _count;
    const GLenum* _enums;
protected:
    EnumArray(
        std::size_t count,
        const Enum* enums
    ): _count(count)
     , _enums(reinterpret_cast<const GLenum*>(enums))
    { }
public:
    std::size_t Count(void) const
    {
        return _count;
    }

    const GLenum* Values(void) const
    {
        return _enums;
    }
};

template <typename Enum>
class EnumArray<Enum, true>
{
private:
    std::vector<GLenum> _enums;
protected:
    EnumArray(
        std::size_t count,
        const Enum* enums
    ): _enums(count)
    {
        for(std::size_t i=0; i!=count; ++i)
        {
            _enums[i] = GLenum(enums[i]);
        }
    }
public:
    std::size_t Count(void) const
    {
        return _enums.size();
    }

    const GLenum* Values(void) const
    {
        return _enums.data();
    }
};

} // namespace aux


template <typename Enum>
class EnumArray
 : public aux::EnumArray<Enum, sizeof(Enum) != sizeof(GLenum)>
{
private:
    typedef aux::EnumArray<Enum, sizeof(Enum) != sizeof(GLenum)> Base_;
public:
    template <std::size_t N>
    EnumArray(const Enum (&enums)[N])
     : Base_(N, enums)
    { }

    EnumArray(const std::vector<Enum>& enums)
     : Base_(enums.size(), enums.data())
    { }

    EnumArray(std::size_t count, const Enum* enums)
     : Base_(count, enums)
    { }
};

#endif // OGLPLUS_DOCUMENTATION_ONLY

} // namespace oglplus

#endif // include guard