add boost on mac

macx64/include/boost/beast/_experimental/http/impl/icy_stream.hpp

@@ -0,0 +1,334 @@
+//
+// 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_CORE_IMPL_ICY_STREAM_HPP
+#define BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP
+
+#include <boost/beast/core/async_base.hpp>
+#include <boost/beast/core/buffer_traits.hpp>
+#include <boost/beast/core/error.hpp>
+#include <boost/beast/core/stream_traits.hpp>
+#include <boost/beast/core/detail/is_invocable.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <cstring>
+#include <memory>
+#include <utility>
+
+namespace boost {
+namespace beast {
+namespace http {
+
+namespace detail {
+
+template<class ConstBufferSequence>
+boost::tribool
+is_icy(ConstBufferSequence const& buffers)
+{
+    char buf[3];
+    auto const n = net::buffer_copy(
+        net::mutable_buffer(buf, 3),
+        buffers);   
+    if(n >= 1 && buf[0] != 'I')
+        return false;
+    if(n >= 2 && buf[1] != 'C')
+        return false;
+    if(n >= 3 && buf[2] != 'Y')
+        return false;
+    if(n < 3)
+        return boost::indeterminate;
+    return true;
+}
+
+} // detail
+
+template<class NextLayer>
+struct icy_stream<NextLayer>::ops
+{
+
+template<class Buffers, class Handler>
+class read_op
+    : public beast::async_base<Handler,
+        beast::executor_type<icy_stream>>
+    , public net::coroutine
+{
+    icy_stream& s_;
+    Buffers b_;
+    std::size_t n_ = 0;
+    error_code ec_;
+    bool match_ = false;
+
+public:
+    template<class Handler_>
+    read_op(
+        Handler_&& h,
+        icy_stream& s,
+        Buffers const& b)
+        : async_base<Handler,
+            beast::executor_type<icy_stream>>(
+                std::forward<Handler_>(h), s.get_executor())
+        , s_(s)
+        , b_(b)
+    {
+        (*this)({}, 0, false);
+    }
+
+    void
+    operator()(
+        error_code ec,
+        std::size_t bytes_transferred,
+        bool cont = true)
+    {
+        BOOST_ASIO_CORO_REENTER(*this)
+        {
+            if(s_.detect_)
+            {
+                BOOST_ASSERT(s_.n_ == 0);
+                for(;;)
+                {
+                    // Try to read the first three characters
+                    BOOST_ASIO_CORO_YIELD
+                    s_.next_layer().async_read_some(
+                        net::mutable_buffer(
+                            s_.buf_ + s_.n_, 3 - s_.n_),
+                        std::move(*this));
+                    s_.n_ += static_cast<char>(bytes_transferred);
+                    if(ec)
+                        goto upcall;
+                    auto result = detail::is_icy(
+                        net::const_buffer(s_.buf_, s_.n_));
+                    if(boost::indeterminate(result))
+                        continue;
+                    if(result)
+                        s_.n_ = static_cast<char>(net::buffer_copy(
+                            net::buffer(s_.buf_, sizeof(s_.buf_)),
+                            icy_stream::version()));
+                    break;
+                }
+                s_.detect_ = false;
+            }
+            if(s_.n_ > 0)
+            {
+                bytes_transferred = net::buffer_copy(
+                    b_, net::const_buffer(s_.buf_, s_.n_));
+                s_.n_ -= static_cast<char>(bytes_transferred);
+                std::memmove(
+                    s_.buf_,
+                    s_.buf_ + bytes_transferred,
+                    sizeof(s_.buf_) - bytes_transferred);
+            }
+            else
+            {
+                BOOST_ASIO_CORO_YIELD
+                s_.next_layer().async_read_some(
+                    b_, std::move(*this));
+            }
+        upcall:
+            if(! cont)
+            {
+                ec_ = ec;
+                n_ = bytes_transferred;
+                BOOST_ASIO_CORO_YIELD
+                s_.next_layer().async_read_some(
+                    net::mutable_buffer{},
+                    std::move(*this));
+                ec = ec_;
+                bytes_transferred = n_;
+            }
+            this->complete_now(ec, bytes_transferred);
+        }
+    }
+};
+
+struct run_read_op
+{
+    template<class ReadHandler, class Buffers>
+    void
+    operator()(
+        ReadHandler&& h,
+        icy_stream* s,
+        Buffers const& b)
+    {
+        // If you get an error on the following line it means
+        // that your handler does not meet the documented type
+        // requirements for the handler.
+
+        static_assert(
+            beast::detail::is_invocable<ReadHandler,
+            void(error_code, std::size_t)>::value,
+            "ReadHandler type requirements not met");
+
+        read_op<
+            Buffers,
+            typename std::decay<ReadHandler>::type>(
+                std::forward<ReadHandler>(h), *s, b);
+    }
+};
+
+};
+
+//------------------------------------------------------------------------------
+
+template<class NextLayer>
+template<class... Args>
+icy_stream<NextLayer>::
+icy_stream(Args&&... args)
+    : stream_(std::forward<Args>(args)...)
+{
+    std::memset(buf_, 0, sizeof(buf_));
+}
+
+template<class NextLayer>
+template<class MutableBufferSequence>
+std::size_t
+icy_stream<NextLayer>::
+read_some(MutableBufferSequence const& buffers)
+{
+    static_assert(is_sync_read_stream<next_layer_type>::value,
+        "SyncReadStream type requirements not met");
+    static_assert(net::is_mutable_buffer_sequence<
+        MutableBufferSequence>::value,
+            "MutableBufferSequence type requirements not met");
+    error_code ec;
+    auto n = read_some(buffers, ec);
+    if(ec)
+        BOOST_THROW_EXCEPTION(system_error{ec});
+    return n;
+}
+
+template<class NextLayer>
+template<class MutableBufferSequence>
+std::size_t
+icy_stream<NextLayer>::
+read_some(MutableBufferSequence const& buffers, error_code& ec)
+{
+    static_assert(is_sync_read_stream<next_layer_type>::value,
+        "SyncReadStream type requirements not met");
+    static_assert(net::is_mutable_buffer_sequence<
+        MutableBufferSequence>::value,
+            "MutableBufferSequence type requirements not met");
+    std::size_t bytes_transferred;
+    if(detect_)
+    {
+        BOOST_ASSERT(n_ == 0);
+        for(;;)
+        {
+            // Try to read the first three characters
+            bytes_transferred = next_layer().read_some(
+                net::mutable_buffer(buf_ + n_, 3 - n_), ec);
+            n_ += static_cast<char>(bytes_transferred);
+            if(ec)
+                return 0;
+            auto result = detail::is_icy(
+                net::const_buffer(buf_, n_));
+            if(boost::indeterminate(result))
+                continue;
+            if(result)
+                n_ = static_cast<char>(net::buffer_copy(
+                    net::buffer(buf_, sizeof(buf_)),
+                    icy_stream::version()));
+            break;
+        }
+        detect_ = false;
+    }
+    if(n_ > 0)
+    {
+        bytes_transferred = net::buffer_copy(
+            buffers, net::const_buffer(buf_, n_));
+        n_ -= static_cast<char>(bytes_transferred);
+        std::memmove(
+            buf_,
+            buf_ + bytes_transferred,
+            sizeof(buf_) - bytes_transferred);
+    }
+    else
+    {
+        bytes_transferred =
+            next_layer().read_some(buffers, ec);
+    }
+    return bytes_transferred;
+}
+
+template<class NextLayer>
+template<
+    class MutableBufferSequence,
+    class ReadHandler>
+BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
+icy_stream<NextLayer>::
+async_read_some(
+    MutableBufferSequence const& buffers,
+    ReadHandler&& handler)
+{
+    static_assert(is_async_read_stream<next_layer_type>::value,
+        "AsyncReadStream type requirements not met");
+    static_assert(net::is_mutable_buffer_sequence<
+            MutableBufferSequence >::value,
+        "MutableBufferSequence type requirements not met");
+    return net::async_initiate<
+        ReadHandler,
+        void(error_code, std::size_t)>(
+            typename ops::run_read_op{},
+            handler,
+            this,
+            buffers);
+}
+
+template<class NextLayer>
+template<class MutableBufferSequence>
+std::size_t
+icy_stream<NextLayer>::
+write_some(MutableBufferSequence const& buffers)
+{
+    static_assert(is_sync_write_stream<next_layer_type>::value,
+        "SyncWriteStream type requirements not met");
+    static_assert(net::is_const_buffer_sequence<
+        MutableBufferSequence>::value,
+            "MutableBufferSequence type requirements not met");
+    return stream_.write_some(buffers);
+}
+
+template<class NextLayer>
+template<class MutableBufferSequence>
+std::size_t
+icy_stream<NextLayer>::
+write_some(MutableBufferSequence const& buffers, error_code& ec)
+{
+    static_assert(is_sync_write_stream<next_layer_type>::value,
+        "SyncWriteStream type requirements not met");
+    static_assert(net::is_const_buffer_sequence<
+        MutableBufferSequence>::value,
+            "MutableBufferSequence type requirements not met");
+    return stream_.write_some(buffers, ec);
+}
+
+template<class NextLayer>
+template<
+    class MutableBufferSequence,
+    class WriteHandler>
+BOOST_BEAST_ASYNC_RESULT2(WriteHandler)
+icy_stream<NextLayer>::
+async_write_some(
+    MutableBufferSequence const& buffers,
+    WriteHandler&& handler)
+{
+    static_assert(is_async_write_stream<next_layer_type>::value,
+        "AsyncWriteStream type requirements not met");
+    static_assert(net::is_const_buffer_sequence<
+            MutableBufferSequence>::value,
+        "MutableBufferSequence type requirements not met");
+    return stream_.async_write_some(
+        buffers, std::forward<WriteHandler>(handler));
+}
+
+} // http
+} // beast
+} // boost
+
+#endif