Tidy up basic_fields, header, and concepts

include/beast/http/impl/fields.ipp

@@ -365,7 +365,7 @@ template<class Allocator>
 inline
 string_view
 basic_fields<Allocator>::
-method_impl() const
+get_method_impl() const
 {
     return method_;
 }
@@ -374,7 +374,7 @@ template<class Allocator>
 inline
 string_view
 basic_fields<Allocator>::
-target_impl() const
+get_target_impl() const
 {
     return target_or_reason_;
 }
@@ -383,7 +383,7 @@ template<class Allocator>
 inline
 string_view
 basic_fields<Allocator>::
-reason_impl() const
+get_reason_impl() const
 {
     return target_or_reason_;
 }
@@ -392,7 +392,7 @@ template<class Allocator>
 inline
 void
 basic_fields<Allocator>::
-method_impl(string_view s)
+set_method_impl(string_view s)
 {
     realloc_string(method_, s);
 }
@@ -401,7 +401,7 @@ template<class Allocator>
 inline
 void
 basic_fields<Allocator>::
-target_impl(string_view s)
+set_target_impl(string_view s)
 {
     realloc_string(target_or_reason_, s);
 }
@@ -410,11 +410,13 @@ template<class Allocator>
 inline
 void
 basic_fields<Allocator>::
-reason_impl(string_view s)
+set_reason_impl(string_view s)
 {
     realloc_string(target_or_reason_, s);
 }
 
+//---
+
 template<class Allocator>
 inline
 void

include/beast/http/impl/message.ipp

@@ -19,60 +19,176 @@ namespace beast {
 namespace http {
 
 template<class Fields>
-template<class>
-string_view
+template<class Arg1, class... ArgN, class>
 header<true, Fields>::
-get_method_string() const
+header(Arg1&& arg1, ArgN&&... argn)
+    : Fields(std::forward<Arg1>(arg1),
+        std::forward<ArgN>(argn)...)
 {
-    if(method_ != verb::unknown)
-        return to_string(method_);
-    return this->method_impl();
 }
 
 template<class Fields>
-template<class>
+inline
+verb
+header<true, Fields>::
+method() const
+{
+    return method_;
+}
+
+template<class Fields>
 void
 header<true, Fields>::
-set_method(verb v)
+method(verb v)
 {
     if(v == verb::unknown)
         BOOST_THROW_EXCEPTION(
             std::invalid_argument{"unknown verb"});
     method_ = v;
-    this->method_impl({});
+    this->set_method_impl({});
+}
+
+template<class Fields>
+string_view
+header<true, Fields>::
+method_string() const
+{
+    if(method_ != verb::unknown)
+        return to_string(method_);
+    return this->get_method_impl();
 }
 
 template<class Fields>
-template<class>
 void
 header<true, Fields>::
-set_method(string_view s)
+method(string_view s)
 {
     method_ = string_to_verb(s);
     if(method_ != verb::unknown)
-        this->method_impl({});
+        this->set_method_impl({});
     else
-        this->method_impl(s);
+        this->set_method_impl(s);
+}
+
+template<class Fields>
+inline
+string_view
+header<true, Fields>::
+target() const
+{
+    return this->get_target_impl();
+}
+
+template<class Fields>
+inline
+void
+header<true, Fields>::
+target(string_view s)
+{
+    this->set_target_impl(s);
+}
+
+template<class Fields>
+void
+swap(
+    header<true, Fields>& h1,
+    header<true, Fields>& h2)
+{
+    using std::swap;
+    swap(
+        static_cast<Fields&>(h1),
+        static_cast<Fields&>(h2));
+    swap(h1.version, h2.version);
+    swap(h1.method_, h2.method_);
+}
+
+//------------------------------------------------------------------------------
+
+template<class Fields>
+template<class Arg1, class... ArgN, class>
+header<false, Fields>::
+header(Arg1&& arg1, ArgN&&... argn)
+    : Fields(std::forward<Arg1>(arg1),
+        std::forward<ArgN>(argn)...)
+{
+}
+template<class Fields>
+inline
+status
+header<false, Fields>::
+result() const
+{
+    return int_to_status(
+        static_cast<int>(result_));
+}
+
+template<class Fields>
+inline
+void
+header<false, Fields>::
+result(status v)
+{
+    result_ = v;
+}
+
+template<class Fields>
+inline
+void
+header<false, Fields>::
+result(unsigned v)
+{
+    if(v > 999)
+        BOOST_THROW_EXCEPTION(
+            std::invalid_argument{
+                "invalid result-code"});
+    result_ = static_cast<status>(v);
+}
+
+template<class Fields>
+inline
+unsigned
+header<false, Fields>::
+result_int() const
+{
+    return static_cast<unsigned>(result_);
 }
 
 template<class Fields>
-template<class>
 string_view
 header<false, Fields>::
-get_reason() const
+reason() const
 {
-    auto const s = this->reason_impl();
+    auto const s = this->get_reason_impl();
     if(! s.empty())
         return s;
     return obsolete_reason(result_);
 }
 
+template<class Fields>
+inline
+void
+header<false, Fields>::
+reason(string_view s)
+{
+    this->set_reason_impl(s);
+}
+
+template<class Fields>
+void
+swap(
+    header<false, Fields>& h1,
+    header<false, Fields>& h2)
+{
+    using std::swap;
+    swap(
+        static_cast<Fields&>(h1),
+        static_cast<Fields&>(h2));
+    swap(h1.version, h2.version);
+    swap(h1.result_, h2.result_);
+}
+
 //------------------------------------------------------------------------------
 
-namespace detail {
-
-} // detail
-
 template<bool isRequest, class Body, class Fields>
 bool
 message<isRequest, Body, Fields>::
@@ -239,34 +355,6 @@ prepare_payload(std::false_type)
 
 //------------------------------------------------------------------------------
 
-template<class Fields>
-void
-swap(
-    header<true, Fields>& h1,
-    header<true, Fields>& h2)
-{
-    using std::swap;
-    swap(
-        static_cast<Fields&>(h1),
-        static_cast<Fields&>(h2));
-    swap(h1.version, h2.version);
-    swap(h1.method_, h2.method_);
-}
-
-template<class Fields>
-void
-swap(
-    header<false, Fields>& h1,
-    header<false, Fields>& h2)
-{
-    using std::swap;
-    swap(
-        static_cast<Fields&>(h1),
-        static_cast<Fields&>(h2));
-    swap(h1.version, h2.version);
-    swap(h1.result_, h2.result_);
-}
-
 template<bool isRequest, class Body, class Fields>
 void
 swap(