add string-keyed set and unordered_set (alibaba#1207)

Author: lihuiba

common/string-keyed.h

@@ -21,7 +21,9 @@ limitations under the License.
 #include <photon/common/hash_combine.h>
 #include <cstring>
 #include <unordered_map>
+#include <unordered_set>
 #include <map>
+#include <set>
 
 // string_key is a string_view with dedicated storage,
 // primarily used as stored keys in std::map and std::unordered_map,
@@ -192,10 +194,8 @@ template<class T,
 using unordered_map_string_key_case_insensitive = basic_map_string_key<
     std::unordered_map<string_key, T, Hasher, KeyEqual, Alloc>>;
 
-template<class T,
-    class Pred = std::less<string_key>,
-    class Alloc = std::allocator<std::pair<const string_key,T>>>
-class map_string_key : public basic_map_string_key<
+template<class T, class Pred, class Alloc>
+class ordered_map_string_key : public basic_map_string_key<
     std::map<string_key, T, Pred, Alloc>>
 {
 public:
@@ -225,6 +225,11 @@ class map_string_key : public basic_map_string_key<
     }
 };
 
+template<class T,
+    class Pred = std::less<string_key>,
+    class Alloc = std::allocator<std::pair<const string_key,T>>>
+using map_string_key = ordered_map_string_key<T, Pred, Alloc>;
+
 class Less_CaseInsensitive {
 public:
     bool operator()(std::string_view a, std::string_view b) const {
@@ -239,8 +244,125 @@ class Less_CaseInsensitive {
 template<class T,
     class Pred = Less_CaseInsensitive,
     class Alloc = std::allocator<std::pair<const string_key,T>>>
-using map_string_key_case_insensitive = basic_map_string_key<
-    std::map<string_key, T, Pred, Alloc>>;
+using map_string_key_case_insensitive = ordered_map_string_key<
+    T, Pred, Alloc>;
+
+// The basic class for sets with string keys, aims to avoid temp
+// std::string construction in queries, by accepting string_views.
+// S is the underlying set, either std::set or std::unordered_set
+template <class S>
+class basic_set_string_key : public S
+{
+public:
+    using base = S;
+    using typename base::const_iterator;
+    using typename base::iterator;
+    using typename base::size_type;
+    using base::base;
+
+    using base::erase;
+
+    using key_type = std::string_view;
+    using value_type = string_key;
+
+    iterator find ( const key_type& k )
+    {
+        return base::find((const string_key&)k);
+    }
+    const_iterator find ( const key_type& k ) const
+    {
+        return base::find((const string_key&)k);
+    }
+    size_type count ( const key_type& k ) const
+    {
+        return base::count((const string_key&)k);
+    }
+    std::pair<iterator,iterator> equal_range ( const key_type& k )
+    {
+        return base::equal_range((const string_key&)k);
+    }
+    std::pair<const_iterator,const_iterator> equal_range ( const key_type& k ) const
+    {
+        return base::equal_range((const string_key&)k);
+    }
+    std::pair<iterator,bool> emplace ( const key_type& k )
+    {
+        return base::emplace((const string_key&)k);
+    }
+    template <class... Args>
+    std::pair<iterator,bool> emplace ( const key_type& k, Args&&... args )
+    {
+        return base::emplace((const string_key&)k, std::forward<Args>(args)...);
+    }
+    template <class... Args>
+    iterator emplace_hint ( const_iterator position, const key_type& k, Args&&... args )
+    {
+        return base::emplace_hint(position, (const string_key&)k, std::forward<Args>(args)...);
+    }
+    std::pair<iterator,bool> insert ( const key_type& k )
+    {
+        return emplace(k);
+    }
+    iterator insert ( const_iterator hint, const key_type& k )
+    {
+        return emplace_hint(hint, k);
+    }
+    size_type erase ( const std::string_view& k )
+    {
+        return base::erase((const string_key&)k);
+    }
+};
+
+template<class Hasher = std::hash<std::string_view>,
+    class KeyEqual = std::equal_to<std::string_view>,
+    class Alloc = std::allocator<string_key>>
+using unordered_set_string_key = basic_set_string_key<
+    std::unordered_set<string_key, Hasher, KeyEqual, Alloc>>;
+
+template<class Hasher = Hasher_CaseInsensitive,
+    class KeyEqual = Equal_CaseInsensitive,
+    class Alloc = std::allocator<string_key>>
+using unordered_set_string_key_case_insensitive = basic_set_string_key<
+    std::unordered_set<string_key, Hasher, KeyEqual, Alloc>>;
+
+// ordered set with string keys, provides lower_bound/upper_bound
+template <class S>
+class ordered_set_string_key : public basic_set_string_key<S>
+{
+public:
+    using base = basic_set_string_key<S>;
+    using typename base::key_type;
+    using typename base::const_iterator;
+    using typename base::iterator;
+    using base::base;
+
+    iterator lower_bound (const key_type& k)
+    {
+        return base::lower_bound((const string_key&)k);
+    }
+    const_iterator lower_bound (const key_type& k) const
+    {
+        return base::lower_bound((const string_key&)k);
+    }
+    iterator upper_bound (const key_type& k)
+    {
+        return base::upper_bound((const string_key&)k);
+    }
+    const_iterator upper_bound (const key_type& k) const
+    {
+        return base::upper_bound((const string_key&)k);
+    }
+};
+
+template<class Pred = std::less<string_key>,
+    class Alloc = std::allocator<string_key>>
+using set_string_key = ordered_set_string_key<
+    std::set<string_key, Pred, Alloc>>;
+
+template<class Pred = Less_CaseInsensitive,
+    class Alloc = std::allocator<string_key>>
+using set_string_key_case_insensitive = ordered_set_string_key<
+    std::set<string_key, Pred, Alloc>>;
 
 // the String Key-Value (Mutable), stored together
 // in a consecutive area, so as to save one allocation

common/test/test.cpp

@@ -1349,6 +1349,72 @@ TEST(string_key, case_insensitive) {
     test_map_case_insensitive<map_string_kv_case_insensitive>();
 }
 
+template<typename S> static
+void basic_set_test(S& test_set) {
+    const auto& const_set = test_set;
+    std::string prefix = "seggwrg90if908234j5rlkmx.c,bnmi7890wer1234rbdfb";
+
+    for (int i = 0; i < 100; i++) {
+        std::string s = prefix + std::to_string(i);
+        test_set.insert(s);
+    }
+    EXPECT_EQ(test_set.size(), 100);
+
+    for (int i = 0; i < 100; i++) {
+        std::string s = prefix + std::to_string(i);
+        EXPECT_NE(test_set.find(s), test_set.end());
+        EXPECT_EQ(test_set.count(s), 1);
+        EXPECT_NE(const_set.find(s), const_set.end());
+        EXPECT_EQ(const_set.count(s), 1);
+    }
+    for (int i = 100; i < 200; i++) {
+        std::string s = prefix + std::to_string(i);
+        EXPECT_EQ(test_set.find(s), test_set.end());
+        EXPECT_EQ(test_set.count(s), 0);
+    }
+
+    test_set.erase(prefix + "50");
+    EXPECT_EQ(test_set.size(), 99);
+    EXPECT_EQ(test_set.count(prefix + "50"), 0);
+
+    test_set.clear();
+    EXPECT_EQ(test_set.size(), 0);
+}
+
+TEST(string_key, unordered_set_string_key) {
+    unordered_set_string_key<> test_set;
+    basic_set_test(test_set);
+}
+
+TEST(string_key, set_string_key) {
+    set_string_key<> test_set;
+    basic_set_test(test_set);
+
+    std::string prefix = "seggwrg90if908234j5rlkmx.c,bnmi7890wer1234rbdfb";
+    EXPECT_EQ(test_set.lower_bound(prefix + "2"), test_set.find(prefix + "2"));
+    EXPECT_EQ(test_set.lower_bound(prefix + "1"), test_set.find(prefix + "2"));
+    EXPECT_EQ(test_set.upper_bound(prefix + "22"), test_set.find(prefix + "23"));
+
+    const auto& const_set = test_set;
+    EXPECT_EQ(const_set.lower_bound(prefix + "2"), const_set.find(prefix + "2"));
+    EXPECT_EQ(const_set.upper_bound(prefix + "22"), const_set.find(prefix + "23"));
+}
+
+template<typename S> static
+void test_set_case_insensitive() {
+    S s;
+    s.insert("asdf");
+    auto it = s.find("ASDF");
+    EXPECT_NE(it, s.end());
+    EXPECT_EQ(*it, "asdf");
+    EXPECT_EQ(s.count("kuherqf"), 0);
+}
+
+TEST(string_key, set_case_insensitive) {
+    test_set_case_insensitive<unordered_set_string_key_case_insensitive<>>();
+    test_set_case_insensitive<set_string_key_case_insensitive<>>();
+}
+
 TEST(RangeLock, Basic) {
   RangeLock m;