Add unordered_set

Author: kirillin

README.md

@@ -3,6 +3,9 @@ mystd is a stl-like library.
 
 [![GitHub Pages](https://img.shields.io/badge/docs-online-blue?logo=github)](https://pets-tech.github.io/mystd/) [![codecov](https://codecov.io/gh/pets-tech/mystd/graph/badge.svg?token=92FQ42MXUZ)](https://codecov.io/gh/pets-tech/mystd) [![mystd CI](https://github.com/pets-tech/mystd/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/pets-tech/mystd/actions/workflows/ci.yml)
 
+> [!IMPORTANT]
+> In fact, this is a demo, not realy production code. Real containers need weeks of dev and testing, not hours/days. Use at your own risk. I just implemented a lot of basic things quickly.
+
 
 ## Features
 
@@ -24,7 +27,7 @@ mystd is a stl-like library.
 - [ ] hash table
     - [x] hash table on separate chaining -> my::hashtable
         - [x] my::unordered_map
-        - [ ] my::unordered_set
+        - [x] my::unordered_set
         - [ ] my::unordered_multimap
         - [ ] my::unordered_multiset
     - [ ] hash table on open addressing

include/mystd/unordered_set.hpp

@@ -6,18 +6,17 @@
 
 namespace my {
 
-template <class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
+template <class Value, class Hash = std::hash<Value>, class KeyEqual = std::equal_to<Value>>
 class unordered_set {
  private:
   struct Identity {
-    const Key& operator()(const Key& k) const noexcept { return k; }
+    const Value& operator()(const Value& v) const noexcept { return v; }
   };
 
-  using Base = hashtable<Key, Key, Identity, Hash, KeyEqual, InsertPolicy::UniqueKeys>;
+  using Base = hashtable<Value, Value, Identity, Hash, KeyEqual, InsertPolicy::UniqueKeys>;
   Base table;
 
  public:
-  using key_type = Key;
   using value_type = Value;
   using reference = Value&;
   using const_reference = const Value&;
@@ -29,28 +28,22 @@ class unordered_set {
   unordered_set(const size_type bucket_count = 8) : table(bucket_count) {};
 
   // initializer_list ctor
-  unordered_set(const std::initializer_list<std::pair<Key, Value>>& init) : unordered_set() {
-    for (const auto& kv : init) {
-      insert(kv);
+  unordered_set(const std::initializer_list<Value>& init) : unordered_set() {
+    for (const auto& v : init) {
+      insert(v);
     }
   }
 
-  // observers
-  reference operator[](const key_type& k) {
-    auto [it, inserted] = table.insert(k);
-    return *it;
-  }
-
   // modifiers
 
-  iterator insert(const key_type& k) {
-    auto it_flag = table.insert(k);
+  iterator insert(const value_type& v) {
+    auto it_flag = table.insert(v);
     return it_flag.first;
   }
 
-  iterator find(const key_type& k) { return table.find(k); }
+  iterator find(const value_type& v) { return table.find(v); }
 
-  iterator erase(const key_type& k) { return table.erase(k); }
+  iterator erase(const value_type& v) { return table.erase(v); }
 
   // capacity
   size_type size() const { return table.size(); }

tests/unit_tests/test_unordered_set.cpp

@@ -0,0 +1,90 @@
+#include <gtest/gtest.h>
+
+#include "mystd/unordered_set.hpp"
+
+namespace my::testing {
+
+TEST(UnorderedSetTest, Initialization) {
+  my::unordered_set<int> uset;
+  EXPECT_TRUE(uset.empty());
+  EXPECT_EQ(uset.size(), 0);
+  EXPECT_EQ(uset.bucket_count(), 8);
+}
+
+TEST(UnorderedSetTest, InitializerList) {
+  my::unordered_set<int> uset = {1, 2, 3, 3, 3, 3};
+  EXPECT_FALSE(uset.empty());
+  EXPECT_EQ(uset.size(), 3);
+  EXPECT_EQ(uset.bucket_count(), 8);
+}
+
+TEST(UnorderedSetTest, Find) {
+  my::unordered_set<int> uset1 = {1, 2, 3, 3, 3, 3};
+  EXPECT_TRUE(uset1.find(1) != uset1.end());
+  EXPECT_TRUE(uset1.find(2) != uset1.end());
+  EXPECT_TRUE(uset1.find(3) != uset1.end());
+  EXPECT_TRUE(uset1.find(4) == uset1.end());
+}
+
+TEST(UnorderedSetTest, Erase) {
+  my::unordered_set<int> uset1 = {1, 2, 3, 3, 3, 3};
+
+  uset1.erase(1);
+  EXPECT_EQ(uset1.size(), 2);
+  EXPECT_TRUE(uset1.find(1) == uset1.end());
+
+  uset1.erase(2);
+  EXPECT_EQ(uset1.size(), 1);
+  EXPECT_TRUE(uset1.find(2) == uset1.end());
+
+  uset1.erase(3);
+  EXPECT_EQ(uset1.size(), 0);
+  EXPECT_TRUE(uset1.find(3) == uset1.end());
+
+  EXPECT_TRUE(uset1.empty());
+}
+
+TEST(UnorderedSetTest, CopyMode) {
+  my::unordered_set<int> uset1 = {1, 2, 3, 3, 3, 3};
+
+  my::unordered_set<int> uset2(uset1);
+  EXPECT_EQ(uset2.size(), 3);
+
+  my::unordered_set<int> uset3;
+  uset3 = uset1;
+  EXPECT_EQ(uset3.size(), 3);
+
+  my::unordered_set<int> uset4(std::move(uset1));
+  EXPECT_EQ(uset4.size(), 3);
+  EXPECT_TRUE(uset1.empty());
+
+  my::unordered_set<int> uset5;
+  uset5 = std::move(uset4);
+  EXPECT_EQ(uset5.size(), 3);
+  EXPECT_TRUE(uset4.empty());
+}
+
+TEST(UnorderedSetTest, Iterators) {
+  my::unordered_set<int> uset = {0, 1, 2, 3, 4, 5};
+
+  for (auto& v : uset) {
+    EXPECT_EQ(*uset.find(v), v);
+  }
+
+  auto it = uset.cbegin();
+  auto ite = uset.cend();
+}
+
+TEST(UnorderedSetTest, Rehashing) {
+  my::unordered_set<int> uset(3);
+
+  EXPECT_EQ(uset.bucket_count(), 3);
+
+  for (size_t i = 0; i < 100; ++i) {
+    uset.insert(i);
+  }
+
+  EXPECT_EQ(uset.bucket_count(), 192);
+}
+
+}  // namespace my::testing