Implement assignment and copy-construction for SkTHashSet/Map.

This will enable us to use SkTHashMap to store our definition maps.

Change-Id: I6017dfa71e1c5e68a20c97e955bb3d3abf347f0d
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/323891
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: John Stiles <johnstiles@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>

Author: johnstiles-google

include/private/SkTHash.h

@@ -39,6 +39,17 @@ class SkTHashTable {
         return *this;
     }
 
+    SkTHashTable(const SkTHashTable& that) {
+        this->copyFrom(that);
+    }
+
+    SkTHashTable& operator=(const SkTHashTable& that) {
+        if (this != &that) {
+            this->copyFrom(that);
+        }
+        return *this;
+    }
+
     // Clear the table.
     void reset() { *this = SkTHashTable(); }
 
@@ -135,6 +146,16 @@ class SkTHashTable {
     }
 
 private:
+    // Copy from another hash table into this one.
+    void copyFrom(const SkTHashTable& that) {
+        fCount = that.fCount;
+        fCapacity = that.fCapacity;
+        fSlots = SkAutoTArray<Slot>(fCapacity);
+        for (int i = 0; i < fCapacity; i++) {
+            fSlots[i] = that.fSlots[i];
+        }
+    }
+
     T* uncheckedSet(T&& val) {
         const K& key = Traits::GetKey(val);
         uint32_t hash = Hash(key);
@@ -223,26 +244,21 @@ class SkTHashTable {
     }
 
     struct Slot {
-        Slot() : val{}, hash(0) {}
+        Slot() = default;
+        Slot(const Slot& o) = default;
+        Slot(Slot&& o) = default;
+        Slot& operator=(const Slot& o) = default;
+        Slot& operator=(Slot&& o) = default;
         Slot(T&& v, uint32_t h) : val(std::move(v)), hash(h) {}
-        Slot(Slot&& o) { *this = std::move(o); }
-        Slot& operator=(Slot&& o) {
-            val  = std::move(o.val);
-            hash = o.hash;
-            return *this;
-        }
 
         bool empty() const { return this->hash == 0; }
 
-        T        val;
-        uint32_t hash;
+        T        val{};
+        uint32_t hash = 0;
     };
 
     int fCount, fCapacity;
     SkAutoTArray<Slot> fSlots;
-
-    SkTHashTable(const SkTHashTable&) = delete;
-    SkTHashTable& operator=(const SkTHashTable&) = delete;
 };
 
 // Maps K->V.  A more user-friendly wrapper around SkTHashTable, suitable for most use cases.
@@ -253,6 +269,8 @@ class SkTHashMap {
     SkTHashMap() {}
     SkTHashMap(SkTHashMap&&) = default;
     SkTHashMap& operator=(SkTHashMap&&) = default;
+    SkTHashMap(const SkTHashMap& that) = default;
+    SkTHashMap& operator=(const SkTHashMap& that) = default;
 
     // Clear the map.
     void reset() { fTable.reset(); }
@@ -315,9 +333,6 @@ class SkTHashMap {
     };
 
     SkTHashTable<Pair, K> fTable;
-
-    SkTHashMap(const SkTHashMap&) = delete;
-    SkTHashMap& operator=(const SkTHashMap&) = delete;
 };
 
 // A set of T.  T is treated as an ordinary copyable C++ type.
@@ -327,6 +342,8 @@ class SkTHashSet {
     SkTHashSet() {}
     SkTHashSet(SkTHashSet&&) = default;
     SkTHashSet& operator=(SkTHashSet&&) = default;
+    SkTHashSet(const SkTHashSet& that) = default;
+    SkTHashSet& operator=(const SkTHashSet& that) = default;
 
     // Clear the set.
     void reset() { fTable.reset(); }
@@ -368,9 +385,6 @@ class SkTHashSet {
         static auto Hash(const T& item) { return HashT()(item); }
     };
     SkTHashTable<T, T, Traits> fTable;
-
-    SkTHashSet(const SkTHashSet&) = delete;
-    SkTHashSet& operator=(const SkTHashSet&) = delete;
 };
 
 #endif//SkTHash_DEFINED

tests/HashTest.cpp

@@ -44,28 +44,45 @@ DEF_TEST(HashMap, r) {
     for (int i = 0; i < N; i++) {
         map.set(i, 2.0*i);
     }
+
+    SkTHashMap<int, double> clone = map;
+
     for (int i = 0; i < N; i++) {
         double* found = map.find(i);
         REPORTER_ASSERT(r, found);
         REPORTER_ASSERT(r, *found == i*2.0);
+
+        found = clone.find(i);
+        REPORTER_ASSERT(r, found);
+        REPORTER_ASSERT(r, *found == i*2.0);
     }
     for (int i = N; i < 2*N; i++) {
         REPORTER_ASSERT(r, !map.find(i));
+        REPORTER_ASSERT(r, !clone.find(i));
     }
 
     REPORTER_ASSERT(r, map.count() == N);
+    REPORTER_ASSERT(r, clone.count() == N);
 
     for (int i = 0; i < N/2; i++) {
         map.remove(i);
     }
     for (int i = 0; i < N; i++) {
         double* found = map.find(i);
-        REPORTER_ASSERT(r, (found == nullptr) ==  (i < N/2));
+        REPORTER_ASSERT(r, (found == nullptr) == (i < N/2));
+
+        found = clone.find(i);
+        REPORTER_ASSERT(r, *found == i*2.0);
     }
     REPORTER_ASSERT(r, map.count() == N/2);
+    REPORTER_ASSERT(r, clone.count() == N);
 
     map.reset();
     REPORTER_ASSERT(r, map.count() == 0);
+    REPORTER_ASSERT(r, clone.count() == N);
+
+    clone = map;
+    REPORTER_ASSERT(r, clone.count() == 0);
 
     {
         // Test that we don't leave dangling values in empty slots.
@@ -88,22 +105,32 @@ DEF_TEST(HashSet, r) {
 
     set.add(SkString("Hello"));
     set.add(SkString("World"));
-
     REPORTER_ASSERT(r, set.count() == 2);
-
     REPORTER_ASSERT(r, set.contains(SkString("Hello")));
     REPORTER_ASSERT(r, set.contains(SkString("World")));
     REPORTER_ASSERT(r, !set.contains(SkString("Goodbye")));
-
     REPORTER_ASSERT(r, set.find(SkString("Hello")));
     REPORTER_ASSERT(r, *set.find(SkString("Hello")) == SkString("Hello"));
 
+    SkTHashSet<SkString> clone = set;
+    REPORTER_ASSERT(r, clone.count() == 2);
+    REPORTER_ASSERT(r, clone.contains(SkString("Hello")));
+    REPORTER_ASSERT(r, clone.contains(SkString("World")));
+    REPORTER_ASSERT(r, !clone.contains(SkString("Goodbye")));
+    REPORTER_ASSERT(r, clone.find(SkString("Hello")));
+    REPORTER_ASSERT(r, *clone.find(SkString("Hello")) == SkString("Hello"));
+
     set.remove(SkString("Hello"));
     REPORTER_ASSERT(r, !set.contains(SkString("Hello")));
     REPORTER_ASSERT(r, set.count() == 1);
+    REPORTER_ASSERT(r, clone.contains(SkString("Hello")));
+    REPORTER_ASSERT(r, clone.count() == 2);
 
     set.reset();
     REPORTER_ASSERT(r, set.count() == 0);
+
+    clone = set;
+    REPORTER_ASSERT(r, clone.count() == 0);
 }
 
 namespace {