update flag library file

Author: therocode

tests/common.hpp

@@ -3,19 +3,16 @@
 #include <probe/probe.hpp>
 #include <flg/flags.hpp>
 
-namespace semantics_flags
+struct semantics_flags: flg::flags<int, semantics_flags>
 {
-    struct semantics_flags_tag{};
-    using type = flg::flag<int, semantics_flags_tag>::type;
-
-    constexpr type None        = type::none_flag();
-    constexpr type NoConstruct = type::from_index(0);
-    constexpr type NoCopy      = type::from_index(1);
-    constexpr type NoMove      = type::from_index(2);
+    constexpr static flag None        = none_flag();
+    constexpr static flag NoConstruct = from_index(0);
+    constexpr static flag NoCopy      = from_index(1);
+    constexpr static flag NoMove      = from_index(2);
 };
 
 template <typename probe, typename functor>
-void verify_semantics(semantics_flags::type flags, functor f)
+void verify_semantics(semantics_flags flags, functor f)
 {
     probe::reset_counts();
 

tests/lib/flg/flags.hpp

@@ -3,68 +3,98 @@
 
 namespace flg
 {
-template <typename numeric_type, typename tag>
-struct flag
-{
-
-struct type
+template <typename numeric_type, typename user_type>
+struct flags
 {
     using value_type = numeric_type;
 
-    explicit operator value_type() const { return value; }
-    operator bool() const { return value; }
+    explicit constexpr operator value_type() const { return value; }
+    constexpr operator bool() const { return value; }
 
-    type operator~() const
+    constexpr flags operator~() const
     {
-        return type{~value};
+        return flags{~value};
     }
-    type operator&(type other) const
+    constexpr flags operator&(flags other) const
     {
-        return type{value & other.value};
+        return flags{value & other.value};
     }
-    type operator|(type other) const
+    constexpr flags operator|(flags other) const
     {
-        return type{value | other.value};
+        return flags{value | other.value};
     }
-    type operator^(type other) const
+    constexpr flags operator^(flags other) const
     {
-        return type{value ^ other.value};
+        return flags{value ^ other.value};
     }
-    type& operator&=(type other)
+    constexpr flags& operator&=(flags other)
     {
         value &= other.value;
         return *this;
     }
-    type& operator|=(type other)
+    constexpr flags& operator|=(flags other)
     {
         value |= other.value;
         return *this;
     }
-    type& operator^=(type other)
+    constexpr flags& operator^=(flags other)
     {
         value ^= other.value;
         return *this;
     }
-    bool operator==(type other) const
+    constexpr bool operator==(flags other) const
     {
         return value == other.value;
     }
-    bool operator!=(type other) const
+    constexpr bool operator!=(flags other) const
     {
         return value != other.value;
     }
 
     value_type value;
 
-    constexpr static type none_flag()
+    struct flag
+    {
+        value_type value;
+
+        constexpr operator user_type() const
+        {
+            return user_type{value};
+        }
+        constexpr user_type operator~() const
+        {
+            return user_type{~value};
+        }
+        constexpr user_type operator&(flag other) const
+        {
+            return user_type{value & other.value};
+        }
+        constexpr user_type operator|(flag other) const
+        {
+            return user_type{value | other.value};
+        }
+        constexpr user_type operator^(flag other) const
+        {
+            return user_type{value ^ other.value};
+        }
+        constexpr bool operator==(flag other) const
+        {
+            return value == other.value;
+        }
+        constexpr bool operator!=(flag other) const
+        {
+            return value != other.value;
+        }
+    };
+
+    constexpr static flag none_flag()
     {
        return  {0};
     }
-    
-    constexpr static type from_index(value_type v)
+
+    constexpr static flag from_index(value_type v)
     {
         return {1 << v};
     }
 };
-};
 }