From 27aa360c9dd9a142cb8877863a8123d1be083615 Mon Sep 17 00:00:00 2001
From: Arthur O'Dwyer <arthur.j.odwyer@gmail.com>
Date: Sun, 5 Nov 2023 12:25:04 -0500
Subject: [PATCH] [flat_foo] Fix uses of std::initializer_list

And use uses-allocator construction in flat_set's copy/move constructors.
---
 include/sg14/flat_map.h | 24 ++++++++++++------------
 include/sg14/flat_set.h | 38 ++++++++++++++++++++++++--------------
 2 files changed, 36 insertions(+), 26 deletions(-)

diff --git a/include/sg14/flat_map.h b/include/sg14/flat_map.h
index 41a06db..07b1082 100644
--- a/include/sg14/flat_map.h
+++ b/include/sg14/flat_map.h
@@ -525,31 +525,31 @@ class flat_map {
           values_(flatmap_detail::make_obj_using_allocator<MappedContainer>(a, m.values_)),
           compare_(m.compare_) {}
 
-    flat_map(std::initializer_list<value_type>&& il, const Compare& comp = Compare())
-        : flat_map(il, comp) {}
+    flat_map(std::initializer_list<value_type> il, const Compare& comp = Compare())
+        : flat_map(il.begin(), il.end(), comp) {}
 
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(std::initializer_list<value_type>&& il, const Compare& comp, const Alloc& a)
-        : flat_map(il, comp, a) {}
+    flat_map(std::initializer_list<value_type> il, const Compare& comp, const Alloc& a)
+        : flat_map(il.begin(), il.end(), comp, a) {}
 
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(std::initializer_list<value_type>&& il, const Alloc& a)
-        : flat_map(il, Compare(), a) {}
+    flat_map(std::initializer_list<value_type> il, const Alloc& a)
+        : flat_map(il.begin(), il.end(), a) {}
 
-    flat_map(sorted_unique_t s, std::initializer_list<value_type>&& il, const Compare& comp = Compare())
-        : flat_map(s, il, comp) {}
+    flat_map(sorted_unique_t s, std::initializer_list<value_type> il, const Compare& comp = Compare())
+        : flat_map(s, il.begin(), il.end(), comp) {}
 
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(sorted_unique_t s, std::initializer_list<value_type>&& il, const Compare& comp, const Alloc& a)
-        : flat_map(s, il, comp, a) {}
+    flat_map(sorted_unique_t s, std::initializer_list<value_type> il, const Compare& comp, const Alloc& a)
+        : flat_map(s, il.begin(), il.end(), comp, a) {}
 
     template<class Alloc,
              typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value && std::uses_allocator<MappedContainer, Alloc>::value, int>::type = 0>
-    flat_map(sorted_unique_t s, std::initializer_list<value_type>&& il, const Alloc& a)
-        : flat_map(s, il, Compare(), a) {}
+    flat_map(sorted_unique_t s, std::initializer_list<value_type> il, const Alloc& a)
+        : flat_map(s, il.begin(), il.end(), Compare(), a) {}
 
 // ========================================================== OTHER MEMBERS
 
diff --git a/include/sg14/flat_set.h b/include/sg14/flat_set.h
index 433f656..245c2e0 100644
--- a/include/sg14/flat_set.h
+++ b/include/sg14/flat_set.h
@@ -314,38 +314,48 @@ class flat_set {
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
     flat_set(flat_set&& m, const Alloc& a)
-        : c_(static_cast<KeyContainer&&>(m.c_), a), compare_(static_cast<Compare&&>(m.compare_)) {}
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, static_cast<KeyContainer&&>(m.c_))),
+          compare_(static_cast<Compare&&>(m.compare_)) {}
 
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
     flat_set(const flat_set& m, const Alloc& a)
-        : c_(m.c_, a), compare_(m.compare_) {}
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, m.c_)), compare_(m.compare_) {}
 
-    flat_set(std::initializer_list<Key>&& il, const Compare& comp = Compare())
-        : flat_set(il, comp) {}
+    flat_set(std::initializer_list<Key> il, const Compare& comp = Compare())
+        : c_(il), compare_(comp)
+    {
+        this->sort_and_unique_impl();
+    }
 
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
-    flat_set(std::initializer_list<Key>&& il, const Compare& comp, const Alloc& a)
-        : flat_set(il, comp, a) {}
+    flat_set(std::initializer_list<Key> il, const Compare& comp, const Alloc& a)
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, il)), compare_(comp)
+    {
+        this->sort_and_unique_impl();
+    }
 
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
-    flat_set(std::initializer_list<Key>&& il, const Alloc& a)
-        : flat_set(il, Compare(), a) {}
+    flat_set(std::initializer_list<Key> il, const Alloc& a)
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, il))
+    {
+        this->sort_and_unique_impl();
+    }
 
-    flat_set(sorted_unique_t s, std::initializer_list<Key>&& il, const Compare& comp = Compare())
-        : flat_set(s, il, comp) {}
+    flat_set(sorted_unique_t, std::initializer_list<Key> il, const Compare& comp = Compare())
+        : c_(il), compare_(comp) {}
 
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
-    flat_set(sorted_unique_t s, std::initializer_list<Key>&& il, const Compare& comp, const Alloc& a)
-        : flat_set(s, il, comp, a) {}
+    flat_set(sorted_unique_t, std::initializer_list<Key> il, const Compare& comp, const Alloc& a)
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, il)), compare_(comp) {}
 
     template<class Alloc,
              class = typename std::enable_if<std::uses_allocator<KeyContainer, Alloc>::value>::type>
-    flat_set(sorted_unique_t s, std::initializer_list<Key>&& il, const Alloc& a)
-        : flat_set(s, il, Compare(), a) {}
+    flat_set(sorted_unique_t, std::initializer_list<Key> il, const Alloc& a)
+        : c_(flatset_detail::make_obj_using_allocator<KeyContainer>(a, il)) {}
 
 
 // ========================================================== OTHER MEMBERS