A typesafe bit mask representation using class enums. More...

#include <BitMask.hxx>

Classes
struct	All
	Helper type for setting all bits during construction time of BitMask. More...

Public Types
using	EnumBaseType = typename std::underlying_type<ENUM>::type

Public Member Functions
constexpr	BitMask ()
	Sets all bits to zero.

	BitMask (const All a)
	Sets all bits to one.

constexpr	BitMask (const std::initializer_list< ENUM > &init_list)
	Sets only the flags found in the given initializer list.

constexpr	BitMask (const ENUM val)
	Sets exactly the given value to one.

constexpr	BitMask (const EnumBaseType value)
	Sets exactly the given primitive type bitmask.

EnumBaseType	raw () const
	Returns the raw bitfield integer.

	operator std::string () const
	Return a string representation of the bit mask.

bool	operator[] (const ENUM flag) const
	Returns a boolean value for the given value,.

std::string	toString () const

BitMask &	set (const All)
	Sets all bits it the set.

BitMask &	set (const ENUM val, bool on_off=true)
	Set or unset the given value.

BitMask &	set (const std::initializer_list< ENUM > &flags)

BitMask &	set (const BitMask other)
	Sets all the bits that are also set in `other`.

BitMask &	reset ()
	Sets all bits to zero.

BitMask &	reset (const ENUM val)
	Zeroes the given value.

BitMask &	reset (const std::initializer_list< ENUM > &flags)
	Zeroes all of the given values.

BitMask &	reset (const BitMask other)

BitMask	reset (const BitMask other) const

BitMask &	limit (const std::initializer_list< ENUM > &flags)
	Sets all bits to zero except the given flags.

BitMask &	limit (const ENUM flag)
	Sets all bits to zero except the given flag.

BitMask &	limit (const BitMask other)
	Sets all bits to zero except the bits in the given mask.

BitMask	limit (const BitMask other) const

BitMask &	flip ()
	Flip every bit in the bit mask.

BitMask &	flip (const ENUM val)
	Flips the given value.

size_t	count () const
	Returns the number of set bits.

constexpr size_t	size () const
	Returns the maximum number of bits that can be stored in the bit mask.

bool	test (const ENUM val) const
	Returns whether the given value is set.

bool	testAny (const ENUM val) const
	Returns whether any of the bits of `val` are set.

bool	only (const ENUM val) const
	Returns whether this is the only value set.

bool	any () const
	Returns whether any bit in the bitset is set.

bool	allOf (const std::initializer_list< ENUM > &flags) const
	Tests whether all of the given values are set.

bool	allOf (const BitMask other) const

bool	anyOf (const std::initializer_list< ENUM > &flags) const
	Returns whether any of the given values is set.

bool	anyOf (const BitMask other) const

bool	none () const
	Returns whether no bit in the bitset is set.

bool	operator== (const BitMask &other) const

bool	operator!= (const BitMask &other) const

bool	operator& (const ENUM val) const
	Checks whether any bit of the given value is set,.

ENUM	operator& (const BitMask &other) const
	returns an ENUM value containing only the values found in both masks.

BitMask	operator~ () const

Static Public Attributes
static constexpr All	all {}

Protected Attributes
EnumBaseType	m_flags = 0

Friends
BitMask	operator- (const BitMask &first, const BitMask &second)
	Returns an object containing all the bits found in `first` without the bits found inc `second`.

BitMask	operator- (const BitMask &first, const ENUM val)
	Returns an object containing all the bits found in `first` without `val`.

BitMask	operator+ (const BitMask &first, const BitMask &second)
	Returns an object containing all the bits found in `first` and `second`.

BitMask	operator+ (const BitMask &first, const ENUM val)
	Returns an object containing all the bits found in `first` and /also `val`.

Detailed Description

template<typename ENUM>
class cosmos::BitMask< ENUM >

A typesafe bit mask representation using class enums.

Instead of using a plain integer type and preprocessor constants to denote certain bit positions, this type provides a type safe implementation of a bitset with named bits based on a strongly typed enum class.

The interface is kept similar to that of std::bitset.

Definition at line 19 of file BitMask.hxx.

Member Typedef Documentation

◆ EnumBaseType

template<typename ENUM >

using cosmos::BitMask< ENUM >::EnumBaseType = typename std::underlying_type<ENUM>::type

Definition at line 26 of file BitMask.hxx.

Constructor & Destructor Documentation

◆ BitMask() [1/5]

template<typename ENUM >

cosmos::BitMask< ENUM >::BitMask ( )

inlineconstexpr

Sets all bits to zero.

Definition at line 31 of file BitMask.hxx.

31{}

◆ BitMask() [2/5]

template<typename ENUM >

cosmos::BitMask< ENUM >::BitMask ( const All a )

inlineexplicit

Sets all bits to one.

Definition at line 34 of file BitMask.hxx.

                                      {
                set(a);
        }

◆ BitMask() [3/5]

template<typename ENUM >

cosmos::BitMask< ENUM >::BitMask ( const std::initializer_list< ENUM > & init_list )

inlineconstexpr

Sets only the flags found in the given initializer list.

Definition at line 39 of file BitMask.hxx.

                                                                      {
                for (auto val: init_list) {
                        m_flags |= static_cast<EnumBaseType>(val);
                }
        }

◆ BitMask() [4/5]

template<typename ENUM >

cosmos::BitMask< ENUM >::BitMask ( const ENUM val )

inlineexplicitconstexpr

Sets exactly the given value to one.

Definition at line 46 of file BitMask.hxx.

                                                   :
                m_flags{static_cast<EnumBaseType>(val)}
        {}

◆ BitMask() [5/5]

template<typename ENUM >

cosmos::BitMask< ENUM >::BitMask ( const EnumBaseType value )

inlineexplicitconstexpr

Sets exactly the given primitive type bitmask.

Definition at line 51 of file BitMask.hxx.

                                                             :
                m_flags{value}
        {}

Member Function Documentation

◆ allOf() [1/2]

template<typename ENUM >

bool cosmos::BitMask< ENUM >::allOf ( const BitMask< ENUM > other ) const

inline

Definition at line 232 of file BitMask.hxx.

                                              {
                return (m_flags & other.m_flags) == other.m_flags;
        }

◆ allOf() [2/2]

template<typename ENUM >

bool cosmos::BitMask< ENUM >::allOf ( const std::initializer_list< ENUM > & flags ) const

inline

Tests whether all of the given values are set.

Definition at line 223 of file BitMask.hxx.

                                                                 {
                for (auto val: flags) {
                        if (!test(val))
                                return false;
                }
 
                return true;
        }

◆ any()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::any ( ) const

inline

Returns whether any bit in the bitset is set.

Definition at line 218 of file BitMask.hxx.

                         {
                return m_flags != 0;
        }

◆ anyOf() [1/2]

template<typename ENUM >

bool cosmos::BitMask< ENUM >::anyOf ( const BitMask< ENUM > other ) const

inline

Definition at line 246 of file BitMask.hxx.

                                              {
                return (m_flags & other.m_flags) != 0;
        }

◆ anyOf() [2/2]

template<typename ENUM >

bool cosmos::BitMask< ENUM >::anyOf ( const std::initializer_list< ENUM > & flags ) const

inline

Returns whether any of the given values is set.

Definition at line 237 of file BitMask.hxx.

                                                                 {
                for (auto val: flags) {
                        if (test(val))
                                return true;
                }
 
                return false;
        }

◆ count()

template<typename ENUM >

size_t cosmos::BitMask< ENUM >::count ( ) const

inline

Returns the number of set bits.

Definition at line 172 of file BitMask.hxx.

                             {
                size_t ret = 0;
 
                for (size_t bit = 0; bit < size(); bit++) {
                        auto val = 1 << bit;
                        if (this->test(static_cast<ENUM>(val)))
                                ret++;
                }
 
                return ret;
        }

◆ flip() [1/2]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::flip ( )

inline

Flip every bit in the bit mask.

Definition at line 160 of file BitMask.hxx.

                        {
                m_flags = ~m_flags;
                return *this;
        }

◆ flip() [2/2]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::flip ( const ENUM val )

inline

Flips the given value.

Definition at line 166 of file BitMask.hxx.

                                      {
                m_flags ^= static_cast<EnumBaseType>(val);
                return *this;
        }

◆ limit() [1/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::limit ( const BitMask< ENUM > other )

inline

Sets all bits to zero except the bits in the given mask.

Definition at line 149 of file BitMask.hxx.

                                            {
                m_flags &= other.raw();
                return *this;
        }

◆ limit() [2/4]

template<typename ENUM >

BitMask cosmos::BitMask< ENUM >::limit ( const BitMask< ENUM > other ) const

inline

Definition at line 154 of file BitMask.hxx.

                                                 {
                auto ret = *this;
                return ret.limit(other);
        }

◆ limit() [3/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::limit ( const ENUM flag )

inline

Sets all bits to zero except the given flag.

Definition at line 144 of file BitMask.hxx.

                                        {
                return limit({flag});
        }

◆ limit() [4/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::limit ( const std::initializer_list< ENUM > & flags )

inline

Sets all bits to zero except the given flags.

Definition at line 133 of file BitMask.hxx.

                                                               {
                EnumBaseType mask = 0;
                for (auto val: flags) {
                        mask |= static_cast<EnumBaseType>(val);
                }
 
                m_flags &= mask;
                return *this;
        }

◆ none()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::none ( ) const

inline

Returns whether no bit in the bitset is set.

Definition at line 251 of file BitMask.hxx.

                          {
                return !this->any();
        }

◆ only()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::only ( const ENUM val ) const

inline

Returns whether this is the only value set.

Definition at line 213 of file BitMask.hxx.

                                        {
                return m_flags == static_cast<EnumBaseType>(val);
        }

◆ operator std::string()

template<typename ENUM >

cosmos::BitMask< ENUM >::operator std::string ( ) const

inlineexplicit

Return a string representation of the bit mask.

Definition at line 59 of file BitMask.hxx.

59{ return toString(); }

◆ operator!=()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::operator!= ( const BitMask< ENUM > & other ) const

inline

Definition at line 259 of file BitMask.hxx.

                                                    {
                return !(*this == other);
        }

◆ operator&() [1/2]

template<typename ENUM >

ENUM cosmos::BitMask< ENUM >::operator& ( const BitMask< ENUM > & other ) const

inline

returns an ENUM value containing only the values found in both masks.

Definition at line 269 of file BitMask.hxx.

                                                   {
                return ENUM{other.raw() & this->raw()};
        }

◆ operator&() [2/2]

template<typename ENUM >

bool cosmos::BitMask< ENUM >::operator& ( const ENUM val ) const

inline

Checks whether any bit of the given value is set,.

See also: testAny().

Definition at line 264 of file BitMask.hxx.

                                             {
                return testAny(val);
        }

◆ operator==()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::operator== ( const BitMask< ENUM > & other ) const

inline

Definition at line 255 of file BitMask.hxx.

                                                    {
                return m_flags == other.m_flags;
        }

◆ operator[]()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::operator[] ( const ENUM flag ) const

inline

Returns a boolean value for the given value,.

See also: test().

Definition at line 62 of file BitMask.hxx.

62{ return test(flag); }

◆ operator~()

template<typename ENUM >

BitMask cosmos::BitMask< ENUM >::operator~ ( ) const

inline

Definition at line 273 of file BitMask.hxx.

                                  {
                return BitMask{~m_flags};
        }

◆ raw()

template<typename ENUM >

EnumBaseType cosmos::BitMask< ENUM >::raw ( ) const

inline

Returns the raw bitfield integer.

Definition at line 56 of file BitMask.hxx.

56{ return m_flags; }

◆ reset() [1/5]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::reset ( )

inline

Sets all bits to zero.

Definition at line 103 of file BitMask.hxx.

                         {
                m_flags = EnumBaseType{0};
                return *this;
        }

◆ reset() [2/5]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::reset ( const BitMask< ENUM > other )

inline

Definition at line 122 of file BitMask.hxx.

                                            {
                m_flags &= ~(other.raw());
                return *this;
        }

◆ reset() [3/5]

template<typename ENUM >

BitMask cosmos::BitMask< ENUM >::reset ( const BitMask< ENUM > other ) const

inline

Definition at line 127 of file BitMask.hxx.

                                                 {
                auto ret = *this;
                return ret.reset(other);
        }

◆ reset() [4/5]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::reset ( const ENUM val )

inline

Zeroes the given value.

Definition at line 109 of file BitMask.hxx.

                                       {
                reset({val});
                return *this;
        }

◆ reset() [5/5]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::reset ( const std::initializer_list< ENUM > & flags )

inline

Zeroes all of the given values.

Definition at line 115 of file BitMask.hxx.

                                                               {
                for (auto val: flags) {
                        m_flags &= ~static_cast<EnumBaseType>(val);
                }
                return *this;
        }

◆ set() [1/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::set ( const All )

inline

Sets all bits it the set.

Definition at line 77 of file BitMask.hxx.

                                {
                m_flags = ~EnumBaseType(0);
                return *this;
        }

◆ set() [2/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::set ( const BitMask< ENUM > other )

inline

Sets all the bits that are also set in other.

Definition at line 97 of file BitMask.hxx.

                                          {
                m_flags |= other.m_flags;
                return *this;
        }

◆ set() [3/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::set	(	const ENUM	val,
		bool	on_off = true )

inline

Set or unset the given value.

Definition at line 83 of file BitMask.hxx.

                                                         {
                const auto bitval = static_cast<EnumBaseType>(val);
                m_flags = (on_off ? (m_flags|bitval) : (m_flags & ~bitval));
                return *this;
        }

◆ set() [4/4]

template<typename ENUM >

BitMask & cosmos::BitMask< ENUM >::set ( const std::initializer_list< ENUM > & flags )

inline

Definition at line 89 of file BitMask.hxx.

                                                             {
                for (auto flag: flags) {
                        set(flag);
                }
                return *this;
        }

◆ size()

template<typename ENUM >

size_t cosmos::BitMask< ENUM >::size ( ) const

inlineconstexpr

Returns the maximum number of bits that can be stored in the bit mask.

Definition at line 185 of file BitMask.hxx.

                                      {
                return sizeof(EnumBaseType) * 8;
        }

◆ test()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::test ( const ENUM val ) const

inline

Returns whether the given value is set.

Note: If val consists of multiple bits then this only returns true if all of the bits it represents are set.

Definition at line 194 of file BitMask.hxx.

                                        {
                const auto raw_val = static_cast<EnumBaseType>(val);
                return (m_flags & raw_val) == raw_val;
        }

◆ testAny()

template<typename ENUM >

bool cosmos::BitMask< ENUM >::testAny ( const ENUM val ) const

inline

Returns whether any of the bits of val are set.

This is only different to test() if the given value consists of multiple bit positions. In this case testAny() will return true even if only some of the bit positions are set in the mask, while test() will only return true if all of the bit positions are set.

Definition at line 207 of file BitMask.hxx.

                                           {
                return ((m_flags & static_cast<EnumBaseType>(val)) != 0);
        }

◆ toString()

template<typename ENUM >

std::string cosmos::BitMask< ENUM >::toString ( ) const

inline

Definition at line 64 of file BitMask.hxx.

                                   {
                std::string ret;
 
                // append each bit starting with the highest one
                for (int bit = size() - 1; bit >= 0; bit--) {
                        const auto val = 1 << bit;
                        ret.push_back(this->test(static_cast<ENUM>(val)) ? '1' : '0');
                }
 
                return ret;
        }

Friends And Related Symbol Documentation

◆ operator+ [1/2]

template<typename ENUM >

BitMask operator+	(	const BitMask< ENUM > &	first,
		const BitMask< ENUM > &	second )

friend

Returns an object containing all the bits found in first and second.

Definition at line 290 of file BitMask.hxx.

                                                                              {
                BitMask ret{first};
                return ret.set(second);
        }

◆ operator+ [2/2]

template<typename ENUM >

BitMask operator+	(	const BitMask< ENUM > &	first,
		const ENUM	val )

friend

Returns an object containing all the bits found in first and /also val.

Definition at line 296 of file BitMask.hxx.

                                                                       {
                BitMask ret{first};
                return ret.set(val);
        }

◆ operator- [1/2]

template<typename ENUM >

BitMask operator-	(	const BitMask< ENUM > &	first,
		const BitMask< ENUM > &	second )

friend

Returns an object containing all the bits found in first without the bits found inc second.

Definition at line 278 of file BitMask.hxx.

                                                                              {
                BitMask ret{first};
                return ret.reset(second);
        }

◆ operator- [2/2]

template<typename ENUM >

BitMask operator-	(	const BitMask< ENUM > &	first,
		const ENUM	val )

friend

Returns an object containing all the bits found in first without val.

Definition at line 284 of file BitMask.hxx.

                                                                       {
                BitMask ret{first};
                return ret.reset(val);
        }

Member Data Documentation

◆ all

template<typename ENUM >

All cosmos::BitMask< ENUM >::all {}

staticconstexpr

Definition at line 24 of file BitMask.hxx.

24{};

◆ m_flags

template<typename ENUM >

EnumBaseType cosmos::BitMask< ENUM >::m_flags = 0

protected

Definition at line 303 of file BitMask.hxx.

The documentation for this class was generated from the following file:

include/BitMask.hxx

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ EnumBaseType

Constructor & Destructor Documentation

◆ BitMask() [1/5]

◆ BitMask() [2/5]

◆ BitMask() [3/5]

◆ BitMask() [4/5]

◆ BitMask() [5/5]

Member Function Documentation

◆ allOf() [1/2]

◆ allOf() [2/2]

◆ any()

◆ anyOf() [1/2]

◆ anyOf() [2/2]

◆ count()

◆ flip() [1/2]

◆ flip() [2/2]

◆ limit() [1/4]

◆ limit() [2/4]

◆ limit() [3/4]

◆ limit() [4/4]

◆ none()

◆ only()

◆ operator std::string()

◆ operator!=()

◆ operator&() [1/2]

◆ operator&() [2/2]

◆ operator==()

◆ operator[]()

◆ operator~()

◆ raw()

◆ reset() [1/5]

◆ reset() [2/5]

◆ reset() [3/5]

◆ reset() [4/5]

◆ reset() [5/5]

◆ set() [1/4]

◆ set() [2/4]

◆ set() [3/4]

◆ set() [4/4]

◆ size()

◆ test()

◆ testAny()

◆ toString()

Friends And Related Symbol Documentation

◆ operator+ [1/2]

◆ operator+ [2/2]

◆ operator- [1/2]

◆ operator- [2/2]

Member Data Documentation

◆ all

◆ m_flags