more tests + bug fixes

Author: grisumbras

include/flags/flags.hpp

@@ -97,9 +97,17 @@ template <class E> struct flags {
 
   constexpr bool operator!() const noexcept { return !val_; }
 
-  flags operator~() const noexcept { return flags(~val_); }
+  friend constexpr bool operator==(flags fl1, flags fl2) {
+    return fl1.val_ == fl2.val_;
+  }
+
+  friend constexpr bool operator!=(flags fl1, flags fl2) {
+    return fl1.val_ != fl2.val_;
+  }
 
 
+  constexpr flags operator~() const noexcept { return flags(~val_); }
+
   flags &operator|=(const flags &fl) noexcept {
     val_ |= fl.val_;
     return *this;
@@ -131,6 +139,18 @@ template <class E> struct flags {
     return *this;
   }
 
+  friend constexpr flags operator|(flags f1, flags f2) noexcept {
+    return flags{f1.val_ | f2.val_};
+  }
+
+  friend constexpr flags operator&(flags f1, flags f2) noexcept {
+    return flags{f1.val_ & f2.val_};
+  }
+
+  friend  constexpr flags operator^(flags f1, flags f2) noexcept {
+    return flags{f1.val_ ^ f2.val_};
+  }
+
 
   void swap(flags &fl) noexcept { std::swap(val_, fl.val_); }
 
@@ -153,7 +173,7 @@ template <class E> struct flags {
   }
 
 
-  bool empty() const noexcept { return !val_; }
+  constexpr bool empty() const noexcept { return !val_; }
 
   size_type size() const noexcept {
     return std::distance(this->begin(), this->end());
@@ -165,13 +185,13 @@ template <class E> struct flags {
   iterator begin() const noexcept { return cbegin(); }
   iterator cbegin() const noexcept { return iterator{val_}; }
 
-  iterator end() const noexcept { return cend(); }
-  iterator cend() const noexcept { return {}; }
+  constexpr iterator end() const noexcept { return cend(); }
+  constexpr iterator cend() const noexcept { return {}; }
 
 
-  iterator find(enum_type e) const noexcept { return {val_, e}; }
+  constexpr iterator find(enum_type e) const noexcept { return {val_, e}; }
 
-  size_type count(enum_type e) const noexcept {
+  constexpr size_type count(enum_type e) const noexcept {
     return find(e) != end() ? 1 : 0;
   }
 
@@ -256,67 +276,7 @@ template <class E> struct flags {
 
 
 template <class E>
-constexpr flags<E> operator|(flags<E> f1, flags<E> f2) noexcept {
-    return f1 |= f2;
-}
-
-template <class E>
-constexpr flags<E> operator|(flags<E> f, E e) noexcept {
-    return f |= e;
-}
-
-template <class E>
-constexpr flags<E> operator|(E e, flags<E> f) noexcept {
-    return f |= e;
-}
-
-
-template <class E>
-constexpr flags<E> operator&(flags<E> f1, flags<E> f2) noexcept {
-    return f1 &= f2;
-}
-
-template <class E>
-constexpr flags<E> operator&(flags<E> f, E e) noexcept {
-    return f &= e;
-}
-
-template <class E>
-constexpr flags<E> operator&(E e, flags<E> f) noexcept {;
-    return f &= e;
-}
-
-
-template <class E>
-constexpr flags<E> operator^(flags<E> f1, flags<E> f2) noexcept {
-    return f1 ^= f2;
-}
-
-template <class E>
-constexpr flags<E> operator^(flags<E> f, E e) noexcept {
-    return f ^= e;
-}
-
-template <class E>
-constexpr flags<E> operator^(E e, flags<E> f) noexcept {
-  return f ^= e;
-}
-
-
-template <class E>
-constexpr bool operator==(const flags<E> &fl1, const flags<E> &fl2) noexcept {
-  return fl1.underlying_value() == fl2.underlying_value();
-}
-
-
-template <class E>
-constexpr bool operator!=(const flags<E> &fl1, const flags<E> &fl2) noexcept {
-  return fl1.underlying_value() != fl2.underlying_value();
-}
-
-
-template <class E>
-constexpr void swap(flags<E> &fl1, flags<E> &fl2) noexcept { fl1.swap(fl2); }
+void swap(flags<E> &fl1, flags<E> &fl2) noexcept { fl1.swap(fl2); }
 
 
 } // namespace flags
@@ -326,23 +286,23 @@ template <class E>
 constexpr auto operator|(E e1, E e2) noexcept
 -> typename std::enable_if<flags::is_flags<E>::value,
                            flags::flags<E>>::type {
-  return flags::flags<E>{e1} |= e2;
+  return flags::flags<E>(e1) | e2;
 }
 
 
 template <class E>
 constexpr auto operator&(E e1, E e2) noexcept
 -> typename std::enable_if<flags::is_flags<E>::value,
                            flags::flags<E>>::type {
-  return flags::flags<E>{e1} &= e2;
+  return flags::flags<E>(e1) & e2;
 }
 
 
 template <class E>
 constexpr auto operator^(E e1, E e2) noexcept
 -> typename std::enable_if<flags::is_flags<E>::value,
                            flags::flags<E>>::type {
-  return flags::flags<E>{e1} ^= e2;
+  return flags::flags<E>(e1) ^ e2;
 }
 
 

include/flags/iterator.hpp

@@ -60,7 +60,7 @@ class FlagsIterator {
   using impl_type = typename flags_type::impl_type;
 
 
-  explicit FlagsIterator(impl_type uv) noexcept : mask_(1), uvalue_(uv) {
+  explicit FlagsIterator(impl_type uv) noexcept : uvalue_(uv), mask_(1) {
     if (!(mask_ & uvalue_)) { nextMask(); }
   }
 

test/Jamroot

@@ -1,5 +1,6 @@
 import testing ;
 
+
 project flags_tests
   : requirements <warnings>all
                  <cxxflags>-std=c++11
@@ -18,4 +19,12 @@ unit-test main-test
   : main-test.cpp boost_utf
   : <define>BOOST_TEST_DYN_LINK
     <define>BOOST_TEST_MODULE=enum_flags
-  ;
+  ;
+
+
+compile should-compile.cpp ;
+
+
+for src in [ glob shouldnt-compile/*.cpp ] {
+  compile-fail $(src) ;
+}

test/common.hpp

@@ -0,0 +1,14 @@
+#ifndef ENUM_CLASS_TEST_COMMON_HPP
+#define ENUM_CLASS_TEST_COMMON_HPP
+
+
+#include <flags/flags.hpp>
+
+
+enum class Enum : int {One = 1, Two = 2, Four = 4, Eight = 8};
+ALLOW_FLAGS_FOR_ENUM(Enum)
+
+using Enums = flags::flags<Enum>;
+
+
+#endif // ENUM_CLASS_TEST_COMMON_HPP

test/main-test.cpp

@@ -1,16 +1,10 @@
-#include <flags/flags.hpp>
+#include "common.hpp"
 
 #include <vector>
 
 #include <boost/test/unit_test.hpp>
 
 
-enum class Enum : int {One = 1, Two = 2, Four = 4, Eight = 8};
-ALLOW_FLAGS_FOR_ENUM(Enum)
-
-using Enums = flags::flags<Enum>;
-
-
 BOOST_AUTO_TEST_CASE(set_underlying_value) {
   Enums result;
   constexpr int random_number = 87;

test/should-compile.cpp

@@ -0,0 +1,147 @@
+#include "common.hpp"
+
+
+// type traits
+static_assert(std::is_pod<Enums>::value,
+              "Enums is not POD!");
+static_assert(std::is_literal_type<Enums>::value,
+              "Enums is not a literal type!");
+
+
+// associated types
+
+// general
+static_assert(std::is_same<Enums::enum_type, Enum>::value,
+              "Enums::enum_type is not Enum!");
+static_assert(std::is_same<std::underlying_type<Enum>::type,
+                           Enums::underlying_type>::value,
+              "Enums::underlying_type is different from "
+              "underlying type of Enum!");
+static_assert(std::is_same<std::make_unsigned<Enums::underlying_type>::type,
+                           Enums::impl_type>::value,
+              "Enums::impl_type is not unsigned version of "
+              "Enums::underlying_type!");
+
+// iterator
+using Iterator = Enums::iterator;
+
+static_assert(std::is_literal_type<Iterator>::value,
+              "Enums::iterator is not a literal type!");
+static_assert(std::is_same<Enums::const_iterator, Iterator>::value,
+              "Enums::const_iterator and Enums::iterator are different types!");
+static_assert(std::is_same<Iterator::flags_type, Enums>::value,
+              "Enums::iterator::flags_type is not Enums!");
+static_assert(std::is_same<Iterator::iterator_category,
+                           std::forward_iterator_tag>::value,
+              "Enums::iterator category is not forward iterator!");
+static_assert(std::is_same<Iterator::value_type, Enum>::value,
+              "Enums::iterator::value_type is not Enum!");
+static_assert(std::is_same<Iterator::reference, const Enum>::value,
+              "Enums::iterator::reference is not const Enum!");
+// (const) forward iterator requirements
+static_assert(std::is_copy_constructible<Iterator>::value
+              && std::is_copy_assignable<Iterator>::value
+              && std::is_destructible<Iterator>::value
+//               && std::is_same<decltype(*std::declval<Iterator &>()),
+//                               Iterator::reference>::value
+              && std::is_same<decltype(++std::declval<Iterator &>()),
+                              Iterator &>::value,
+              "Enums::iterator does not model Iterator!");
+static_assert(std::is_convertible<
+                decltype(std::declval<Iterator>() == std::declval<Iterator>()),
+                bool>::value,
+              "Enums::iterator does not model EqualityComparable!");
+static_assert(std::is_convertible<
+                decltype(std::declval<Iterator>() != std::declval<Iterator>()),
+                bool>::value
+              && std::is_convertible<decltype(*std::declval<Iterator &>()),
+                                     Iterator::value_type>::value
+              && std::is_convertible<decltype(*std::declval<Iterator &>()++),
+                                     Iterator::value_type>::value,
+              "Enums::iterator does not model InputIterator!");
+static_assert(std::is_default_constructible<Iterator>::value
+              && std::is_convertible<decltype(++std::declval<Iterator &>()),
+                                     Iterator>::value
+              && std::is_convertible<decltype(std::declval<Iterator &>()++),
+                                     Iterator>::value,
+              "Enums::iterator does not model ForwardIterator!");
+
+// container
+static_assert(std::is_same<Enums::iterator::value_type,
+                           Enums::value_type>::value,
+              "Enums::value_type is not Enums::iterator::value_type!");
+
+static_assert(std::is_same<Enums::iterator::reference, Enums::reference>::value,
+              "Enums::reference is not Enums::iterator::reference!");
+static_assert(std::is_same<Enums::const_reference, Enums::reference>::value,
+              "Enums::const_reference is not Enums::reference!");
+
+static_assert(std::is_same<Enums::iterator::pointer, Enums::pointer>::value,
+              "Enums::pointer is not Enums::iterator::pointer!");
+static_assert(std::is_same<Enums::enum_type *, Enums::pointer>::value,
+              "Enums::pointer is not Enum *!");
+static_assert(std::is_same<const Enums::enum_type *,
+                           Enums::const_pointer>::value,
+              "Enums::const_pointer is not const Enum *!");
+
+static_assert(std::is_arithmetic<Enums::size_type>::value,
+              "Enums::size_type is not arithmetic!");
+
+static_assert(std::is_same<Enums::iterator::difference_type,
+                           Enums::difference_type>::value,
+              "Enums::difference_type is not Enums::iterator::difference_type!"
+             );
+static_assert(std::is_signed<Enums::difference_type>::value,
+              "Enums::difference_type is not signed!");
+
+
+// constexpr construction
+constexpr Enums ec1(flags::empty);
+constexpr Enums ec2{flags::empty};
+constexpr Enums vc1(Enum::One);
+constexpr auto vc2 = Enums(Enum::One);
+
+
+// constexpr logical operators
+constexpr bool l1 = static_cast<bool>(ec1);
+constexpr bool l2 = !ec1;
+constexpr bool l3 = ec1 == ec2;
+constexpr bool l4 = ec1 != ec2;
+
+
+// constexpr bitwise operators
+constexpr auto b1 = ~ec1;
+
+constexpr auto b2 = ec1 | ec2;
+constexpr auto b3 = ec1 | Enum::One;
+constexpr auto b4 = Enum::One | ec1;
+constexpr auto b5 = Enum::One | Enum::Two;
+
+constexpr auto b6 = ec1 & ec2;
+constexpr auto b7 = ec1 & Enum::One;
+constexpr auto b8 = Enum::One & ec1;
+constexpr auto b9 = Enum::One & Enum::Two;
+
+constexpr auto b10 = ec1 ^ ec2;
+constexpr auto b11 = ec1 & Enum::One;
+constexpr auto b12 = Enum::One ^ ec1;
+constexpr auto b13 = Enum::One ^ Enum::Two;
+
+
+// constexpr conversions
+constexpr auto cv1 = ec1.underlying_value();
+static_assert(std::is_same<decltype(ec1.underlying_value()),
+                           Enums::underlying_type>::value,
+              "Enums::underlying_value() did not return an object of type "
+              "Enums::underlying_type!");
+constexpr auto cv2 = ec1.to_bitset();
+constexpr auto cv3 = static_cast<std::bitset<Enums::bit_size()>>(ec1);
+static_assert(std::is_same<decltype(cv2), decltype(cv3)>::value,
+              "Bitset conversion functions return different types!");
+
+
+// constexpr container functions
+constexpr bool cf1 = ec1.empty();
+constexpr Enums::size_type cf2 = ec1.max_size();
+constexpr Enums::iterator cf3 = ec1.find(Enum::One);
+constexpr Enums::size_type cf4 = ec1.count(Enum::One);

test/shouldnt-compile/allow-accidental.cpp

@@ -0,0 +1,9 @@
+#include "common.hpp"
+
+
+enum class AnotherEnum { One = 1, Two = 2 };
+
+
+void check() {
+  auto aes = AnotherEnum::One | AnotherEnum::Two;
+}