A class containing a set of flags. More...

#include "FlagSet.h"

Inheritance diagram for util::flags::FlagSet< NFlags, Storage >:

Public Types
using	This_t = FlagSet< NFlags, Storage >
	Type of this class. More...

using	Mask_t = BitMask< Storage >
	Type of bit mask for this flag set. More...

using	Base_t = Mask_t
	Type of the base class. More...

using	Bits_t = typename Mask_t::Bits_t
	Type of bits for this flag set. More...

using	FlagIndex_t = typename Mask_t::FlagIndex_t
	Type of index of flag. More...

using	Flag_t = typename Mask_t::Flag_t
	Type identifying a single flag. More...

Exceptions
using	Exception = typename Mask_t::Exception
	Generic BitMask exception. More...

using	OutOfRangeError = typename Mask_t::OutOfRangeError
	Out-of-range flag index. More...

using	FlagNotDefinedError = typename Mask_t::FlagNotDefinedError
	Flag not defined. More...

Public Member Functions
	FlagSet ()=default

	FlagSet (This_t const &)=default

	FlagSet (This_t &&)=default

FlagSet &	operator= (This_t const &)=default

FlagSet &	operator= (This_t &&)=default

constexpr	FlagSet (Mask_t const &from)
	Constructor: copy the specified mask. More...

template<typename Stream >
void	dump (Stream &&out) const
	Dumps on screen only the "official" flags (see `size()`). More...

constexpr bool	operator== (Mask_t const &other) const

constexpr bool	operator!= (Mask_t const &other) const

template<typename Stream >
void	dump (Stream &&out, unsigned int nBits) const
	Prints into the specified stream the least nBits significant bits. More...

Access to flags
constexpr Mask_t const &	mask () const
	Returns all the flags in the form of a mask. More...

constexpr bool	isFlag (FlagIndex_t flagIndex) const
	Returns whether the flag index is valid. More...

constexpr bool	isFlag (Flag_t flag) const
	Returns whether the flag index is valid. More...

bool	test (Flag_t flag) const
	Returns if the specified flag is set. More...

bool	test (FlagIndex_t flagIndex) const
	Returns if the specified flag is set. More...

Access to flags
constexpr bool	isDefined (Flag_t flag) const
	Returns whether the flag is defined. More...

constexpr bool	isDefined (Bits_t bits) const
	Returns whether all specified bits are defined. More...

constexpr bool	isUndefined (Flag_t flag) const
	Returns whether the flag is undefined. More...

constexpr bool	isUndefined (Bits_t bits) const
	Returns whether all specified bits are undefined. More...

constexpr bool	get (Flag_t flag) const
	Returns if the specified flag is on ("set"). More...

constexpr bool	isSet (Flag_t flag) const
	Returns if the specified flag is set. More...

constexpr bool	isUnset (Flag_t flag) const
	Returns if the specified flag is unset. More...

constexpr bool	all (Bits_t bits) const
	Returns whether all the specified bits are set. More...

constexpr bool	any (Bits_t bits) const
	Returns whether at least one of the specified bits is set. More...

constexpr bool	none (Bits_t bits) const
	Returns whether all the specified bits are unset. More...

constexpr bool	anySet (Mask_t const &mask) const
	Returns whether any of the bits set in the mask are set. More...

constexpr bool	noneSet (Mask_t const &mask) const
	Returns whether none of the bits set in the mask is set. More...

constexpr bool	match (Mask_t const &mask) const
	Returns whether all bits defined in the mask are equal to ours. More...

Setting flags
template<typename Flag , typename... OtherFlags>
void	set (Flag first, OtherFlags...others)
	Sets all specified flags. More...

template<typename BeginIter , typename EndIter >
void	rangeSet (BeginIter begin, EndIter end)
	Sets all flags specified by the index iterator range. More...

template<typename Flag , typename... OtherFlags>
void	unset (Flag first, OtherFlags...others)
	Unsets all specified flags. More...

template<typename BeginIter , typename EndIter >
void	rangeUnset (BeginIter begin, EndIter end)
	Unsets all flags specified by the index iterator range. More...

template<typename Flag , typename... OtherFlags>
void	remove (Flag first, OtherFlags...others)
	Declares all specified flags as undefined. More...

void	clear ()
	Undefines all bits. More...

Static Public Member Functions
static constexpr size_t	size ()
	Returns the number of flags the set supports. More...

template<typename... Args>
static constexpr Mask_t	createMask (Args...args)
	Creates a new BitMask. More...

Number of flags
static constexpr size_t	capacity ()
	Returns the number of flags the set has room for. More...

Static mask manipulation
template<typename... Args>
static constexpr Mask_t	create (Args...args)
	Creates a new BitMask. More...

static constexpr Mask_t	mergeIntoMask (Mask_t baseMask, Mask_t mask)
	Returns a new mask with the content of the other `mask` merged. More...

static constexpr Mask_t	mergeIntoMask (Mask_t baseMask, Bits_t bits)
	Returns a new mask with the specified bits defined and set. More...

static constexpr Mask_t	mergeIntoMask (Mask_t baseMask, Flag_t flag)
	Returns a new mask with the specified flag defined and set. More...

static constexpr Mask_t	combineWithMask (Mask_t A, Mask_t B)
	Returns a new mask combining bits set from two masks. More...

static constexpr Mask_t	combineWithMask (Mask_t baseMask, Bits_t bits)
	Returns a new mask with the specified flag defined and set. More...

static constexpr Mask_t	combineWithMask (Mask_t baseMask, Flag_t flag)
	Returns a new mask with the specified flag defined and set. More...

static constexpr Mask_t	intersectWithMask (Mask_t A, Mask_t B)
	Returns a new mask with the bits set from both masks. More...

static constexpr Mask_t	intersectWithMask (Mask_t baseMask, Bits_t bits)
	Returns a new mask with only the specified bits set. More...

static constexpr Mask_t	intersectWithMask (Mask_t baseMask, Flag_t flag)
	Returns a new mask with the specified flag as only set flag. More...

static constexpr Mask_t	unsetMask (Mask_t baseMask, Mask_t mask)
	Returns a new mask with the bits set from both masks. More...

static constexpr Mask_t	unsetMask (Mask_t baseMask, Bits_t bits)
	Returns a new mask with only the specified bits set. More...

static constexpr Mask_t	unsetMask (Mask_t baseMask, Flag_t flag)
	Returns a new mask with the specified flag as only set flag. More...

static constexpr Mask_t	negateMask (Mask_t mask)
	Returns the negation of mask. More...

static constexpr Mask_t	negateMask (Bits_t bits)
	Returns a new mask with the specified bits unset. More...

static constexpr Mask_t	negateMask (Flag_t flag)
	Returns a new mask with the specified flag unset. More...

Static Public Attributes
static constexpr auto	fromValues = maskFromValues
	Constructor tag from values. More...

Private Member Functions
bool	testImpl (Flag_t flag) const
	Implementation detail of test() More...

Detailed Description

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>
class util::flags::FlagSet< NFlags, Storage >

A class containing a set of flags.

Template Parameters

NFlags	number of flags to be allocated
Storage	underlying integral type whose bits represent the flags

A FlagSet contains a set of flags. Each flag can be in one of two states ("set" and "unset"), or can be not defined at all ("undefined").

Note that the object might have a capacity() larger than just NFlags. The flags after the first NFlags are "unsupported", in the sense that in future implementations they might disappear. For the rest, they behave just like the other flags though.

Definition at line 40 of file FlagSet.h.

Member Typedef Documentation

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::Base_t = Mask_t

Type of the base class.

Definition at line 50 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::Bits_t = typename Mask_t::Bits_t

Type of bits for this flag set.

Definition at line 53 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::Exception = typename Mask_t::Exception

Generic BitMask exception.

Definition at line 65 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::Flag_t = typename Mask_t::Flag_t

Type identifying a single flag.

Definition at line 59 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::FlagIndex_t = typename Mask_t::FlagIndex_t

Type of index of flag.

Definition at line 56 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::FlagNotDefinedError = typename Mask_t::FlagNotDefinedError

Flag not defined.

Definition at line 71 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::Mask_t = BitMask<Storage>

Type of bit mask for this flag set.

Definition at line 48 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::OutOfRangeError = typename Mask_t::OutOfRangeError

Out-of-range flag index.

Definition at line 68 of file FlagSet.h.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

using util::flags::FlagSet< NFlags, Storage >::This_t = FlagSet<NFlags, Storage>

Type of this class.

Definition at line 46 of file FlagSet.h.

Constructor & Destructor Documentation

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

util::flags::FlagSet< NFlags, Storage >::FlagSet ( )

default

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

util::flags::FlagSet< NFlags, Storage >::FlagSet ( This_t const & )

default

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

util::flags::FlagSet< NFlags, Storage >::FlagSet ( This_t && )

default

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

constexpr util::flags::FlagSet< NFlags, Storage >::FlagSet ( Mask_t const & from )

inline

Constructor: copy the specified mask.

Definition at line 83 of file FlagSet.h.

83 : Base_t(from) {}

util::flags::FlagSet::Base_t

Mask_t Base_t

Type of the base class.

Definition: FlagSet.h:50

Member Function Documentation

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::all ( Bits_t bits ) const

inherited

Returns whether all the specified bits are set.

Parameters

bits	bits to check

Returns: whether all bits are set

See also: isSet(Flag_t)

This method is equivalent to calling isSet(Flag_t) on each single flag defined in bits. The result is true only if all of them are set, that includes all of them being defined.

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::any ( Bits_t bits ) const

inherited

Returns whether at least one of the specified bits is set.

Parameters

bits	bits to check

Returns: whether any of the bits is set

See also: isSet(Flag_t)

This method is equivalent to calling isSet(Flag_t) on each single flag defined in bits. The result is true only if at least one of them is set (including that one being defined).

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::anySet ( Mask_t const & mask ) const

inherited

Returns whether any of the bits set in the mask are set.

Parameters

mask	the mask of bits

Returns: whether we have any of those bits set

See also: noneSet(), match()

The bits that are undefined in mask are not used to compute the result.

template<typename Storage>

static constexpr size_t util::flags::BitMask< Storage >::capacity ( )

staticinherited

Returns the number of flags the set has room for.

template<typename Storage>

void util::flags::BitMask< Storage >::clear ( )

inlineinherited

Undefines all bits.

Definition at line 799 of file BitMask.h.

References util::values().

       {
         presence.clear();
         values.clear();
       }

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::combineWithMask	(	Mask_t	A,
		Mask_t	B
	)

staticinherited

Returns a new mask combining bits set from two masks.

Parameters

A	one of the masks to be combined
B	the other mask to be combined

Returns: a new mask with all set bits from of the two masks

The content of the new mask has a bit set if it was set (isSet()) in either of the masks, otherwise unset if it was unset (isUnset()) in either of the masks, or else undefined (isUndefined()), as it was undefined in both masks.

The result differs from mergeIntoMask() only for bits which are set (isSet()) in the first mask but unset (isUnset()) in the second: combineWithMask() will leave the bit set, like in the first mask, while mergeIntoMask() would have that bit always unset.

This is equivalent to a flagwise OR operation.

The truth table of the operation is described in the following table, where '-' represents an undefined flag (isUndefined()), '0' an unset flag (isUnset()), and '1' a set flag (isSet()).

B	-	0	1
A
-	-	0	1
0	0	0	1
1	1	1	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::combineWithMask	(	Mask_t	baseMask,
		Bits_t	bits
	)

staticinherited

Returns a new mask with the specified flag defined and set.

Parameters

baseMask	the starting mask
bits	the bits to be set

Returns: a new mask with all content from baseMask, plus the flag bit set

The truth table of this operation follows (see mergeIntoMask() for its legend).

`bits`	0	1
`baseMask`
-	-	1
0	0	1
1	1	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::combineWithMask	(	Mask_t	baseMask,
		Flag_t	flag
	)

staticinherited

Returns a new mask with the specified flag defined and set.

Parameters

baseMask	the starting mask
flag	the single flag to be set

Returns: a new mask with all content from baseMask, plus the bits set

template<typename Storage>

template<typename... Args>

static constexpr Mask_t util::flags::BitMask< Storage >::create ( Args... args )

staticinherited

Creates a new BitMask.

Template Parameters

Args	types of the arguments

Parameters

args	the data to create the mask from

Returns: a BitMask with the features specified in the arguments

If no argument is provided, the mask is returned with all the flags undefined (like in default constructor). The order of the arguments matters: the first arguments are processed first and their effect can be overridden by the following arguments. For the details, see mergeIntoMask(), which is used to incrementally merge the argument to create the result.

Referenced by util::flags::FlagSet< NFlags, Storage >::createMask().

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

template<typename... Args>

static constexpr Mask_t util::flags::FlagSet< NFlags, Storage >::createMask ( Args... args )

inlinestatic

Creates a new BitMask.

Template Parameters

Args	types of the arguments

Parameters

args	the data to create the mask from

Returns: a BitMask with the features specified in the arguments

If no argument is provided, the mask is returned with all the flags undefined (like in default constructor). For the details, see BitMask<Storage>::createMask().

Definition at line 173 of file FlagSet.h.

References util::flags::BitMask< Storage >::create(), and util::flags::FlagSet< NFlags, Storage >::testImpl().

       {
         return Mask_t::create(args...);
       }

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

template<typename Stream >

void util::flags::FlagSet< NFlags, Storage >::dump ( Stream && out ) const

inline

Dumps on screen only the "official" flags (see size()).

Definition at line 153 of file FlagSet.h.

References util::flags::BitMask< Storage >::dump(), util::flags::FlagSet< NFlags, Storage >::mask(), and util::flags::FlagSet< NFlags, Storage >::size().

       {
         mask().dump(std::forward<Stream>(out), size());
       }

template<typename Storage>

template<typename Stream >

void util::flags::BitMask< Storage >::dump	(	Stream &&	out,
		unsigned int	nBits
	)		const

inherited

Prints into the specified stream the least nBits significant bits.

Referenced by util::flags::FlagSet< NFlags, Storage >::dump().

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::get ( Flag_t flag ) const

inherited

Returns if the specified flag is on ("set").

Parameters

flag	index of the flag to test

Returns: whether the specified flag is set

This method provides an unchecked access to a single flag value. If the flag is isUndefined(), the behaviour of this method is also undefined.

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::intersectWithMask	(	Mask_t	A,
		Mask_t	B
	)

staticinherited

Returns a new mask with the bits set from both masks.

Parameters

A	one of the masks to be combined
B	the other mask to be combined

Returns: a new mask with all bits set in both masks

The content of the new mask has a bit set if it was set (isSet()) in both masks, otherwise unset if it was unset (isUnset()) in either of the masks, or else undefined (isUndefined()), as it was undefined in both masks.

This is equivalent to a flagwise AND operation.

The truth table of the operation is described in the following table, where '-' represents an undefined flag (isUndefined()), '0' an unset flag (isUnset()), and '1' a set flag (isSet()).

`B`	-	0	1
`A`
-	-	0	1
0	0	0	0
1	1	0	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::intersectWithMask	(	Mask_t	baseMask,
		Bits_t	bits
	)

staticinherited

Returns a new mask with only the specified bits set.

Parameters

baseMask	the starting mask
bits	the bits to be set

Returns: a new mask with all defined flags from baseMask, with only the specified bits set

All bits in the argument are also defined.

The truth table of this operation follows (see mergeIntoMask() for its legend).

`bits`	0	1
`baseMask`
-	-	1
0	0	0
1	0	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::intersectWithMask	(	Mask_t	baseMask,
		Flag_t	flag
	)

staticinherited

Returns a new mask with the specified flag as only set flag.

Parameters

baseMask	the starting mask
flag	the single flag to be set

Returns: a new mask with all flags from baseMask, with only flag set

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isDefined ( Flag_t flag ) const

inherited

Returns whether the flag is defined.

Parameters

flag	index of the flag to check

Returns: whether the flag is defined

A flag must be defined before it can be used. A common convention is to use the "undefined" state of the flag to denote that its value is currently unknown.

A flag is defined by setting (set()) or unsetting (unset()) it.

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isDefined ( Bits_t bits ) const

inherited

Returns whether all specified bits are defined.

Parameters

bits	bits to check

Returns: whether all bits set in bits are defined

See also: isDefined(Flag_t)

This method is equivalent to calling isDefined(Flag_t) on each single flag defined in bits. The result is true only if all of them are defined.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

constexpr bool util::flags::FlagSet< NFlags, Storage >::isFlag ( FlagIndex_t flagIndex ) const

Returns whether the flag index is valid.

Parameters

flagIndex index of the flag to check

Returns: whether the flag index is valid

Valid flag index values go from 0 up to the size (size()) of this flag set.

Referenced by util::flags::FlagSet< NFlags, Storage >::mask().

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

constexpr bool util::flags::FlagSet< NFlags, Storage >::isFlag ( Flag_t flag ) const

Returns whether the flag index is valid.

Parameters

flag	flag to check

Returns: whether the flag is valid

Valid flag index values go from 0 up to the size (size()) of this flag set.

Note: This method is unable to check flags that are beyond the capacity of the flag set itself. For example, in a flag set represented with 8 bits, the Flag_t value corresponding to flag #12 would be Flag_t(0x1000), which is beyond the range that Flag_t can represent.

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isSet ( Flag_t flag ) const

inherited

Returns if the specified flag is set.

Parameters

flag	index of the flag to test

Returns: whether the specified flag is set

This method provides an unchecked access to a single flag value. If the flag is isUndefined(), the behaviour of this method is also undefined.

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isUndefined ( Flag_t flag ) const

inherited

Returns whether the flag is undefined.

Parameters

flag	index of the flag to check

Returns: whether the flag is undefined

See also: isUndefined()

This is exactly the negation of isDefined().

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isUndefined ( Bits_t bits ) const

inherited

Returns whether all specified bits are undefined.

Parameters

bits	bits to check

Returns: whether all bits set in bits are undefined

See also: isDefined(Bits_t), isUndefined(Flag_t)

This is exactly the negation of isDefined().

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::isUnset ( Flag_t flag ) const

inherited

Returns if the specified flag is unset.

Parameters

flag	index of the flag to test

Returns: whether the specified flag is unset

This method provides an unchecked access to a single flag value. If the flag is isUndefined(), the behaviour of this method is also undefined.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

constexpr Mask_t const& util::flags::FlagSet< NFlags, Storage >::mask ( ) const

inline

Returns all the flags in the form of a mask.

Definition at line 91 of file FlagSet.h.

References util::flags::FlagSet< NFlags, Storage >::isFlag(), and util::flags::FlagSet< NFlags, Storage >::test().

Referenced by util::flags::FlagSet< NFlags, Storage >::dump().

91 { return *this; }

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::match ( Mask_t const & mask ) const

inherited

Returns whether all bits defined in the mask are equal to ours.

Parameters

mask	the mask of bits

Returns: whether the mask matches ours

The flags that are undefined in mask are not used to compute the result. If all the flags that are set in mask (isSet()) are set in this object, and likewise all the flags that are unset in mask (isUnset()) are unset, this method returns true.

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::mergeIntoMask	(	Mask_t	baseMask,
		Mask_t	mask
	)

staticinherited

Returns a new mask with the content of the other mask merged.

Parameters

baseMask	the starting mask
mask	the bits to be set

Returns: a new mask with all the content of base and the new mask

The content of the new mask overrides the base one: if a flag is defined in mask, it is defined and copied into the result, otherwise the state of the flag is copied from baseMask.

The truth table of the operation is described in the following table, where '-' represents an undefined flag (isUndefined()), '0' an unset flag (isUnset()), and '1' a set flag (isSet()).

`mask`	-	0	1
`baseMask`
-	-	0	1
0	0	0	1
1	1	0	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::mergeIntoMask	(	Mask_t	baseMask,
		Bits_t	bits
	)

staticinherited

Returns a new mask with the specified bits defined and set.

Parameters

baseMask	the starting mask
bits	the bits to be set

Returns: a new mask with all content from baseMask, plus the flag bit set

The truth table of this operation follows (see mergeIntoMask() for its legend).

`bits`	0	1
`baseMask`
-	-	1
0	0	1
1	1	1

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::mergeIntoMask	(	Mask_t	baseMask,
		Flag_t	flag
	)

staticinherited

Returns a new mask with the specified flag defined and set.

Parameters

baseMask	the starting mask
flag	the single flag to be set

Returns: a new mask with all content from baseMask, plus the flag bit set

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::negateMask ( Mask_t mask )

staticinherited

Returns the negation of mask.

Parameters

mask	the starting mask

Returns: a new mask with all defined bits flipped

The bits which were undefined, stay so. The others change their value.

The truth table of this operation follows (see mergeIntoMask() for its legend).

`mask`	`negate()`
-	-
0	1
1	0

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::negateMask ( Bits_t bits )

staticinherited

Returns a new mask with the specified bits unset.

Parameters

bits	bits to be unset

Returns: a new mask with the specified bits unset

Only the unset bits are defined.

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::negateMask ( Flag_t flag )

staticinherited

Returns a new mask with the specified flag unset.

Parameters

flag	the single flag to be set

Returns: a new mask with only the flag bit defined, and unset

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::none ( Bits_t bits ) const

inherited

Returns whether all the specified bits are unset.

Parameters

bits	bits to check

Returns: whether all bits are unset

See also: isUnset(Flag_t)

This method is equivalent to calling isUnset(Flag_t) on each single flag defined in bits. The result is true only if all of them are unset, that includes all of them being defined.

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::noneSet ( Mask_t const & mask ) const

inherited

Returns whether none of the bits set in the mask is set.

Parameters

mask	the mask of bits

Returns: whether we have any of those bits set

See also: anySet(), match()

This is the logical negation of anySet().

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::operator!= ( Mask_t const & other ) const

inlineinherited

Comparison: not all flags must be the same

Bug:: Also the value of undefined flags is currently checked

Definition at line 827 of file BitMask.h.

References util::flags::BitMask< Storage >::presence, util::values(), and util::flags::BitMask< Storage >::values.

       {
         return (values != other.values) || (presence != other.presence);
       }

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

FlagSet& util::flags::FlagSet< NFlags, Storage >::operator= ( This_t const & )

default

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

FlagSet& util::flags::FlagSet< NFlags, Storage >::operator= ( This_t && )

default

template<typename Storage>

constexpr bool util::flags::BitMask< Storage >::operator== ( Mask_t const & other ) const

inlineinherited

Comparison: all flags must be the same

Bug:: Also the value of undefined flags is currently checked

Definition at line 820 of file BitMask.h.

References util::flags::BitMask< Storage >::presence, util::values(), and util::flags::BitMask< Storage >::values.

       {
         return (values == other.values) && (presence == other.presence);
       }

template<typename Storage>

template<typename BeginIter , typename EndIter >

void util::flags::BitMask< Storage >::rangeSet	(	BeginIter	begin,
		EndIter	end
	)

inherited

Sets all flags specified by the index iterator range.

Template Parameters

BeginIter	type of iterator to the first of the flags
EndIter	type of end iterator

Parameters

begin	iterator to the index of the first flag
end	iterator past the index of the last flag

See also: set()

Each flag is set as if set(flag) were called.

template<typename Storage>

template<typename BeginIter , typename EndIter >

void util::flags::BitMask< Storage >::rangeUnset	(	BeginIter	begin,
		EndIter	end
	)

inherited

Unsets all flags specified by the index iterator range.

Template Parameters

BeginIter	type of iterator to the first of the flags
EndIter	type of end iterator

Parameters

begin	iterator to the index of the first flag
end	iterator past the index of the last flag

See also: unset()

Each flag is unset as if unset(flag) were called.

template<typename Storage>

template<typename Flag , typename... OtherFlags>

void util::flags::BitMask< Storage >::remove	(	Flag	first,
		OtherFlags...	others
	)

inlineinherited

Declares all specified flags as undefined.

Template Parameters

Flag	types of the first flag
OtherFlags	types of other optional flags

Parameters

first	the first flag to be removed
others	flags also to be removed

See also: set(), unset(), isDefined()

All specified flags are marked back as undefined. Already undefined flags are not affected. The value of an undefined flag is... well, undefined.

There is no equivalent direct way to just define a flag, but rather when a flag is assigned a value the first time, that flag is at the same time defined.

Each argument can be of one of the following supported types:

Flag_t: single flag (a FlagIndex_t can be implicitly converted to this one, too)

Definition at line 793 of file BitMask.h.

       {
         undefineImpl(first, others...);
       }

template<typename Storage>

template<typename Flag , typename... OtherFlags>

void util::flags::BitMask< Storage >::set	(	Flag	first,
		OtherFlags...	others
	)

inlineinherited

Sets all specified flags.

Template Parameters

Flag	types of the first flag
OtherFlags	types of other optional flags

Parameters

first	the first flag to be set
others	flags also to be set

All specified flags are set. Flags set are automatically defined.

Each argument can be of one of the following supported types:

Flag_t: single flag (a FlagIndex_t can be implicitly converted to this one, too)

Definition at line 724 of file BitMask.h.

References util::begin(), and util::end().

       {
         setImpl(first, others...);
       }

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

static constexpr size_t util::flags::FlagSet< NFlags, Storage >::size ( )

inlinestatic

Returns the number of flags the set supports.

Definition at line 159 of file FlagSet.h.

Referenced by util::flags::FlagSet< NFlags, Storage >::dump().

159 { return NFlags; }

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

bool util::flags::FlagSet< NFlags, Storage >::test ( Flag_t flag ) const

Returns if the specified flag is set.

Parameters

flag	flag to test

Returns: whether the specified flag is set

Exceptions

FlagNotDefinedError	if the flag was not defined at all
OutOfRangeError	if the flag index denotes a non-existing flag

This method provides a checked access to a single flag value. If the flag is not supported (see isFlag()), or if it is isUndefined(), an exception is thrown.

See get() for an unchecked access.

Referenced by util::flags::FlagSet< NFlags, Storage >::mask().

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

bool util::flags::FlagSet< NFlags, Storage >::test ( FlagIndex_t flagIndex ) const

Returns if the specified flag is set.

Parameters

flagIndex index of the flag to test

Returns: whether the specified flag is set

Exceptions

FlagNotDefinedError	if the flag was not defined at all
OutOfRangeError	if the flag index denotes a non-existing flag

This method provides a checked access to a single flag value. If the flag is not supported (see isFlag()), or if it is isUndefined(), an exception is thrown.

See get() for an unchecked access.

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>

bool util::flags::FlagSet< NFlags, Storage >::testImpl ( Flag_t flag ) const

private

Implementation detail of test()

Referenced by util::flags::FlagSet< NFlags, Storage >::createMask().

template<typename Storage>

template<typename Flag , typename... OtherFlags>

void util::flags::BitMask< Storage >::unset	(	Flag	first,
		OtherFlags...	others
	)

inlineinherited

Unsets all specified flags.

Template Parameters

Flag	types of the first flag
OtherFlags	types of other optional flags

Parameters

first	the first flag to be unset
others	flags also to be unset

See also: set()

All specified flags are unset. Flags unset are automatically defined. The types accepted are the same as for set().

Definition at line 754 of file BitMask.h.

Referenced by trkmkr::KalmanFilterFitTrackMaker::restoreInputPoints().

       {
         unsetImpl(first, others...);
       }

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::unsetMask	(	Mask_t	baseMask,
		Mask_t	mask
	)

staticinherited

Returns a new mask with the bits set from both masks.

Parameters

baseMask	one of the masks to be combined
mask	the other mask to be combined

Returns: a new mask with all bits set in both masks

The content of the new mask has a bit set if it was set (isSet()) in both masks, otherwise unset if it was unset (isUnset()) in either of the masks, or else undefined (isUndefined()), as it was undefined in both masks.

The truth table of this operation follows (see mergeIntoMask() for its legend).

`mask`	-	0	1
`baseMask`
-	-	0	0
0	0	0	0
1	1	1	0

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::unsetMask	(	Mask_t	baseMask,
		Bits_t	bits
	)

staticinherited

Returns a new mask with only the specified bits set.

Parameters

baseMask	the starting mask
bits	the bits to be set

Returns: a new mask with all defined flags from baseMask, with only the specified bits set

All bits in the argument are also defined.

The truth table of this operation follows (see mergeIntoMask() for its legend).

`bits`	0	1
`baseMask`
-	-	0
0	0	0
1	1	0

template<typename Storage>

static constexpr Mask_t util::flags::BitMask< Storage >::unsetMask	(	Mask_t	baseMask,
		Flag_t	flag
	)

staticinherited

Returns a new mask with the specified flag as only set flag.

Parameters

baseMask	the starting mask
flag	the single flag to be set

Returns: a new mask with all flags from baseMask, with only flag set

Member Data Documentation

template<typename Storage>

constexpr auto util::flags::BitMask< Storage >::fromValues = maskFromValues

staticinherited

Constructor tag from values.

Definition at line 437 of file BitMask.h.

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

lardataobj/v09_18_03/source/lardataobj/Utilities/FlagSet.h

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Detailed Description

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>> class util::flags::FlagSet< NFlags, Storage >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<unsigned int NFlags, typename Storage = details::smallestUInt_t<NFlags>>
class util::flags::FlagSet< NFlags, Storage >