Added thirdparty: boost library

thirdparty/include/boost/beast/_experimental/http/icy_stream.hpp

@@ -0,0 +1,329 @@
+//
+// 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_ICY_STREAM_HPP
+#define BOOST_BEAST_HTTP_ICY_STREAM_HPP
+
+#include <boost/beast/core/detail/config.hpp>
+#include <boost/beast/core/error.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/buffer.hpp>
+#include <boost/logic/tribool.hpp>
+#include <type_traits>
+
+namespace boost {
+namespace beast {
+namespace http {
+
+/** Stream wrapper to process Shoutcast HTTP responses
+
+    This wrapper replaces the word "ICY" in the first
+    HTTP response received on the connection, with "HTTP/1.1".
+    This allows the Beast parser to be used with Shoutcast
+    servers, which send a non-standard HTTP message as the
+    response.
+
+    For asynchronous operations, the application must ensure
+    that they are are all performed within the same implicit
+    or explicit strand.
+
+    @par Thread Safety
+    @e Distinct @e objects: Safe.@n
+    @e Shared @e objects: Unsafe.
+    The application must also ensure that all asynchronous
+    operations are performed within the same implicit or explicit strand.
+
+    @par Example
+    To use the @ref icy_stream template with an @ref tcp_stream
+    you would write:
+    @code
+    http::icy_stream<tcp_stream> is(ioc);
+    @endcode
+
+    @tparam NextLayer The type representing the next layer, to which
+    data will be read and written during operations. For synchronous
+    operations, the type must support the <em>SyncStream</em> concept.
+    For asynchronous operations, the type must support the
+    <em>AsyncStream</em> concept.
+
+    @note A stream object must not be moved or destroyed while there
+    are pending asynchronous operations associated with it.
+
+    @par Concepts
+    <em>AsyncStream</em>, <em>SyncStream</em>
+*/
+template<class NextLayer>
+class icy_stream
+{
+    NextLayer stream_;
+    char buf_[8];
+    unsigned char n_ = 0;
+    bool detect_ = true;
+
+    struct ops;
+
+    static
+    net::const_buffer
+    version()
+    {
+        return {"HTTP/1.1", 8};
+    }
+
+public:
+    /// The type of the next layer.
+    using next_layer_type =
+        typename std::remove_reference<NextLayer>::type;
+
+    /// The type of the executor associated with the object.
+    using executor_type = typename next_layer_type::executor_type;
+
+    icy_stream(icy_stream&&) = default;
+    icy_stream(icy_stream const&) = default;
+    icy_stream& operator=(icy_stream&&) = default;
+    icy_stream& operator=(icy_stream const&) = default;
+
+    /** Destructor
+
+        The treatment of pending operations will be the same as that
+        of the next layer.
+    */
+    ~icy_stream() = default;
+
+    /** Constructor
+
+        Arguments, if any, are forwarded to the next layer's constructor.
+    */
+    template<class... Args>
+    explicit
+    icy_stream(Args&&... args);
+
+    //--------------------------------------------------------------------------
+
+    /** Get the executor associated with the object.
+    
+        This function may be used to obtain the executor object that the
+        stream uses to dispatch handlers for asynchronous operations.
+
+        @return A copy of the executor that stream will use to dispatch handlers.
+    */
+    executor_type
+    get_executor() noexcept
+    {
+        return stream_.get_executor();
+    }
+
+    /** Get a reference to the next layer
+
+        This function returns a reference to the next layer
+        in a stack of stream layers.
+
+        @return A reference to the next layer in the stack of
+        stream layers.
+    */
+    next_layer_type&
+    next_layer()
+    {
+        return stream_;
+    }
+
+    /** Get a reference to the next layer
+
+        This function returns a reference to the next layer in a
+        stack of stream layers.
+
+        @return A reference to the next layer in the stack of
+        stream layers.
+    */
+    next_layer_type const&
+    next_layer() const
+    {
+        return stream_;
+    }
+
+    //--------------------------------------------------------------------------
+
+    /** Read some data from the stream.
+
+        This function is used to read data from the stream. The function call will
+        block until one or more bytes of data has been read successfully, or until
+        an error occurs.
+        
+        @param buffers The buffers into which the data will be read.
+        
+        @returns The number of bytes read.
+        
+        @throws system_error Thrown on failure.
+        
+        @note The `read_some` operation may not read all of the requested number of
+        bytes. Consider using the function `net::read` if you need to ensure
+        that the requested amount of data is read before the blocking operation
+        completes.
+    */
+    template<class MutableBufferSequence>
+    std::size_t
+    read_some(MutableBufferSequence const& buffers);
+
+    /** Read some data from the stream.
+
+        This function is used to read data from the stream. The function call will
+        block until one or more bytes of data has been read successfully, or until
+        an error occurs.
+        
+        @param buffers The buffers into which the data will be read.
+        
+        @param ec Set to indicate what error occurred, if any.
+
+        @returns The number of bytes read.
+                
+        @note The `read_some` operation may not read all of the requested number of
+        bytes. Consider using the function `net::read` if you need to ensure
+        that the requested amount of data is read before the blocking operation
+        completes.
+    */
+    template<class MutableBufferSequence>
+    std::size_t
+    read_some(
+        MutableBufferSequence const& buffers,
+        error_code& ec);
+
+    /** Start an asynchronous read.
+    
+        This function is used to asynchronously read one or more bytes of data from
+        the stream. The function call always returns immediately.
+        
+        @param buffers The buffers into which the data will be read. Although the
+        buffers object may be copied as necessary, ownership of the underlying
+        buffers is retained by the caller, which must guarantee that they remain
+        valid until the handler is called.
+
+        @param handler The completion handler to invoke when the operation
+        completes. The implementation takes ownership of the handler by
+        performing a decay-copy. The equivalent function signature of
+        the handler must be:
+        @code
+        void handler(
+          const boost::system::error_code& error, // Result of operation.
+          std::size_t bytes_transferred           // Number of bytes read.
+        );
+        @endcode
+        If the handler has an associated immediate executor,
+        an immediate completion will be dispatched to it.
+        Otherwise, the handler will not be invoked from within
+        this function. Invocation of the handler will be performed
+        by dispatching to the immediate executor. If no
+        immediate executor is specified, this is equivalent
+        to using `net::post`.
+        @note The `async_read_some` operation may not read all of the requested number of
+        bytes. Consider using the function `net::async_read` if you need
+        to ensure that the requested amount of data is read before the asynchronous
+        operation completes.
+    */
+    template<
+        class MutableBufferSequence,
+        BOOST_BEAST_ASYNC_TPARAM2 ReadHandler =
+            net::default_completion_token_t<executor_type>
+    >
+    BOOST_BEAST_ASYNC_RESULT2(ReadHandler)
+    async_read_some(
+        MutableBufferSequence const& buffers,
+        ReadHandler&& handler =
+            net::default_completion_token_t<executor_type>{});
+
+    /** Write some data to the stream.
+    
+        This function is used to write data on the stream. The function call will
+        block until one or more bytes of data has been written successfully, or
+        until an error occurs.
+        
+        @param buffers The data to be written.
+        
+        @returns The number of bytes written.
+        
+        @throws system_error Thrown on failure.
+        
+        @note The `write_some` operation may not transmit all of the data to the
+        peer. Consider using the function `net::write` if you need to
+        ensure that all data is written before the blocking operation completes.
+    */
+    template<class ConstBufferSequence>
+    std::size_t
+    write_some(ConstBufferSequence const& buffers);
+
+    /** Write some data to the stream.
+    
+        This function is used to write data on the stream. The function call will
+        block until one or more bytes of data has been written successfully, or
+        until an error occurs.
+        
+        @param buffers The data to be written.
+        
+        @param ec Set to indicate what error occurred, if any.
+
+        @returns The number of bytes written.
+                
+        @note The `write_some` operation may not transmit all of the data to the
+        peer. Consider using the function `net::write` if you need to
+        ensure that all data is written before the blocking operation completes.
+    */
+    template<class ConstBufferSequence>
+    std::size_t
+    write_some(
+        ConstBufferSequence const& buffers,
+        error_code& ec);
+
+    /** Start an asynchronous write.
+        
+        This function is used to asynchronously write one or more bytes of data to
+        the stream. The function call always returns immediately.
+        
+        @param buffers The data to be written to the stream. Although the buffers
+        object may be copied as necessary, ownership of the underlying buffers is
+        retained by the caller, which must guarantee that they remain valid until
+        the handler is called.
+        
+        @param handler The completion handler to invoke when the operation
+        completes. The implementation takes ownership of the handler by
+        performing a decay-copy. The equivalent function signature of
+        the handler must be:
+        @code
+        void handler(
+          error_code const& error,          // Result of operation.
+          std::size_t bytes_transferred     // Number of bytes written.
+        );
+        @endcode
+        If the handler has an associated immediate executor,
+        an immediate completion will be dispatched to it.
+        Otherwise, the handler will not be invoked from within
+        this function. Invocation of the handler will be performed
+        by dispatching to the immediate executor. If no
+        immediate executor is specified, this is equivalent
+        to using `net::post`.
+        @note The `async_write_some` operation may not transmit all of the data to
+        the peer. Consider using the function `net::async_write` if you need
+        to ensure that all data is written before the asynchronous operation completes.
+    */
+    template<
+        class ConstBufferSequence,
+        BOOST_BEAST_ASYNC_TPARAM2 WriteHandler =
+            net::default_completion_token_t<executor_type>
+    >
+    BOOST_BEAST_ASYNC_RESULT2(WriteHandler)
+    async_write_some(
+        ConstBufferSequence const& buffers,
+        WriteHandler&& handler =
+            net::default_completion_token_t<executor_type>{});
+};
+
+} // http
+} // beast
+} // boost
+
+#include <boost/beast/_experimental/http/impl/icy_stream.hpp>
+
+#endif