Fix indentation. Update doxygen comments

include/sta/enum_flags.hpp

@@ -10,143 +10,143 @@
 
 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 */
+    /**
+     * @brief 32-bit flag register with enum type representing single flag bits.
+     *
+     * @tparam F    Enum type used for flag bits
+     *
+     * @ingroup sta_core
+     */
+    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);
+    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
-		//
+        // 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();
+        /**
+         * @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
-		//
+        // 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 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;
+        /**
+         * @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
-		//
+        // 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 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 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 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();
+        /**
+         * @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:
+        /**
+         * @brief Construct from uint32_t flags.
+         *
+         * @param flags Flags
+         */
+        EnumFlags(uint32_t flags);
 
-	private:
-		uint32_t flags_;    /**< Flags register */
-	};
+    private:
+        uint32_t flags_;    /**< Flags register */
+    };
 } // namespace sta
 
 
@@ -155,23 +155,23 @@ namespace sta
  *
  * @param enumType  Enum type to overload
  *
- * @ingroup staCore
+ * @ingroup sta_core
  */
 #define STA_ENUM_FLAGS_OVERLOAD(enumType) \
-	sta::EnumFlags<enumType> operator |(enumType lhs, enumType rhs) \
-	{ \
-		return sta::EnumFlags<enumType>{lhs} | rhs; \
-	}
+    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
+ * @ingroup sta_core
  */
 #define STA_ENUM_FLAGS_ALIAS(enumType) \
-	using enumType ## Flags = sta::EnumFlags<enumType>
+    using enumType ## Flags = sta::EnumFlags<enumType>
 
 /**
  * @brief Declare enum and create sta::EnumFlags alias and overloads.
@@ -180,15 +180,15 @@ namespace sta
  * @param value1    First enum value
  * @param ...       Enum values 2 - 32
  *
- * @ingroup staCore
+ * @ingroup sta_core
  */
 #define STA_ENUM_FLAGS_DECL(enumType, value1, ...) \
-	enum class enumType \
-	{ \
-		value1, ##__VA_ARGS__ \
-	}; \
-	STA_ENUM_FLAGS_ALIAS(enumType); \
-	STA_ENUM_FLAGS_OVERLOAD(enumType)
+    enum class enumType \
+    { \
+        value1, ##__VA_ARGS__ \
+    }; \
+    STA_ENUM_FLAGS_ALIAS(enumType); \
+    STA_ENUM_FLAGS_OVERLOAD(enumType)
 
 
 // Include template implementation