serializing file_body is not const

CHANGELOG.md

@@ -6,6 +6,7 @@ Version 76:
 * Add serializer::get
 * Add serializer::chunked
 * Serializer members are not const
+* serializing file_body is not const
 
 API Changes:
 

example/common/write_msg.hpp

@@ -46,12 +46,16 @@ class write_msg_op
         //
         beast::http::message<isRequest, Body, Fields> msg;
 
+        // Serializer for the message
+        beast::http::serializer<isRequest, Body, Fields> sr;
+
         data(
             Handler& handler,
             AsyncWriteStream& stream_,
             beast::http::message<isRequest, Body, Fields>&& msg_)
             : stream(stream_)
             , msg(std::move(msg_))
+            , sr(msg)
         {
             boost::ignore_unused(handler);
         }
@@ -96,7 +100,7 @@ public:
     {
         auto& d = *d_;
         beast::http::async_write(
-            d.stream, d.msg, std::move(*this));
+            d.stream, d.sr, std::move(*this));
     }
 
     // Completion handler

example/http-server-threaded/http_server_threaded.cpp

@@ -141,11 +141,18 @@ private:
         auto res = get(full_path, file_ec);
 
         if(file_ec == beast::errc::no_such_file_or_directory)
+        {
             http::write(sock_, not_found(), ec);
+        }
         else if(ec)
+        {
             http::write(sock_, server_error(file_ec), ec);
+        }
         else
-            http::write(sock_, std::move(res), ec);
+        {
+            http::serializer<false, decltype(res)::body_type> sr{res};
+            http::write(sock_, sr, ec);
+        }
     }
 
     void

example/server-framework/http_sync_port.hpp

@@ -157,7 +157,8 @@ private:
         operator()(
             beast::http::response<Body, Fields>&& res) const
         {
-            beast::http::write(self_.impl().stream(), res, ec_);
+            beast::http::serializer<false, Body, Fields> sr{res};
+            beast::http::write(self_.impl().stream(), sr, ec_);
         }
     };
 

include/beast/core/file_win32.hpp

@@ -75,7 +75,7 @@ public:
 
     /// Returns the native handle associated with the file.
     native_handle_type
-    native_handle() const
+    native_handle()
     {
         return h_;
     }
@@ -130,7 +130,7 @@ public:
         @return The offset in bytes from the beginning of the file
     */
     std::uint64_t
-    pos(error_code& ec) const;
+    pos(error_code& ec);
 
     /** Adjust the current position in the open file
 
@@ -150,7 +150,7 @@ public:
         @param ec Set to the error, if any occurred
     */
     std::size_t
-    read(void* buffer, std::size_t n, error_code& ec) const;
+    read(void* buffer, std::size_t n, error_code& ec);
 
     /** Write to the open file
 

include/beast/core/impl/file_win32.ipp

@@ -226,7 +226,7 @@ size(error_code& ec) const
 inline
 std::uint64_t
 file_win32::
-pos(error_code& ec) const
+pos(error_code& ec)
 {
     if(h_ == boost::detail::winapi::INVALID_HANDLE_VALUE_)
     {
@@ -272,7 +272,7 @@ seek(std::uint64_t offset, error_code& ec)
 inline
 std::size_t
 file_win32::
-read(void* buffer, std::size_t n, error_code& ec) const
+read(void* buffer, std::size_t n, error_code& ec)
 {
     if(h_ == boost::detail::winapi::INVALID_HANDLE_VALUE_)
     {

include/beast/http/file_body.hpp

@@ -219,7 +219,7 @@ size(value_type const& v)
 template<class File>
 class basic_file_body<File>::reader
 {
-    value_type const& body_;    // The body we are reading from
+    value_type& body_;      // The body we are reading from
     std::uint64_t remain_;  // The number of unread bytes
     char buf_[4096];        // Small buffer for reading
 
@@ -234,9 +234,28 @@ public:
     // `m` holds the message we are sending, which will
     // always have the `file_body` as the body type.
     //
+    // Note that the message is passed by non-const reference.
+    // This is intentional, because reading from the file
+    // changes its "current position" which counts makes the
+    // operation logically not-const (although it is bitwise
+    // const).
+    //
+    // The BodyReader concept allows the reader to choose
+    // whether to take the message by const reference or
+    // non-const reference. Depending on the choice, a
+    // serializer constructed using that body type will
+    // require the same const or non-const reference to
+    // construct.
+    //
+    // Readers which accept const messages usually allow
+    // the same body to be serialized by multiple threads
+    // concurrently, while readers accepting non-const
+    // messages may only be serialized by one thread at
+    // a time.
+    //
     template<bool isRequest, class Fields>
     reader(message<
-        isRequest, basic_file_body, Fields> const& m);
+        isRequest, basic_file_body, Fields>& m);
 
     // Initializer
     //
@@ -269,7 +288,7 @@ template<class File>
 template<bool isRequest, class Fields>
 basic_file_body<File>::
 reader::
-reader(message<isRequest, basic_file_body, Fields> const& m)
+reader(message<isRequest, basic_file_body, Fields>& m)
     : body_(m.body)
 {
     // The file must already be open