add boost on mac

macx64/include/boost/beast/http/string_body.hpp

@@ -0,0 +1,187 @@
+//
+// 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_HTTP_STRING_BODY_HPP
+#define BOOST_BEAST_HTTP_STRING_BODY_HPP
+
+#include <boost/beast/core/detail/config.hpp>
+#include <boost/beast/core/buffer_traits.hpp>
+#include <boost/beast/http/error.hpp>
+#include <boost/beast/http/message.hpp>
+#include <boost/beast/core/buffers_range.hpp>
+#include <boost/beast/core/detail/clamp.hpp>
+#include <boost/beast/core/detail/type_traits.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/optional.hpp>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace boost {
+namespace beast {
+namespace http {
+
+/** A <em>Body</em> using `std::basic_string`
+
+    This body uses `std::basic_string` as a memory-based container
+    for holding message payloads. Messages using this body type
+    may be serialized and parsed.
+*/
+template<
+    class CharT,
+    class Traits = std::char_traits<CharT>,
+    class Allocator = std::allocator<CharT>>
+struct basic_string_body
+{
+private:
+    static_assert(
+        std::is_integral<CharT>::value &&
+            sizeof(CharT) == 1,
+        "CharT requirements not met");
+
+public:
+    /** The type of container used for the body
+
+        This determines the type of @ref message::body
+        when this body type is used with a message container.
+    */
+    using value_type =
+        std::basic_string<CharT, Traits, Allocator>;
+
+    /** Returns the payload size of the body
+
+        When this body is used with @ref message::prepare_payload,
+        the Content-Length will be set to the payload size, and
+        any chunked Transfer-Encoding will be removed.
+    */
+    static
+    std::uint64_t
+    size(value_type const& body)
+    {
+        return body.size();
+    }
+
+    /** The algorithm for parsing the body
+
+        Meets the requirements of <em>BodyReader</em>.
+    */
+#if BOOST_BEAST_DOXYGEN
+    using reader = __implementation_defined__;
+#else
+    class reader
+    {
+        value_type& body_;
+
+    public:
+        template<bool isRequest, class Fields>
+        explicit
+        reader(header<isRequest, Fields>&, value_type& b)
+            : body_(b)
+        {
+        }
+
+        void
+        init(boost::optional<
+            std::uint64_t> const& length, error_code& ec)
+        {
+            if(length)
+            {
+                if(*length > body_.max_size())
+                {
+                    ec = error::buffer_overflow;
+                    return;
+                }
+                body_.reserve(beast::detail::clamp(*length));
+            }
+            ec = {};
+        }
+
+        template<class ConstBufferSequence>
+        std::size_t
+        put(ConstBufferSequence const& buffers,
+            error_code& ec)
+        {
+            auto const extra = buffer_bytes(buffers);
+            auto const size = body_.size();
+            if (extra > body_.max_size() - size)
+            {
+                ec = error::buffer_overflow;
+                return 0;
+            }
+
+            body_.resize(size + extra);
+            ec = {};
+            CharT* dest = &body_[size];
+            for(auto b : beast::buffers_range_ref(buffers))
+            {
+                Traits::copy(dest, static_cast<
+                    CharT const*>(b.data()), b.size());
+                dest += b.size();
+            }
+            return extra;
+        }
+
+        void
+        finish(error_code& ec)
+        {
+            ec = {};
+        }
+    };
+#endif
+
+    /** The algorithm for serializing the body
+
+        Meets the requirements of <em>BodyWriter</em>.
+    */
+#if BOOST_BEAST_DOXYGEN
+    using writer = __implementation_defined__;
+#else
+    class writer
+    {
+        value_type const& body_;
+
+    public:
+        using const_buffers_type =
+            net::const_buffer;
+
+        template<bool isRequest, class Fields>
+        explicit
+        writer(header<isRequest, Fields> const&, value_type const& b)
+            : body_(b)
+        {
+        }
+
+        void
+        init(error_code& ec)
+        {
+            ec = {};
+        }
+
+        boost::optional<std::pair<const_buffers_type, bool>>
+        get(error_code& ec)
+        {
+            ec = {};
+            return {{const_buffers_type{
+                body_.data(), body_.size()}, false}};
+        }
+    };
+#endif
+};
+
+/// A <em>Body</em> using `std::string`
+using string_body = basic_string_body<char>;
+
+} // http
+} // beast
+} // boost
+
+#endif