Merge pull request #285 from jj683/make-set-map-nothrow-move

set/map nothrow move constructible/assignable

immer/detail/hamts/champ.hpp

@@ -139,22 +139,26 @@ struct champ
 
     static node_t* empty()
     {
-        static const auto node = node_t::make_inner_n(0);
-        return node->inc();
+        static const auto empty_ = []{
+            constexpr auto size = node_t::sizeof_inner_n(0);
+            static std::aligned_storage_t<size, alignof(std::max_align_t)> storage;
+            return node_t::make_inner_n_into(&storage, size, 0u);
+        }();
+        return empty_->inc();
     }
 
-    champ(node_t* r, size_t sz = 0)
+    champ(node_t* r, size_t sz = 0) noexcept
         : root{r}
         , size{sz}
     {}
 
-    champ(const champ& other)
+    champ(const champ& other) noexcept
         : champ{other.root, other.size}
     {
         inc();
     }
 
-    champ(champ&& other)
+    champ(champ&& other) noexcept
         : champ{empty()}
     {
         swap(*this, other);
@@ -167,13 +171,13 @@ struct champ
         return *this;
     }
 
-    champ& operator=(champ&& other)
+    champ& operator=(champ&& other) noexcept
     {
         swap(*this, other);
         return *this;
     }
 
-    friend void swap(champ& x, champ& y)
+    friend void swap(champ& x, champ& y) noexcept
     {
         using std::swap;
         swap(x.root, y.root);

immer/detail/hamts/node.hpp

@@ -222,12 +222,11 @@ struct node
         return can_mutate(impl.d.data.inner.values, e);
     }
 
-    static node_t* make_inner_n(count_t n)
+    static node_t* make_inner_n_into(void* buffer, std::size_t size, count_t n)
     {
         assert(n <= branches<B>);
-        auto m = heap::allocate(sizeof_inner_n(n));
-        auto p = new (m) node_t;
-        assert(p == (node_t*) m);
+        assert(size >= sizeof_inner_n(n));
+        auto p = new (buffer) node_t;
 #if IMMER_TAGGED_NODE
         p->impl.d.kind = node_t::kind_t::inner;
 #endif
@@ -237,6 +236,13 @@ struct node
         return p;
     }
 
+    static node_t* make_inner_n(count_t n)
+    {
+        assert(n <= branches<B>);
+        auto m = heap::allocate(sizeof_inner_n(n));
+        return make_inner_n_into(m, sizeof_inner_n(n), n);
+    }
+
     static node_t* make_inner_n(count_t n, values_t* values)
     {
         auto p = make_inner_n(n);

immer/map.hpp

@@ -547,4 +547,9 @@ class map
     impl_t impl_ = impl_t::empty();
 };
 
+static_assert(std::is_nothrow_move_constructible<map<int, int>>::value,
+              "map is not nothrow move constructible");
+static_assert(std::is_nothrow_move_assignable<map<int, int>>::value,
+              "map is not nothrow move assignable");
+
 } // namespace immer

immer/set.hpp

@@ -292,4 +292,10 @@ class set
     impl_t impl_ = impl_t::empty();
 };
 
+static_assert(std::is_nothrow_move_constructible<set<int>>::value,
+              "set is not nothrow move constructible");
+static_assert(std::is_nothrow_move_assignable<set<int>>::value,
+              "set is not nothrow move assignable");
+
+
 } // namespace immer