| Revision | 1b9e82800e24bff5f615cd13cb1b246aa9d26807 (tree) |
|---|---|
| Time | 2021-01-20 11:43:57 |
| Author | Eric Hopper <hopper@omni...> |
| Commiter | Eric Hopper |
Completely rework flagset into being a factory for flagset types.
pubincludes/pppbase/flagset.h (diff)
tests/flagset.cpp (diff)| @@ -1,6 +1,7 @@ | ||
| 1 | 1 | #pragma once /*-*-c++-*-*/ |
| 2 | 2 | |
| 3 | 3 | #include <cstdint> |
| 4 | +#include <concepts> | |
| 4 | 5 | |
| 5 | 6 | // Copyright 2021 by Eric Hopper |
| 6 | 7 | // Can be distributed under the terms of the LGPL v3. |
| @@ -8,69 +9,122 @@ | ||
| 8 | 9 | namespace pppbase { |
| 9 | 10 | |
| 10 | 11 | //! A set of boolean flags, may not be modified after creation. |
| 11 | -class flagset { | |
| 12 | +class flagset_base { | |
| 13 | + protected: | |
| 14 | + using bitvec_t = ::std::uintmax_t; | |
| 15 | + | |
| 12 | 16 | public: |
| 13 | - explicit constexpr flagset(::std::uintmax_t bits = 0) | |
| 17 | + constexpr explicit flagset_base(bitvec_t bits = 0) | |
| 14 | 18 | : bits_{bits} |
| 15 | 19 | {} |
| 16 | 20 | |
| 17 | 21 | constexpr explicit operator bool() const { return bits_; } |
| 18 | 22 | |
| 19 | - constexpr | |
| 20 | - flagset intersection(flagset const &b) const { | |
| 21 | - return flagset{bits_ & b.bits_}; | |
| 23 | + [[nodiscard]] constexpr | |
| 24 | + flagset_base intersection(flagset_base const &b) const { | |
| 25 | + return flagset_base{bits_ & b.bits_}; | |
| 22 | 26 | } |
| 23 | - constexpr | |
| 24 | - flagset setunion(flagset const &b) const { | |
| 25 | - return flagset{bits_ | b.bits_}; | |
| 27 | + [[nodiscard]] constexpr | |
| 28 | + flagset_base setunion(flagset_base const &b) const { | |
| 29 | + return flagset_base{bits_ | b.bits_}; | |
| 26 | 30 | } |
| 27 | - constexpr | |
| 28 | - flagset symmetric_difference(flagset const &b) const { | |
| 29 | - return flagset{bits_ ^ b.bits_}; | |
| 31 | + [[nodiscard]] constexpr | |
| 32 | + flagset_base symmetric_difference(flagset_base const &b) const { | |
| 33 | + return flagset_base{bits_ ^ b.bits_}; | |
| 30 | 34 | } |
| 31 | - constexpr | |
| 32 | - flagset minus(flagset const &b) const { | |
| 33 | - return flagset{bits_ & ~b.bits_}; | |
| 35 | + [[nodiscard]] constexpr | |
| 36 | + flagset_base minus(flagset_base const &b) const { | |
| 37 | + return flagset_base{bits_ & ~b.bits_}; | |
| 34 | 38 | } |
| 35 | 39 | |
| 36 | - constexpr | |
| 37 | - bool is_equal(flagset const &b) const { | |
| 40 | + [[nodiscard]] constexpr | |
| 41 | + bool is_equal(flagset_base const &b) const { | |
| 38 | 42 | return bits_ == b.bits_; |
| 39 | 43 | } |
| 40 | 44 | |
| 45 | + [[nodiscard]] constexpr | |
| 46 | + bitvec_t getbits() const { return bits_; } | |
| 47 | + | |
| 41 | 48 | private: |
| 42 | - ::std::uintmax_t bits_; | |
| 49 | + bitvec_t bits_; | |
| 43 | 50 | }; |
| 44 | 51 | |
| 45 | -constexpr | |
| 46 | -bool operator ==(flagset const &a, flagset const &b) | |
| 52 | + | |
| 53 | +template <typename T> | |
| 54 | +concept supports_flagset = requires(T const &x) { | |
| 55 | + bool{x}; | |
| 56 | + {x.intersection(x)} -> ::std::same_as<T>; | |
| 57 | + {x.setunion(x)} -> ::std::same_as<T>; | |
| 58 | + {x.symmetric_difference(x)} -> ::std::same_as<T>; | |
| 59 | + {x.minus(x)} -> ::std::same_as<T>; | |
| 60 | + {x.is_equal(x)} -> ::std::same_as<bool>; | |
| 61 | +}; | |
| 62 | + | |
| 63 | + | |
| 64 | +template <typename Derived> | |
| 65 | +class specific_flagset_crtp : private flagset_base { | |
| 66 | + protected: | |
| 67 | + using flagset_base::bitvec_t; | |
| 68 | + using flagset_base::getbits; | |
| 69 | + constexpr explicit specific_flagset_crtp(bitvec_t bits=0) | |
| 70 | + : flagset_base(bits) { | |
| 71 | + } | |
| 72 | + | |
| 73 | + public: | |
| 74 | + using flagset_base::operator bool; | |
| 75 | + | |
| 76 | + [[nodiscard]] constexpr | |
| 77 | + Derived intersection(Derived const &b) const { | |
| 78 | + return Derived{flagset_base::intersection(b).getbits()}; | |
| 79 | + } | |
| 80 | + [[nodiscard]] constexpr | |
| 81 | + Derived setunion(Derived const &b) const { | |
| 82 | + return Derived{flagset_base::setunion(b).getbits()}; | |
| 83 | + } | |
| 84 | + [[nodiscard]] constexpr | |
| 85 | + Derived symmetric_difference(Derived const &b) const { | |
| 86 | + return Derived{flagset_base::symmetric_difference(b).getbits()}; | |
| 87 | + } | |
| 88 | + [[nodiscard]] constexpr | |
| 89 | + Derived minus(Derived const &b) const { | |
| 90 | + return Derived{flagset_base::minus(b).getbits()}; | |
| 91 | + } | |
| 92 | + | |
| 93 | + [[nodiscard]] constexpr | |
| 94 | + bool is_equal(Derived const &b) const { | |
| 95 | + return flagset_base::is_equal(b); | |
| 96 | + } | |
| 97 | +}; | |
| 98 | + | |
| 99 | +template <supports_flagset T> constexpr | |
| 100 | +bool operator ==(T const &a, T const &b) | |
| 47 | 101 | { |
| 48 | 102 | return a.is_equal(b); |
| 49 | 103 | } |
| 50 | 104 | |
| 51 | -constexpr | |
| 52 | -bool operator !=(flagset const &a, flagset const &b) | |
| 105 | +template <supports_flagset T> constexpr | |
| 106 | +bool operator !=(T const &a, T const &b) | |
| 53 | 107 | { |
| 54 | 108 | return !a.is_equal(b); |
| 55 | 109 | } |
| 56 | 110 | |
| 57 | -constexpr | |
| 58 | -flagset operator &(flagset const &a, flagset const &b) { | |
| 111 | +template <supports_flagset T> constexpr | |
| 112 | +T operator &(T const &a, T const &b) { | |
| 59 | 113 | return a.intersection(b); |
| 60 | 114 | } |
| 61 | 115 | |
| 62 | -constexpr | |
| 63 | -flagset operator |(flagset const &a, flagset const &b) { | |
| 116 | +template <supports_flagset T> constexpr | |
| 117 | +T operator |(T const &a, T const &b) { | |
| 64 | 118 | return a.setunion(b); |
| 65 | 119 | } |
| 66 | 120 | |
| 67 | -constexpr | |
| 68 | -flagset operator ^(flagset const &a, flagset const &b) { | |
| 121 | +template <supports_flagset T> constexpr | |
| 122 | +T operator ^(T const &a, T const &b) { | |
| 69 | 123 | return a.symmetric_difference(b); |
| 70 | 124 | } |
| 71 | 125 | |
| 72 | -constexpr | |
| 73 | -flagset operator -(flagset const &a, flagset const &b) { | |
| 126 | +template <supports_flagset T> constexpr | |
| 127 | +T operator -(T const &a, T const &b) { | |
| 74 | 128 | return a.minus(b); |
| 75 | 129 | } |
| 76 | 130 |
| @@ -1,15 +1,25 @@ | ||
| 1 | 1 | #include <pppbase/flagset.h> |
| 2 | 2 | #include <catch2/catch.hpp> |
| 3 | 3 | |
| 4 | +class test_flagset : public ::pppbase::specific_flagset_crtp<test_flagset> { | |
| 5 | + using base_t = ::pppbase::specific_flagset_crtp<test_flagset>; | |
| 6 | + public: | |
| 7 | + using bitvec_t = base_t::bitvec_t; | |
| 8 | + constexpr explicit test_flagset(bitvec_t bits = 0) : base_t(bits) {} | |
| 9 | + | |
| 10 | + using base_t::getbits; | |
| 11 | +}; | |
| 12 | + | |
| 13 | + | |
| 4 | 14 | SCENARIO("flagsets support all required operations correctly") |
| 5 | 15 | { |
| 6 | 16 | GIVEN("A three carefully chosen flagsets.") |
| 7 | 17 | { |
| 8 | - using ::pppbase::flagset; | |
| 9 | - flagset f0; | |
| 10 | - flagset f1{1}; | |
| 11 | - flagset f2{2}; | |
| 12 | - flagset f3{3}; | |
| 18 | + using ::pppbase::flagset_base; | |
| 19 | + test_flagset f0; | |
| 20 | + test_flagset f1{1}; | |
| 21 | + test_flagset f2{2}; | |
| 22 | + test_flagset f3{3}; | |
| 13 | 23 | |
| 14 | 24 | WHEN("Each is tested for truth") { |
| 15 | 25 | THEN("f0 is false") { |
Fork