Refactor FeatureBitset:

* Remove composite helper functions
* Add set difference and Bitset/uint256 operators
* Convert tests to use new feature bitset set difference operator

src/ripple/protocol/Feature.h

@@ -107,16 +107,218 @@ supportedAmendments ();
 boost::optional<uint256>
 getRegisteredFeature (std::string const& name);
 
-using FeatureBitset = std::bitset<detail::FeatureCollections::numFeatures()>;
-
 size_t
 featureToBitsetIndex(uint256 const& f);
 
 uint256
 bitsetIndexToFeature(size_t i);
 
-bool
-hasFeature (uint256 const& feat, FeatureBitset features);
+class FeatureBitset
+    : private std::bitset<detail::FeatureCollections::numFeatures()>
+{
+    using base = std::bitset<detail::FeatureCollections::numFeatures()>;
+
+    void initFromFeatures()
+    {
+    }
+
+    template<class... Fs>
+    void initFromFeatures(uint256 const& f, Fs&&... fs)
+    {
+        set(f);
+        initFromFeatures(std::forward<Fs>(fs)...);
+    }
+
+public:
+    using base::bitset;
+    using base::operator==;
+    using base::operator!=;
+ 
+    using base::test;
+    using base::all;
+    using base::any;
+    using base::none;
+    using base::count;
+    using base::size;
+    using base::set;
+    using base::reset;
+    using base::flip;
+    using base::operator[];
+    using base::to_string;
+    using base::to_ulong;
+    using base::to_ullong;
+
+    FeatureBitset() = default;
+
+    explicit
+    FeatureBitset(base const& b)
+        : base(b)
+    {
+    }
+
+    template<class... Fs>
+    explicit
+    FeatureBitset(uint256 const& f, Fs&&... fs)
+    {
+        initFromFeatures(f, std::forward<Fs>(fs)...);
+    }
+
+    template <class Col>
+    explicit
+    FeatureBitset(Col const& fs)
+    {
+        for (auto const& f : fs)
+            set(featureToBitsetIndex(f));
+    }
+
+    auto operator[](uint256 const& f)
+    {
+        return base::operator[](featureToBitsetIndex(f));
+    }
+
+    auto operator[](uint256 const& f) const
+    {
+        return base::operator[](featureToBitsetIndex(f));
+    }
+
+    FeatureBitset&
+    set(uint256 const& f, bool value = true)
+    {
+        base::set(featureToBitsetIndex(f), value);
+        return *this;
+    }
+
+    FeatureBitset&
+    reset(uint256 const& f)
+    {
+        base::reset(featureToBitsetIndex(f));
+        return *this;
+    }
+
+    FeatureBitset&
+    flip(uint256 const& f)
+    {
+        base::flip(featureToBitsetIndex(f));
+        return *this;
+    }
+
+    FeatureBitset& operator&=(FeatureBitset const& rhs)
+    {
+        base::operator&=(rhs);
+        return *this;
+    }
+
+    FeatureBitset& operator|=(FeatureBitset const& rhs)
+    {
+        base::operator|=(rhs);
+        return *this;
+    }
+
+    FeatureBitset operator~() const
+    {
+        return FeatureBitset{base::operator~()};
+    }
+
+    friend
+    FeatureBitset operator&(
+        FeatureBitset const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{static_cast<base const&>(lhs) &
+                             static_cast<base const&>(rhs)};
+    }
+
+    friend
+    FeatureBitset operator&(
+        FeatureBitset const& lhs,
+        uint256 const& rhs)
+    {
+        return lhs & FeatureBitset{rhs};
+    }
+
+    friend
+    FeatureBitset operator&(
+        uint256 const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{lhs} & rhs;
+    }
+
+    friend
+    FeatureBitset operator|(
+        FeatureBitset const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{static_cast<base const&>(lhs) |
+                             static_cast<base const&>(rhs)};
+    }
+
+    friend
+    FeatureBitset operator|(
+        FeatureBitset const& lhs,
+        uint256 const& rhs)
+    {
+        return lhs | FeatureBitset{rhs};
+    }
+
+    friend
+    FeatureBitset operator|(
+        uint256 const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{lhs} | rhs;
+    }
+
+    friend
+    FeatureBitset operator^(
+        FeatureBitset const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{static_cast<base const&>(lhs) ^
+                             static_cast<base const&>(rhs)};
+    }
+
+    friend
+    FeatureBitset operator^(
+        FeatureBitset const& lhs,
+        uint256 const& rhs)
+    {
+        return lhs ^ FeatureBitset{rhs};
+    }
+
+    friend
+    FeatureBitset operator^(
+        uint256 const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{lhs} ^ rhs;
+    }
+
+    // set difference
+    friend
+    FeatureBitset operator-(
+        FeatureBitset const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return lhs & ~rhs;
+    }
+
+    friend
+    FeatureBitset operator-(
+        FeatureBitset const& lhs,
+        uint256 const& rhs)
+    {
+        return lhs - FeatureBitset{rhs};
+    }
+
+    friend
+    FeatureBitset operator-(
+        uint256 const& lhs,
+        FeatureBitset const& rhs)
+    {
+        return FeatureBitset{lhs} - rhs;
+    }
+};
 
 template <class F>
 void
@@ -127,34 +329,6 @@ foreachFeature(FeatureBitset bs, F&& f)
             f(bitsetIndexToFeature(i));
 }
 
-template <class Col>
-FeatureBitset
-makeFeatureBitset(Col&& fs)
-{
-    FeatureBitset result;
-    for (auto const& f : fs)
-        result.set(featureToBitsetIndex(f));
-    return result;
-}
-
-template <class Col>
-FeatureBitset
-addFeatures(FeatureBitset bs, Col&& fs)
-{
-    for (auto const& f : fs)
-        bs.set(featureToBitsetIndex(f));
-    return bs;
-}
-
-template <class Col>
-FeatureBitset
-removeFeatures(FeatureBitset bs, Col&& fs)
-{
-    for (auto const& f : fs)
-        bs.reset(featureToBitsetIndex(f));
-    return bs;
-}
-
 extern uint256 const featureMultiSign;
 extern uint256 const featureTickets;
 extern uint256 const featureTrustSetAuth;