From 190d20e3a83c14f03bec5b2ac17566971bff4fa8 Mon Sep 17 00:00:00 2001
From: Damian Jarek <damian.jarek93@gmail.com>
Date: Sat, 18 Nov 2017 19:50:57 +0100
Subject: [PATCH] Tidy up basic_fields exception specifiers

fix #894

Signed-off-by: Damian Jarek <damian.jarek93@gmail.com>
---
 CHANGELOG.md                             |  4 ++
 include/boost/beast/http/fields.hpp      | 33 +++++++-------
 include/boost/beast/http/impl/fields.ipp | 11 +++--
 test/beast/http/fields.cpp               | 57 +++++++++++++++++++++++-
 4 files changed, 83 insertions(+), 22 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0c7f025..b85e9b8f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,10 @@ Version 147:
 * Don't use boost::string_ref
 * Use iterator wrapper in detail::buffers_range
 
+HTTP:
+
+* Tidy up basic_fields exception specifiers
+
 WebSocket:
 
 * control callback is copied or moved
diff --git a/include/boost/beast/http/fields.hpp b/include/boost/beast/http/fields.hpp
index 469320ca..1fe95684 100644
--- a/include/boost/beast/http/fields.hpp
+++ b/include/boost/beast/http/fields.hpp
@@ -188,6 +188,19 @@ private:
                             boost::intrusive::constant_time_size<true>,
                                 boost::intrusive::compare<key_compare>>::type;
 
+    using align_type = typename
+        boost::type_with_alignment<alignof(value_type)>::type;
+
+    using rebind_type = typename
+        beast::detail::allocator_traits<Allocator>::
+            template rebind_alloc<align_type>;
+
+    using alloc_traits =
+        beast::detail::allocator_traits<rebind_type>;
+
+    using size_type = typename
+        beast::detail::allocator_traits<Allocator>::size_type;
+
 
 public:
     /// Destructor
@@ -201,14 +214,14 @@ public:
         @param alloc The allocator to use.
     */
     explicit
-    basic_fields(Allocator const& alloc);
+    basic_fields(Allocator const& alloc) noexcept;
 
     /** Move constructor.
 
         The state of the moved-from object is
         as if constructed using the same allocator.
     */
-    basic_fields(basic_fields&&);
+    basic_fields(basic_fields&&) noexcept;
 
     /** Move constructor.
 
@@ -245,7 +258,8 @@ public:
         The state of the moved-from object is
         as if constructed using the same allocator.
     */
-    basic_fields& operator=(basic_fields&&);
+    basic_fields& operator=(basic_fields&&) noexcept(
+        alloc_traits::propagate_on_container_move_assignment::value);
 
     /// Copy assignment.
     basic_fields& operator=(basic_fields const&);
@@ -690,19 +704,6 @@ private:
     template<class OtherAlloc>
     friend class basic_fields;
 
-    using align_type = typename
-        boost::type_with_alignment<alignof(value_type)>::type;
-
-    using rebind_type = typename
-        beast::detail::allocator_traits<Allocator>::
-            template rebind_alloc<align_type>;
-
-    using alloc_traits =
-        beast::detail::allocator_traits<rebind_type>;
-
-    using size_type = typename
-        beast::detail::allocator_traits<Allocator>::size_type;
-
     value_type&
     new_element(field name,
         string_view sname, string_view value);
diff --git a/include/boost/beast/http/impl/fields.ipp b/include/boost/beast/http/impl/fields.ipp
index d0505f0b..0e3d48ec 100644
--- a/include/boost/beast/http/impl/fields.ipp
+++ b/include/boost/beast/http/impl/fields.ipp
@@ -349,14 +349,14 @@ basic_fields<Allocator>::
 
 template<class Allocator>
 basic_fields<Allocator>::
-basic_fields(Allocator const& alloc)
+basic_fields(Allocator const& alloc) noexcept
     : beast::detail::empty_base_optimization<Allocator>(alloc)
 {
 }
 
 template<class Allocator>
 basic_fields<Allocator>::
-basic_fields(basic_fields&& other)
+basic_fields(basic_fields&& other) noexcept
     : beast::detail::empty_base_optimization<Allocator>(
         std::move(other.member()))
     , set_(std::move(other.set_))
@@ -426,9 +426,12 @@ basic_fields(basic_fields<OtherAlloc> const& other,
 template<class Allocator>
 auto
 basic_fields<Allocator>::
-operator=(basic_fields&& other) ->
-    basic_fields&
+operator=(basic_fields&& other) noexcept(
+    alloc_traits::propagate_on_container_move_assignment::value)
+      -> basic_fields&
 {
+    static_assert(is_nothrow_move_assignable<Allocator>::value,
+        "Allocator must be noexcept assignable.");
     if(this == &other)
         return *this;
     move_assign(other, std::integral_constant<bool,
diff --git a/test/beast/http/fields.cpp b/test/beast/http/fields.cpp
index 6abdcd8b..0b982db6 100644
--- a/test/beast/http/fields.cpp
+++ b/test/beast/http/fields.cpp
@@ -21,11 +21,64 @@ namespace boost {
 namespace beast {
 namespace http {
 
-BOOST_STATIC_ASSERT(is_fields<fields>::value);
-
 class fields_test : public beast::unit_test::suite
 {
 public:
+    template <class T>
+    class test_allocator
+    {
+    public:
+        using value_type = T;
+
+        test_allocator() noexcept(false) {}
+
+        template <typename  U, typename = typename std::enable_if<!std::is_same<test_allocator, U>::value>::type>
+        test_allocator(test_allocator<U> const&) noexcept {}
+
+        value_type*
+        allocate(std::size_t n)
+        {
+            return static_cast<value_type*>(::operator new (n*sizeof(value_type)));
+        }
+
+        void
+        deallocate(value_type* p, std::size_t) noexcept
+        {
+            ::operator delete(p);
+        }
+
+        template <class U>
+        friend
+        bool
+        operator==(test_allocator<T> const&, test_allocator<U> const&) noexcept
+        {
+            return true;
+        }
+
+        template <class U>
+        friend
+        bool
+        operator!=(test_allocator<T> const& x, test_allocator<U> const& y) noexcept
+        {
+            return !(x == y);
+        }
+    };
+
+    using test_fields = basic_fields<test_allocator<char>>;
+
+    BOOST_STATIC_ASSERT(is_fields<fields>::value);
+    BOOST_STATIC_ASSERT(is_fields<test_fields>::value);
+
+    // std::allocator is noexcept movable, fields should satisfy
+    // these constraints as well.
+    BOOST_STATIC_ASSERT(std::is_nothrow_move_constructible<fields>::value);
+    BOOST_STATIC_ASSERT(std::is_nothrow_move_assignable<fields>::value);
+
+    // Check if basic_fields respects throw-constructibility and
+    // propagate_on_container_move_assignment of the allocator.
+    BOOST_STATIC_ASSERT(std::is_nothrow_move_constructible<test_fields>::value);
+    BOOST_STATIC_ASSERT(!std::is_nothrow_move_assignable<test_fields>::value);
+
     template<class Allocator>
     using fa_t = basic_fields<Allocator>;