bitfield.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_BITFIELD_1107121519_HPP
#define OGLPLUS_BITFIELD_1107121519_HPP

#include <oglplus/config/compiler.hpp>

#include <type_traits>

#if !OGLPLUS_NO_INITIALIZER_LISTS
#include <initializer_list>
#endif

namespace oglplus {

namespace enums {
template <typename Enum>
struct EnumBaseType;

template <typename Enum>
struct IsBitfieldBit
{
    typedef std::false_type Type;
};

} // namespace enums


template <typename Bit>
class Bitfield
{
private:
    typedef typename enums::EnumBaseType<Bit>::Type BF;
    BF _bits;
public:
    Bitfield(void)
     : _bits(0)
    { }

    Bitfield(BF bits)
     : _bits(bits)
    { }

    Bitfield(Bit _bit)
     : _bits(BF(_bit))
    { }

    Bitfield(Bit _bit_a, Bit _bit_b)
     : _bits(BF(_bit_a) | BF(_bit_b))
    { }

#if OGLPLUS_DOCUMENTATION_ONLY
    template <typename Iter>
    Bitfield(Iter pos, Iter end);
#else
    template <typename Iter>
    Bitfield(Iter pos, Iter end)
     : _bits(BF(0))
    {
        while(pos != end)
        {
            _bits |= BF(*pos);
            ++pos;
        }
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || !OGLPLUS_NO_INITIALIZER_LISTS
    Bitfield(const std::initializer_list<Bit>& bits)
     : _bits(BF(0))
    {
        for(auto i=bits.begin(),e=bits.end(); i!=e; ++i)
            _bits |= BF(*i);
    }
#endif

    friend Bitfield operator | (Bitfield bf, Bit b)
    {
        bf._bits |= BF(b);
        return bf;
    }

    Bitfield& operator |= (Bit b)
    {
        this->_bits |= BF(b);
        return *this;
    }

    bool Test(Bit b) const
    {
        return (this->_bits & BF(b)) == BF(b);
    }

    OGLPLUS_EXPLICIT operator BF (void) const
    {
        return _bits;
    }
};

// helper macro used to define bitfield-related functions
#define OGLPLUS_MAKE_BITFIELD(BITS) \
namespace enums { \
template <> struct EnumBaseType<BITS> { typedef GLbitfield Type; }; \
template <> struct IsBitfieldBit<BITS> { typedef std::true_type Type; }; \
} \
inline oglplus::Bitfield<BITS> operator | (BITS b1, BITS b2) \
{ \
    return Bitfield<BITS>(b1, b2); \
}


} // namespace oglplus

#endif // include guard