Add more IntSet methods:

- add_range
- is_subset_of
- min/max
- union, intersect, subtract, sym diff.

Author: garretrieger

common/int_set.h

@@ -1,6 +1,8 @@
 #ifndef COMMON_INT_SET
 #define COMMON_INT_SET
 
+#include <optional>
+
 #include "common/hb_set_unique_ptr.h"
 namespace common {
 
@@ -78,14 +80,14 @@ class IntSet {
   }
 
   IntSet(const hb_set_t* set) : set_(make_hb_set()) {
-    // We always keep exclusive ownership of the internal set, so copy the contents
-    // of the input set instead of referencing it.
+    // We always keep exclusive ownership of the internal set, so copy the
+    // contents of the input set instead of referencing it.
     hb_set_union(set_.get(), set);
   }
 
   IntSet(const hb_set_unique_ptr& set) : set_(make_hb_set()) {
-    // We always keep exclusive ownership of the internal set, so copy the contents
-    // of the input set instead of referencing it.
+    // We always keep exclusive ownership of the internal set, so copy the
+    // contents of the input set instead of referencing it.
     hb_set_union(set_.get(), set.get());
   }
 
@@ -147,8 +149,6 @@ class IntSet {
     return H::combine(std::move(h), harfbuzz_hash);
   }
 
-  // TODO(garretrieger): add union, intersection etc.
-
   iterator begin() { return iterator(set_.get()); }
 
   iterator end() { return iterator(); }
@@ -169,25 +169,72 @@ class IntSet {
 
   void add(hb_codepoint_t codepoint) { hb_set_add(set_.get(), codepoint); }
 
+  void add_range(hb_codepoint_t start, hb_codepoint_t end) {
+    hb_set_add_range(set_.get(), start, end);
+  }
+
   bool contains(hb_codepoint_t codepoint) const {
     return hb_set_has(set_.get(), codepoint);
   }
 
+  bool is_subset_of(const IntSet& other) const {
+    return hb_set_is_subset(set_.get(), other.set_.get());
+  }
+
+  std::optional<hb_codepoint_t> min() const {
+    hb_codepoint_t value = hb_set_get_min(set_.get());
+    if (value == HB_SET_VALUE_INVALID) {
+      return std::nullopt;
+    }
+    return value;
+  }
+
+  std::optional<hb_codepoint_t> max() const {
+    hb_codepoint_t value = hb_set_get_max(set_.get());
+    if (value == HB_SET_VALUE_INVALID) {
+      return std::nullopt;
+    }
+    return value;
+  }
+
   void erase(hb_codepoint_t codepoint) { hb_set_del(set_.get(), codepoint); }
 
   size_t size() const { return hb_set_get_population(set_.get()); }
 
   bool empty() const { return hb_set_is_empty(set_.get()); }
 
-  // Remove all elements
+  // Removes all elements
   void clear() { hb_set_clear(set_.get()); }
 
+  // Compute the union of this and other, store the result in this set.
+  void union_set(const IntSet& other) {
+    hb_set_union(set_.get(), other.set_.get());
+  }
+
+  // Compute the intersection of this and other, store the result in this set.
+  void intersect(const IntSet& other) {
+    hb_set_intersect(set_.get(), other.set_.get());
+  }
+
+  // Subtract other from this set.
+  void subtract(const IntSet& other) {
+    hb_set_subtract(set_.get(), other.set_.get());
+  }
+
+  // Compute the symmetric difference of this and other, store the result in
+  // this set.
+  void symmetric_difference(const IntSet& other) {
+    hb_set_symmetric_difference(set_.get(), other.set_.get());
+  }
+
  private:
   // Note: set_ must always point to a valid set object. nullptr is not allowed.
-  // Note: we always retain exclusive ownership over set_. Normally hb_set_t* can be
-  //       shared (via hb_set_reference()), but for this container we don't ever expose
-  //       the underlying hb_set_t* pointer so that we know we're always the only owner.
-  //       This prevents the sets contents from being changed outside of this class.
+  // Note: we always retain exclusive ownership over set_. Normally hb_set_t*
+  // can be
+  //       shared (via hb_set_reference()), but for this container we don't ever
+  //       expose the underlying hb_set_t* pointer so that we know we're always
+  //       the only owner. This prevents the sets contents from being changed
+  //       outside of this class.
   hb_set_unique_ptr set_;
 };
 

common/int_set_test.cc

@@ -1,8 +1,10 @@
 #include "common/int_set.h"
 
+#include <optional>
+
+#include "absl/hash/hash_testing.h"
 #include "common/hb_set_unique_ptr.h"
 #include "gtest/gtest.h"
-#include "absl/hash/hash_testing.h"
 
 namespace common {
 
@@ -126,7 +128,7 @@ TEST_F(IntSetTest, CopyHbSet) {
   // Make sure chaing hb_set doesn't cause changes in the IntSet's
   hb_set_add(hb_set.get(), 49);
 
-  IntSet expected {13, 47};
+  IntSet expected{13, 47};
 
   ASSERT_EQ(a, expected);
   ASSERT_EQ(b, expected);
@@ -219,13 +221,95 @@ TEST_F(IntSetTest, UseInHashSet) {
 
 TEST_F(IntSetTest, SupportsAbslHash) {
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
-      IntSet {},
-      IntSet {7, 8},
-      IntSet {7, 8, 11},
-      IntSet {7, 8, 12},
-      IntSet {8, 11},
-      IntSet {7, 8, 12},
+      IntSet{},
+      IntSet{7, 8},
+      IntSet{7, 8, 11},
+      IntSet{7, 8, 12},
+      IntSet{8, 11},
+      IntSet{7, 8, 12},
   }));
 }
 
+TEST_F(IntSetTest, MinMax) {
+  IntSet empty{};
+  IntSet a{8};
+  IntSet b{7, 8, 11};
+
+  ASSERT_EQ(empty.min(), std::nullopt);
+  ASSERT_EQ(empty.max(), std::nullopt);
+
+  ASSERT_EQ(*a.min(), 8);
+  ASSERT_EQ(*a.max(), 8);
+
+  ASSERT_EQ(*b.min(), 7);
+  ASSERT_EQ(*b.max(), 11);
+}
+
+TEST_F(IntSetTest, AddRange) {
+  IntSet a{7, 8, 11};
+
+  a.add_range(10, 15);
+  IntSet expected{7, 8, 10, 11, 12, 13, 14, 15};
+
+  ASSERT_EQ(a, expected);
+}
+
+TEST_F(IntSetTest, IsSubsetOf) {
+  IntSet empty;
+  IntSet a{7, 8};
+  IntSet b{7, 8, 11};
+
+  ASSERT_TRUE(empty.is_subset_of(a));
+  ASSERT_TRUE(empty.is_subset_of(b));
+
+  ASSERT_FALSE(a.is_subset_of(empty));
+  ASSERT_FALSE(b.is_subset_of(empty));
+
+  ASSERT_TRUE(a.is_subset_of(b));
+  ASSERT_FALSE(b.is_subset_of(a));
+
+  ASSERT_TRUE(a.is_subset_of(a));
+  ASSERT_TRUE(b.is_subset_of(b));
+}
+
+TEST_F(IntSetTest, Union) {
+  IntSet a{5, 8};
+  IntSet b{8, 11};
+  IntSet expected{5, 8, 11};
+
+  a.union_set(b);
+
+  ASSERT_EQ(a, expected);
+}
+
+TEST_F(IntSetTest, Intersect) {
+  IntSet a{5, 8};
+  IntSet b{8, 11};
+  IntSet expected{8};
+
+  a.intersect(b);
+
+  ASSERT_EQ(a, expected);
+}
+
+TEST_F(IntSetTest, Subtract) {
+  IntSet a{5, 8};
+  IntSet b{8, 11};
+  IntSet expected{5};
+
+  a.subtract(b);
+
+  ASSERT_EQ(a, expected);
+}
+
+TEST_F(IntSetTest, SymmetricDifference) {
+  IntSet a{5, 8};
+  IntSet b{8, 11};
+  IntSet expected{5, 11};
+
+  a.symmetric_difference(b);
+
+  ASSERT_EQ(a, expected);
+}
+
 }  // namespace common