Fix memory leak

Author: sergcpp

internal/HashMap32.h

@@ -54,11 +54,17 @@ class HashMap32 : HashFunc, KeyEqual, Allocator {
     HashMap32(const HashMap32 &rhs) = delete;
     HashMap32 &operator=(const HashMap32 &rhs) = delete;
 
-    HashMap32(HashMap32 &&rhs) noexcept { (*this) = std::move(rhs); }
+    HashMap32(HashMap32 &&rhs) noexcept : ctrl_(nullptr), nodes_(nullptr), capacity_(0), size_(0) {
+        (*this) = std::move(rhs);
+    }
     HashMap32 &operator=(HashMap32 &&rhs) noexcept {
         if (this == &rhs) {
             return (*this);
         }
+        if (ctrl_) {
+            clear();
+            this->deallocate(ctrl_, mem_size(capacity_));
+        }
         if constexpr (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) {
             Allocator::operator=(static_cast<Allocator &&>(rhs));
         }
@@ -79,6 +85,8 @@ class HashMap32 : HashFunc, KeyEqual, Allocator {
     uint32_t size() const { return size_; }
     uint32_t capacity() const { return capacity_; }
 
+    bool empty() const { return size_ == 0; }
+
     void clear() {
         for (uint32_t i = 0; i < capacity_ && size_; i++) {
             if (ctrl_[i] & OccupiedBit) {
@@ -185,7 +193,7 @@ class HashMap32 : HashFunc, KeyEqual, Allocator {
     }
 
     template <typename K2> V *Find(const uint32_t hash, const K2 &key) {
-        return const_cast<V *>(const_cast<const HashMap32 *>(this)->Find(hash, key));
+        return const_cast<V *>(std::as_const(*this).Find(hash, key));
     }
 
     Node *GetOrNull(const uint32_t index) {
@@ -330,6 +338,15 @@ class HashMap32 : HashFunc, KeyEqual, Allocator {
         return iter_at(next);
     }
 
+    uint32_t FindOccupiedInRange(const uint32_t start, const uint32_t end) {
+        for (uint32_t i = start; i < end; ++i) {
+            if (ctrl_[i] & OccupiedBit) {
+                return i;
+            }
+        }
+        return end;
+    }
+
   private:
     void CheckRealloc() {
         if ((size_ + 1) > uint32_t(0.8f * capacity_)) {

internal/HashSet32.h

@@ -56,16 +56,26 @@ template <typename K> class Hash {
 template <> class Hash<char *> {
   public:
     uint32_t operator()(const char *s) const { return _str_hash(s); }
+    uint32_t operator()(const std::string_view &s) const { return _str_hash_len(s.data(), s.size()); }
 };
 
 template <> class Hash<const char *> {
   public:
     uint32_t operator()(const char *s) const { return _str_hash(s); }
+    uint32_t operator()(const std::string_view &s) const { return _str_hash_len(s.data(), s.size()); }
+};
+
+template <> class Hash<std::string_view> {
+  public:
+    uint32_t operator()(const std::string &s) const { return _str_hash_len(s.c_str(), s.length()); }
+    uint32_t operator()(const std::string_view &s) const { return _str_hash_len(s.data(), s.size()); }
+    uint32_t operator()(const char *s) const { return _str_hash(s); }
 };
 
 template <> class Hash<std::string> {
   public:
     uint32_t operator()(const std::string &s) const { return _str_hash_len(s.c_str(), s.length()); }
+    uint32_t operator()(const std::string_view &s) const { return _str_hash_len(s.data(), s.size()); }
     uint32_t operator()(const char *s) const { return _str_hash(s); }
 };
 
@@ -77,11 +87,13 @@ template <typename K> class Equal : std::equal_to<K> {
 template <> class Equal<char *> {
   public:
     bool operator()(const char *k1, const char *k2) const { return strcmp(k1, k2) == 0; }
+    bool operator()(const char *k1, std::string_view k2) const { return k2 == k1; }
 };
 
 template <> class Equal<const char *> {
   public:
     bool operator()(const char *k1, const char *k2) const { return strcmp(k1, k2) == 0; }
+    bool operator()(const char *k1, std::string_view k2) const { return k2 == k1; }
 };
 
 template <> class Equal<std::string> {
@@ -138,11 +150,17 @@ class HashSet32 : HashFunc, KeyEqual, Allocator {
     HashSet32(const HashSet32 &rhs) = delete;
     HashSet32 &operator=(const HashSet32 &rhs) = delete;
 
-    HashSet32(HashSet32 &&rhs) noexcept { (*this) = std::move(rhs); }
+    HashSet32(HashSet32 &&rhs) noexcept : ctrl_(nullptr), nodes_(nullptr), capacity_(0), size_(0) {
+        (*this) = std::move(rhs);
+    }
     HashSet32 &operator=(HashSet32 &&rhs) noexcept {
         if (this == &rhs) {
             return (*this);
         }
+        if (ctrl_) {
+            clear();
+            this->deallocate(ctrl_, mem_size(capacity_));
+        }
         if constexpr (std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) {
             Allocator::operator=(static_cast<Allocator &&>(rhs));
         }
@@ -252,7 +270,7 @@ class HashSet32 : HashFunc, KeyEqual, Allocator {
     }
 
     template <typename K2> K *Find(const uint32_t hash, const K2 &key) {
-        return const_cast<K *>(const_cast<const HashSet32 *>(this)->Find(hash, key));
+        return const_cast<K *>(std::as_const(*this).Find(hash, key));
     }
 
     Node *GetOrNull(const uint32_t index) {

internal/SmallVector.h

@@ -219,7 +219,6 @@ template <typename T, typename Allocator = aligned_allocator<T, alignof(T)>> cla
         }
 
         T *new_begin = this->allocate(req_capacity);
-        T *new_end = new_begin + size_;
 
         for (uint32_t i = 0; i < size_; ++i) {
             new (new_begin + i) T(std::move(begin_[i]));