sta-core/include/sta/enum_flags.hpp

/**
 * @file
 * @brief Helper for using enum values as flags.
 */
#ifndef STA_ENUM_FLAGS_HPP
#define STA_ENUM_FLAGS_HPP

#include <cstdint>


namespace sta
{
	/**
	 * @brief 32-bit flag register with enum type representing single flag bits.
	 *
	 * @tparam F    Enum type used for flag bits
	 *
	 * @ingroup staCore
	 */
	template <typename F>
	class EnumFlags
	{
	public:
		using flag_type = F;    /**< Enum type used for flag bits */

	public:
		/**
		 * @brief Default constructor.
		 */
		EnumFlags();
		/**
		 * @brief Copy constructor.
		 *
		 * @param other Flags to copy
		 */
		EnumFlags(const EnumFlags & other);
		/**
		 * @brief Construct from single flag.
		 *
		 * @param flag  Single flag bit to set
		 */
		EnumFlags(flag_type flag);


		// Modification
		//

		/**
		 * @brief Set bits from flags register.
		 *
		 * @param flags     Flag bits to set
		 */
		void set(const EnumFlags & flags);
		/**
		 * @brief Clear flag bits.
		 *
		 * @param flags    Flag bits to clear
		 */
		void clear(const EnumFlags & flags);
		/**
		 * @brief Clear all flag bits.
		 */
		void clear();


		// Inspection
		//

		/**
		 * @brief Test if all flags are set.
		 *
		 * @param flags     Flag bits to check
		 * @return          True if all checked flag bits are set
		 */
		bool isSet(const EnumFlags & flags) const;

		/**
		 * @brief Test if any flag is set.
		 *
		 * @param flags     Flag bits to check
		 * @return          True if any checked flag bit is set
		 */
		bool isAnySet(const EnumFlags & flags) const;


		// Operator overloads
		//

		/**
		 * @brief Equal to operator.
		 *
		 * @param rhs   Flags to compare
		 * @return      True if flags are equal
		 */
		bool operator ==(const EnumFlags & rhs) const;
		/**
		 * @brief Not equal to operator.
		 *
		 * @param rhs   Flags to compare
		 * @return      True if flags are not equal
		 */
		bool operator !=(const EnumFlags & rhs) const;

		/**
		 * @brief Bitwise AND operator.
		 *
		 * @param rhs   Other flags
		 * @return      Result of bitwise AND
		 */
		EnumFlags operator &(const EnumFlags & rhs) const;
		/**
		 * @brief Bitwise OR operator.
		 *
		 * @param rhs   Other flags
		 * @return      Result of bitwise OR
		 */
		EnumFlags operator |(const EnumFlags & rhs) const;

		/**
		 * @brief Bitwise AND assignment operator.
		 *
		 * @param rhs   Other flags
		 * @return      Reference to this
		 */
		EnumFlags & operator &=(const EnumFlags & rhs);
		/**
		 * @brief Bitwise OR assignment operator.
		 *
		 * @param rhs   Other flags
		 * @return      Reference to this
		 */
		EnumFlags & operator |=(const EnumFlags & rhs);

		/**
		 * @brief Explicitly convert flags to uint32_t.
		 */
		explicit operator uint32_t();

	private:
		/**
		 * @brief Construct from uint32_t flags.
		 *
		 * @param flags Flags
		 */
		EnumFlags(uint32_t flags);

	private:
		uint32_t flags_;    /**< Flags register */
	};
} // namespace sta


/**
 * @brief Provide overload for operator | to combine enum values.
 *
 * @param enumType  Enum type to overload
 *
 * @ingroup staCore
 */
#define STA_ENUM_FLAGS_OVERLOAD(enumType) \
	sta::EnumFlags<enumType> operator |(enumType lhs, enumType rhs) \
	{ \
		return sta::EnumFlags<enumType>{lhs} | rhs; \
	}

/**
 * @brief Declare alias for sta::EnumFlags specialization.
 *
 * @param enumType  Enum type for specialization
 *
 * @ingroup staCore
 */
#define STA_ENUM_FLAGS_ALIAS(enumType) \
	using enumType ## Flags = sta::EnumFlags<enumType>

/**
 * @brief Declare enum and create sta::EnumFlags alias and overloads.
 *
 * @param enumType  Name of new enum class
 * @param value1    First enum value
 * @param ...       Enum values 2 - 32
 *
 * @ingroup staCore
 */
#define STA_ENUM_FLAGS_DECL(enumType, value1, ...) \
	enum class enumType \
	{ \
		value1, ##__VA_ARGS__ \
	}; \
	STA_ENUM_FLAGS_ALIAS(enumType); \
	STA_ENUM_FLAGS_OVERLOAD(enumType)


// Include template implementation
#include <sta/enum_flags.tpp>


#endif // STA_ENUM_FLAGS_HPP