Use static_string from Boost.StaticString

CMakeLists.txt

@@ -29,6 +29,7 @@ target_link_libraries(boost_beast
     Boost::optional
     Boost::smart_ptr
     Boost::static_assert
+    Boost::static_string
     Boost::system
     Boost::throw_exception
     Boost::type_traits

include/boost/beast/core/detail/static_string.hpp

@@ -10,56 +10,15 @@
 #ifndef BOOST_BEAST_DETAIL_STATIC_STRING_HPP
 #define BOOST_BEAST_DETAIL_STATIC_STRING_HPP
 
-#include <boost/beast/core/string.hpp>
 #include <boost/assert.hpp>
-#include <iterator>
+#include <boost/core/ignore_unused.hpp>
+#include <string>
 #include <type_traits>
 
 namespace boost {
 namespace beast {
 namespace detail {
 
-// Because k-ballo said so
-template<class T>
-using is_input_iterator =
-    std::integral_constant<bool,
-        ! std::is_integral<T>::value>;
-
-template<class CharT, class Traits>
-int
-lexicographical_compare(
-    CharT const* s1, std::size_t n1,
-    CharT const* s2, std::size_t n2)
-{
-    if(n1 < n2)
-        return Traits::compare(
-            s1, s2, n1) <= 0 ? -1 : 1;
-    if(n1 > n2)
-        return Traits::compare(
-            s1, s2, n2) >= 0 ? 1 : -1;
-    return Traits::compare(s1, s2, n1);
-}
-
-template<class CharT, class Traits>
-int
-lexicographical_compare(
-    basic_string_view<CharT, Traits> s1,
-    CharT const* s2, std::size_t n2)
-{
-    return detail::lexicographical_compare<
-        CharT, Traits>(s1.data(), s1.size(), s2, n2);
-}
-
-template<class CharT, class Traits>
-int
-lexicographical_compare(
-    basic_string_view<CharT, Traits> s1,
-    basic_string_view<CharT, Traits> s2)
-{
-    return detail::lexicographical_compare<CharT, Traits>(
-        s1.data(), s1.size(), s2.data(), s2.size());
-}
-
 // Maximum number of characters in the decimal
 // representation of a binary number. This includes
 // the potential minus sign.

include/boost/beast/core/impl/static_string.hpp

@@ -1,583 +0,0 @@
-//
-// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// Official repository: https://github.com/boostorg/beast
-//
-
-#ifndef BOOST_BEAST_IMPL_STATIC_STRING_HPP
-#define BOOST_BEAST_IMPL_STATIC_STRING_HPP
-
-#include <boost/beast/core/detail/static_string.hpp>
-#include <boost/throw_exception.hpp>
-
-namespace boost {
-namespace beast {
-
-//
-// (constructor)
-//
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string()
-{
-    n_ = 0;
-    term();
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(size_type count, CharT ch)
-{
-    assign(count, ch);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-static_string<N, CharT, Traits>::
-static_string(static_string<M, CharT, Traits> const& other,
-    size_type pos)
-{
-    assign(other, pos);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-static_string<N, CharT, Traits>::
-static_string(static_string<M, CharT, Traits> const& other,
-    size_type pos, size_type count)
-{
-    assign(other, pos, count);
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(CharT const* s, size_type count)
-{
-    assign(s, count);
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(CharT const* s)
-{
-    auto const count = Traits::length(s);
-    if(count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "count > max_size()"});
-    n_ = count;
-    Traits::copy(&s_[0], s, n_ + 1);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class InputIt>
-static_string<N, CharT, Traits>::
-static_string(InputIt first, InputIt last)
-{
-    assign(first, last);
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(static_string const& s)
-{
-    assign(s);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-static_string<N, CharT, Traits>::
-static_string(static_string<M, CharT, Traits> const& s)
-{
-    assign(s);
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(std::initializer_list<CharT> init)
-{
-    assign(init.begin(), init.end());
-}
-
-template<std::size_t N, class CharT, class Traits>
-static_string<N, CharT, Traits>::
-static_string(string_view_type sv)
-{
-    assign(sv);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class T, class>
-static_string<N, CharT, Traits>::
-static_string(T const& t, size_type pos, size_type n)
-{
-    assign(t, pos, n);
-}
-
-//
-// (assignment)
-//
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-operator=(CharT const* s) ->
-    static_string&
-{
-    auto const count = Traits::length(s);
-    if(count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "count > max_size()"});
-    n_ = count;
-    Traits::copy(&s_[0], s, n_ + 1);
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-assign(size_type count, CharT ch) ->
-    static_string&
-{
-    if(count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "count > max_size()"});
-    n_ = count;
-    Traits::assign(&s_[0], n_, ch);
-    term();
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-assign(static_string const& str) ->
-    static_string&
-{
-    n_ = str.n_;
-    auto const n = n_ + 1;
-    BOOST_BEAST_ASSUME(n != 0);
-    Traits::copy(&s_[0], &str.s_[0], n);
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-auto
-static_string<N, CharT, Traits>::
-assign(static_string<M, CharT, Traits> const& str,
-        size_type pos, size_type count) ->
-    static_string&
-{
-    auto const ss = str.substr(pos, count);
-    return assign(ss.data(), ss.size());
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-assign(CharT const* s, size_type count) ->
-    static_string&
-{
-    if(count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "count > max_size()"});
-    n_ = count;
-    Traits::copy(&s_[0], s, n_);
-    term();
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class InputIt>
-auto
-static_string<N, CharT, Traits>::
-assign(InputIt first, InputIt last) ->
-    static_string&
-{
-    std::size_t const n = std::distance(first, last);
-    if(n > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "n > max_size()"});
-    n_ = n;
-    for(auto it = &s_[0]; first != last; ++it, ++first)
-        Traits::assign(*it, *first);
-    term();
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class T>
-auto
-static_string<N, CharT, Traits>::
-assign(T const& t, size_type pos, size_type count) ->
-    typename std::enable_if<std::is_convertible<T,
-        string_view_type>::value, static_string&>::type
-{
-    auto const sv = string_view_type(t).substr(pos, count);
-    if(sv.size() > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "sv.size() > max_size()"});
-    n_ = sv.size();
-    Traits::copy(&s_[0], &sv[0], n_);
-    term();
-    return *this;
-}
-
-//
-// Element access
-//
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-at(size_type pos) ->
-    reference
-{
-    if(pos >= size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "pos >= size()"});
-    return s_[pos];
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-at(size_type pos) const ->
-    const_reference
-{
-    if(pos >= size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "pos >= size()"});
-    return s_[pos];
-}
-
-//
-// Capacity
-//
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-reserve(std::size_t n)
-{
-    if(n > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "n > max_size()"});
-}
-
-//
-// Operations
-//
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-clear()
-{
-    n_ = 0;
-    term();
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-insert(size_type index, size_type count, CharT ch) ->
-    static_string&
-{
-    if(index > size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "index > size()"});
-    insert(begin() + index, count, ch);
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-insert(size_type index, CharT const* s, size_type count) ->
-    static_string&
-{
-    if(index > size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "index > size()"});
-    if(size() + count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "size() + count > max_size()"});
-    Traits::move(
-        &s_[index + count], &s_[index], size() - index);
-    n_ += count;
-    Traits::copy(&s_[index], s, count);
-    term();
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-auto
-static_string<N, CharT, Traits>::
-insert(size_type index,
-    static_string<M, CharT, Traits> const& str,
-        size_type index_str, size_type count) ->
-    static_string&
-{
-    auto const ss = str.substr(index_str, count);
-    return insert(index, ss.data(), ss.size());
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-insert(const_iterator pos, size_type count, CharT ch) ->
-    iterator
-{
-    if(size() + count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "size() + count() > max_size()"});
-    auto const index = pos - &s_[0];
-    Traits::move(
-        &s_[index + count], &s_[index], size() - index);
-    n_ += count;
-    Traits::assign(&s_[index], count, ch);
-    term();
-    return &s_[index];
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class InputIt>
-auto
-static_string<N, CharT, Traits>::
-insert(const_iterator pos, InputIt first, InputIt last) ->
-    typename std::enable_if<
-        detail::is_input_iterator<InputIt>::value,
-            iterator>::type
-{
-    std::size_t const count = std::distance(first, last);
-    if(size() + count > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "size() + count > max_size()"});
-    std::size_t const index = pos - begin();
-    Traits::move(
-        &s_[index + count], &s_[index], size() - index);
-    n_ += count;
-    for(auto it = begin() + index;
-            first != last; ++it, ++first)
-        Traits::assign(*it, *first);
-    term();
-    return begin() + index;
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<class T>
-auto
-static_string<N, CharT, Traits>::
-insert(size_type index, const T& t,
-        size_type index_str, size_type count) ->
-    typename std::enable_if<std::is_convertible<
-        T const&, string_view_type>::value &&
-        ! std::is_convertible<T const&, CharT const*>::value,
-            static_string&>::type
-{
-    auto const str =
-        string_view_type(t).substr(index_str, count);
-    return insert(index, str.data(), str.size());
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-erase(size_type index, size_type count) ->
-    static_string&
-{
-    if(index > size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "index > size()"});
-    auto const n = (std::min)(count, size() - index);
-    Traits::move(
-        &s_[index], &s_[index + n], size() - (index + n) + 1);
-    n_ -= n;
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-erase(const_iterator pos) ->
-    iterator
-{
-    erase(pos - begin(), 1);
-    return begin() + (pos - begin());
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-erase(const_iterator first, const_iterator last) ->
-    iterator
-{
-    erase(first - begin(),
-        std::distance(first, last));
-    return begin() + (first - begin());
-}
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-push_back(CharT ch)
-{
-    if(size() >= max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "size() >= max_size()"});
-    Traits::assign(s_[n_++], ch);
-    term();
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-auto
-static_string<N, CharT, Traits>::
-append(static_string<M, CharT, Traits> const& str,
-        size_type pos, size_type count) ->
-    static_string&
-{
-    // Valid range is [0, size)
-    if(pos >= str.size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "pos > str.size()"});
-    string_view_type const ss{&str.s_[pos],
-        (std::min)(count, str.size() - pos)};
-    insert(size(), ss.data(), ss.size());
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-substr(size_type pos, size_type count) const ->
-    string_view_type
-{
-    if(pos > size())
-        BOOST_THROW_EXCEPTION(std::out_of_range{
-            "pos > size()"});
-    return{&s_[pos], (std::min)(count, size() - pos)};
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-copy(CharT* dest, size_type count, size_type pos) const ->
-    size_type
-{
-    auto const str = substr(pos, count);
-    Traits::copy(dest, str.data(), str.size());
-    return str.size();
-}
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-resize(std::size_t n)
-{
-    if(n > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "n > max_size()"});
-    if(n > n_)
-        Traits::assign(&s_[n_], n - n_, CharT{});
-    n_ = n;
-    term();
-}
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-resize(std::size_t n, CharT c)
-{
-    if(n > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "n > max_size()"});
-    if(n > n_)
-        Traits::assign(&s_[n_], n - n_, c);
-    n_ = n;
-    term();
-}
-
-template<std::size_t N, class CharT, class Traits>
-void
-static_string<N, CharT, Traits>::
-swap(static_string& str)
-{
-    static_string tmp(str);
-    str.n_ = n_;
-    Traits::copy(&str.s_[0], &s_[0], n_ + 1);
-    n_ = tmp.n_;
-    Traits::copy(&s_[0], &tmp.s_[0], n_ + 1);
-}
-
-template<std::size_t N, class CharT, class Traits>
-template<std::size_t M>
-void
-static_string<N, CharT, Traits>::
-swap(static_string<M, CharT, Traits>& str)
-{
-    if(size() > str.max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "size() > str.max_size()"});
-    if(str.size() > max_size())
-        BOOST_THROW_EXCEPTION(std::length_error{
-            "str.size() > max_size()"});
-    static_string tmp(str);
-    str.n_ = n_;
-    Traits::copy(&str.s_[0], &s_[0], n_ + 1);
-    n_ = tmp.n_;
-    Traits::copy(&s_[0], &tmp.s_[0], n_ + 1);
-}
-
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-assign_char(CharT ch, std::true_type) ->
-    static_string&
-{
-    n_ = 1;
-    Traits::assign(s_[0], ch);
-    term();
-    return *this;
-}
-
-template<std::size_t N, class CharT, class Traits>
-auto
-static_string<N, CharT, Traits>::
-assign_char(CharT, std::false_type) ->
-    static_string&
-{
-    BOOST_THROW_EXCEPTION(std::length_error{
-        "max_size() == 0"});
-}
-
-template<class Integer, class>
-static_string<detail::max_digits(sizeof(Integer))>
-to_static_string(Integer x)
-{
-    using CharT = char;
-    using Traits = std::char_traits<CharT>;
-    BOOST_STATIC_ASSERT(std::is_integral<Integer>::value);
-    char buf[detail::max_digits(sizeof(Integer))];
-    auto last = buf + sizeof(buf);
-    auto it = detail::raw_to_string<
-        CharT, Integer, Traits>(last, sizeof(buf), x);
-    static_string<detail::max_digits(sizeof(Integer))> s;
-    s.resize(static_cast<std::size_t>(last - it));
-    auto p = s.data();
-    while(it < last)
-        Traits::assign(*p++, *it++);
-    return s;
-}
-
-} // beast
-} // boost
-
-#endif

include/boost/beast/core/string_type.hpp

@@ -39,6 +39,13 @@ using basic_string_view =
 
 #endif
 
+template<class S>
+inline string_view
+to_string_view(const S& s)
+{
+    return string_view(s.data(), s.size());
+}
+
 } // beast
 } // boost
 

include/boost/beast/http/impl/fields.hpp

@@ -933,8 +933,9 @@ set_content_length_impl(
         erase(field::content_length);
     else
     {
+        auto s = to_static_string(*value);
         set(field::content_length,
-            to_static_string(*value));
+            to_string_view(s));
     }
 }
 

include/boost/beast/websocket/detail/hybi13.ipp

@@ -40,7 +40,7 @@ make_sec_ws_accept(
     sec_ws_accept_type& accept,
     string_view key)
 {
-    BOOST_ASSERT(key.size() <= sec_ws_key_type::max_size_n);
+    BOOST_ASSERT(key.size() <= sec_ws_key_type::static_capacity);
     using namespace beast::detail::string_literals;
     auto const guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"_sv;
     beast::detail::sha1_context ctx;

include/boost/beast/websocket/detail/pmd_extension.hpp

@@ -82,7 +82,7 @@ pmd_write(http::basic_fields<Allocator>& fields,
     pmd_offer const& offer)
 {
     auto s = detail::pmd_write_impl(offer);
-    fields.set(http::field::sec_websocket_extensions, s);
+    fields.set(http::field::sec_websocket_extensions, to_string_view(s));
 }
 
 // Negotiate a permessage-deflate client offer
@@ -104,7 +104,7 @@ pmd_negotiate(
 
     auto s = detail::pmd_negotiate_impl(config, offer, o);
     if(config.accept)
-        fields.set(http::field::sec_websocket_extensions, s);
+        fields.set(http::field::sec_websocket_extensions, to_string_view(s));
 }
 
 // Normalize the server's response

include/boost/beast/websocket/impl/accept.hpp

@@ -120,7 +120,7 @@ build_response(
         if(it == req.end())
             return err(error::no_sec_key);
         key = it->value();
-        if(key.size() > detail::sec_ws_key_type::max_size_n)
+        if(key.size() > detail::sec_ws_key_type::static_capacity)
             return err(error::bad_sec_key);
     }
     {
@@ -149,7 +149,7 @@ build_response(
     {
         detail::sec_ws_accept_type acc;
         detail::make_sec_ws_accept(acc, key);
-        res.set(http::field::sec_websocket_accept, acc);
+        res.set(http::field::sec_websocket_accept, to_string_view(acc));
     }
     this->build_response_pmd(res, req);
     decorate(res);

include/boost/beast/websocket/impl/read.hpp

@@ -248,7 +248,7 @@ public:
                                 goto loop;
                             if(impl.ctrl_cb)
                                 impl.ctrl_cb(
-                                    frame_type::ping, payload);
+                                    frame_type::ping, to_string_view(payload));
                             impl.rd_fb.clear();
                             impl.template write_ping<
                                 flat_static_buffer_base>(impl.rd_fb,
@@ -336,7 +336,7 @@ public:
                         impl.rd_buf.consume(len);
                         // Ignore pong when closing
                         if(! impl.wr_close && impl.ctrl_cb)
-                            impl.ctrl_cb(frame_type::pong, payload);
+                            impl.ctrl_cb(frame_type::pong, to_string_view(payload));
                         goto loop;
                     }
 
@@ -376,7 +376,7 @@ public:
                         impl.rd_buf.consume(len);
                         if(impl.ctrl_cb)
                             impl.ctrl_cb(frame_type::close,
-                                impl.cr.reason);
+                                to_string_view(impl.cr.reason));
                         // See if we are already closing
                         if(impl.status_ == status::closing)
                         {
@@ -1103,7 +1103,7 @@ loop:
                     goto loop;
                 }
                 if(impl.ctrl_cb)
-                    impl.ctrl_cb(frame_type::ping, payload);
+                    impl.ctrl_cb(frame_type::ping, to_string_view(payload));
                 detail::frame_buffer fb;
                 impl.template write_ping<flat_static_buffer_base>(fb,
                     detail::opcode::pong, payload);
@@ -1119,7 +1119,7 @@ loop:
                 detail::read_ping(payload, b);
                 impl.rd_buf.consume(len);
                 if(impl.ctrl_cb)
-                    impl.ctrl_cb(frame_type::pong, payload);
+                    impl.ctrl_cb(frame_type::pong, to_string_view(payload));
                 goto loop;
             }
             // Handle close frame
@@ -1139,7 +1139,7 @@ loop:
                 impl.cr = cr;
                 impl.rd_buf.consume(len);
                 if(impl.ctrl_cb)
-                    impl.ctrl_cb(frame_type::close, impl.cr.reason);
+                    impl.ctrl_cb(frame_type::close, to_string_view(impl.cr.reason));
                 BOOST_ASSERT(! impl.wr_close);
                 // _Start the WebSocket Closing Handshake_
                 do_fail(

include/boost/beast/websocket/impl/stream_impl.hpp

@@ -631,7 +631,7 @@ build_request(
     req.set(http::field::upgrade, "websocket");
     req.set(http::field::connection, "upgrade");
     detail::make_sec_ws_key(key);
-    req.set(http::field::sec_websocket_key, key);
+    req.set(http::field::sec_websocket_key, to_string_view(key));
     req.set(http::field::sec_websocket_version, "13");
     this->build_request_pmd(req);
     decorator_opt(req);
@@ -677,8 +677,8 @@ on_response(
         if(it == res.end())
             return err(error::no_sec_accept);
         detail::sec_ws_accept_type acc;
-        detail::make_sec_ws_accept(acc, key);
+        detail::make_sec_ws_accept(acc, to_string_view(key));
-        if(acc.compare(it->value()) != 0)
+        if (to_string_view(acc).compare(it->value()) != 0)
             return err(error::bad_sec_accept);
     }
 

include/boost/beast/websocket/rfc6455.hpp

@@ -189,7 +189,7 @@ struct close_reason
     /// Construct from a reason string. code is @ref close_code::normal.
     close_reason(string_view s)
         : code(close_code::normal)
-        , reason(s)
+        , reason(s.data(), s.size())
     {
     }
 
@@ -203,7 +203,7 @@ struct close_reason
     /// Construct from a close code and reason string.
     close_reason(close_code code_, string_view s)
         : code(code_)
-        , reason(s)
+        , reason(s.data(), s.size())
     {
     }
 

test/beast/core/static_string.cpp

@@ -941,10 +941,15 @@ public:
             s3.append(s1, 1, 1);
             BEAST_EXPECT(s3 == "12Y");
             BEAST_EXPECT(*s3.end() == 0);
-            try
             {
                 static_string<3> s4("12");
                 s4.append(s1, 3);
+                BEAST_EXPECT(s4 == "12");
+            }
+            try
+            {
+                static_string<3> s4("12");
+                s4.append(s1, 4);
                 fail("", __FILE__, __LINE__);
             }
             catch(std::out_of_range const&)

test/beast/http/basic_parser.cpp

@@ -1136,7 +1136,7 @@ public:
         auto const grind =
         [&](string_view s)
         {
-            static_string<100> ss{s};
+            static_string<100> ss(s.data(), s.size());
             test::fuzz_rand r;
             test::fuzz(ss, 4, 5, r,
             [&](string_view s)

test/beast/http/chunk_encode.cpp

@@ -230,7 +230,7 @@ public:
         [&](string_view s)
         {
             error_code ec;
-            static_string<200> ss{s};
+            static_string<200> ss(s.data(), s.size());
             test::fuzz_rand r;
             for(auto i = 3; i--;)
             {

test/beast/http/fields.cpp

@@ -94,8 +94,10 @@ public:
     void
     fill(std::size_t n, basic_fields<Allocator>& f)
     {
-        for(std::size_t i = 1; i<= n; ++i)
+        for(std::size_t i = 1; i<= n; ++i) {
-            f.insert(std::to_string(i), to_static_string(i));
+            auto s = std::to_string(i);
+            f.insert(s, s);
+        }
     }
 
     template<class U, class V>
@@ -412,10 +414,10 @@ public:
         {
             // group fields
             fields f;
-            f.insert(field::age,   to_static_string(1));
+            f.insert(field::age,   "1");
-            f.insert(field::body,  to_static_string(2));
+            f.insert(field::body,  "2");
-            f.insert(field::close, to_static_string(3));
+            f.insert(field::close, "3");
-            f.insert(field::body,  to_static_string(4));
+            f.insert(field::body,  "4");
             BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::age);
             BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::body);
             BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::body);
@@ -435,10 +437,10 @@ public:
         {
             // group fields, case insensitive
             fields f;
-            f.insert("a",  to_static_string(1));
+            f.insert("a",  "1");
-            f.insert("ab", to_static_string(2));
+            f.insert("ab", "2");
-            f.insert("b",  to_static_string(3));
+            f.insert("b",  "3");
-            f.insert("AB", to_static_string(4));
+            f.insert("AB", "4");
             BEAST_EXPECT(std::next(f.begin(), 0)->name() == field::unknown);
             BEAST_EXPECT(std::next(f.begin(), 1)->name() == field::unknown);
             BEAST_EXPECT(std::next(f.begin(), 2)->name() == field::unknown);
@@ -458,14 +460,14 @@ public:
         {
             // verify insertion orde
             fields f;
-            f.insert( "a", to_static_string(1));
+            f.insert( "a", "1");
-            f.insert("dd", to_static_string(2));
+            f.insert("dd", "2");
-            f.insert("b",  to_static_string(3));
+            f.insert("b",  "3");
-            f.insert("dD", to_static_string(4));
+            f.insert("dD", "4");
-            f.insert("c",  to_static_string(5));
+            f.insert("c",  "5");
-            f.insert("Dd", to_static_string(6));
+            f.insert("Dd", "6");
-            f.insert("DD", to_static_string(7));
+            f.insert("DD", "7");
-            f.insert( "e", to_static_string(8));
+            f.insert( "e", "8");
             BEAST_EXPECT(f.count("dd") == 4);
             BEAST_EXPECT(std::next(f.begin(), 1)->name_string() == "dd");
             BEAST_EXPECT(std::next(f.begin(), 2)->name_string() == "dD");
@@ -479,13 +481,13 @@ public:
         // equal_range
         {
             fields f;
-            f.insert("E", to_static_string(1));
+            f.insert("E", "1");
-            f.insert("B", to_static_string(2));
+            f.insert("B", "2");
-            f.insert("D", to_static_string(3));
+            f.insert("D", "3");
-            f.insert("B", to_static_string(4));
+            f.insert("B", "4");
-            f.insert("C", to_static_string(5));
+            f.insert("C", "5");
-            f.insert("B", to_static_string(6));
+            f.insert("B", "6");
-            f.insert("A", to_static_string(7));
+            f.insert("A", "7");
             auto const rng = f.equal_range("B");
             BEAST_EXPECT(std::distance(rng.first, rng.second) == 3);
             BEAST_EXPECT(std::next(rng.first, 0)->value() == "2");
@@ -945,7 +947,7 @@ public:
             };
 
         res.erase(field::transfer_encoding);
-        res.set(field::content_length, to_static_string(32));
+        res.set(field::content_length, "32");
         chunked(true);
         BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
 
@@ -954,7 +956,7 @@ public:
         BEAST_EXPECT(res[field::transfer_encoding] == "chunked");
 
         res.erase(field::transfer_encoding);
-        res.set(field::content_length, to_static_string(32));
+        res.set(field::content_length, "32");
         chunked(false);
         BEAST_EXPECT(res.count(field::transfer_encoding) == 0);
 

test/beast/http/file_body.cpp

@@ -176,7 +176,7 @@ public:
             header.version(11);
             header.result(status::accepted);
             header.set(field::server, "test");
-            header.set(field::content_length, to_static_string(4097));
+            header.set(field::content_length, "4097");
 
             typename file_body_type::writer w(header, value);
             auto maybe_range = w.get(ec);

test/beast/http/write.cpp

@@ -643,7 +643,7 @@ public:
             m.method(verb::get);
             m.version(11);
             m.target("/");
-            m.set("Content-Length", to_static_string(5));
+            m.set("Content-Length", "5");
             m.body() = "*****";
             async_write(ts, m, handler{});
             BEAST_EXPECT(handler::count() > 0);
@@ -666,7 +666,7 @@ public:
                 m.method(verb::get);
                 m.version(11);
                 m.target("/");
-                m.set("Content-Length", to_static_string(5));
+                m.set("Content-Length", "5");
                 m.body() = "*****";
                 async_write(ts, m, handler{});
                 BEAST_EXPECT(handler::count() > 0);

tools/get-boost.sh

@@ -36,6 +36,7 @@ git submodule update --init --depth 20 --jobs 4 \
     libs/optional \
     libs/smart_ptr \
     libs/static_assert \
+    libs/static_string \
     libs/system \
     libs/throw_exception \
     libs/type_traits \