From 4e6c24a126ceec48fdd97329a7f28f5b5adf274a Mon Sep 17 00:00:00 2001
From: BlackMATov <blackmatov@gmail.com>
Date: Sat, 4 May 2019 12:59:35 +0700
Subject: [PATCH] add operators interface

---
 flat_map.hpp       | 44 ++++++++++++++++++++++++++++++++++++--------
 flat_map_tests.cpp | 11 +++++++++++
 flat_set.hpp       | 43 ++++++++++++++++++++++++++++++++++++-------
 flat_set_tests.cpp | 11 +++++++++++
 4 files changed, 94 insertions(+), 15 deletions(-)

diff --git a/flat_map.hpp b/flat_map.hpp
index 7c6ad6d..6b47b63 100644
--- a/flat_map.hpp
+++ b/flat_map.hpp
@@ -247,15 +247,43 @@ namespace flat_hpp
         data_type data_;
         key_compare compare_;
     };
+}
 
-    template < typename Key
-             , typename Value
-             , typename Compare
-             , typename Allocator >
-    void swap(
-        flat_map<Key, Value, Compare, Allocator>& l,
-        flat_map<Key, Value, Compare, Allocator>& r)
-    {
+namespace flat_hpp
+{
+    template < typename K, typename V, typename C, typename A >
+    void swap(flat_map<K, V, C, A>& l, flat_map<K, V, C, A>& r) {
         l.swap(r);
     }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator==(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return l.size() == r.size()
+            && std::equal(l.begin(), l.end(), r.begin(), r.end());
+    }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator!=(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return !(l == r);
+    }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator<(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+    }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator>(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return r < l;
+    }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator<=(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return !(r < l);
+    }
+
+    template < typename K, typename V, typename C, typename A >
+    bool operator>=(const flat_map<K, V, C, A>& l, const flat_map<K, V, C, A>& r) {
+        return !(l < r);
+    }
 }
diff --git a/flat_map_tests.cpp b/flat_map_tests.cpp
index 78564e1..287578c 100644
--- a/flat_map_tests.cpp
+++ b/flat_map_tests.cpp
@@ -158,4 +158,15 @@ TEST_CASE("flat_map") {
         my_as_const(s0).key_comp();
         my_as_const(s0).value_comp();
     }
+    SECTION("operators") {
+        using map_t = flat_map<int, unsigned>;
+        map_t s0;
+        map_t s1;
+        REQUIRE(s0 == s1);
+        REQUIRE_FALSE(s0 != s1);
+        REQUIRE_FALSE(s0 < s1);
+        REQUIRE_FALSE(s0 > s1);
+        REQUIRE(s0 <= s1);
+        REQUIRE(s0 >= s1);
+    }
 }
diff --git a/flat_set.hpp b/flat_set.hpp
index d9bf478..9c661e9 100644
--- a/flat_set.hpp
+++ b/flat_set.hpp
@@ -233,14 +233,43 @@ namespace flat_hpp
         data_type data_;
         key_compare compare_;
     };
+}
 
-    template < typename Key
-             , typename Compare
-             , typename Allocator >
-    void swap(
-        flat_set<Key, Compare, Allocator>& l,
-        flat_set<Key, Compare, Allocator>& r)
-    {
+namespace flat_hpp
+{
+    template < typename K, typename C, typename A >
+    void swap(flat_set<K, C, A>& l, flat_set<K, C, A>& r) {
         l.swap(r);
     }
+
+    template < typename K, typename C, typename A >
+    bool operator==(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return l.size() == r.size()
+            && std::equal(l.begin(), l.end(), r.begin(), r.end());
+    }
+
+    template < typename K, typename C, typename A >
+    bool operator!=(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return !(l == r);
+    }
+
+    template < typename K, typename C, typename A >
+    bool operator<(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+    }
+
+    template < typename K, typename C, typename A >
+    bool operator>(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return r < l;
+    }
+
+    template < typename K, typename C, typename A >
+    bool operator<=(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return !(r < l);
+    }
+
+    template < typename K, typename C, typename A >
+    bool operator>=(const flat_set<K, C, A>& l, const flat_set<K, C, A>& r) {
+        return !(l < r);
+    }
 }
diff --git a/flat_set_tests.cpp b/flat_set_tests.cpp
index d360cd4..8e0451b 100644
--- a/flat_set_tests.cpp
+++ b/flat_set_tests.cpp
@@ -149,4 +149,15 @@ TEST_CASE("flat_set") {
         my_as_const(s0).key_comp();
         my_as_const(s0).value_comp();
     }
+    SECTION("operators") {
+        using set_t = flat_set<int>;
+        set_t s0;
+        set_t s1;
+        REQUIRE(s0 == s1);
+        REQUIRE_FALSE(s0 != s1);
+        REQUIRE_FALSE(s0 < s1);
+        REQUIRE_FALSE(s0 > s1);
+        REQUIRE(s0 <= s1);
+        REQUIRE(s0 >= s1);
+    }
 }