FM / http

/usr/include/boost/beast/_experimental/http/

/usr/include/boost/beast/_experimental/http

Name	Size	Mode	Actions
impl/	-	0755	rm
icy_stream.hpp	11238	0644	edit dl rm

Edit: /usr/include/boost/beast/_experimental/http/icy_stream.hpp (11238B)

//
// 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 SyncStream concept.
 For asynchronous operations, the type must support the
 AsyncStream concept.

@note A stream object must not be moved or destroyed while there
    are pending asynchronous operations associated with it.

@par Concepts
 AsyncStream, SyncStream
*/
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.

@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
        Regardless of whether the asynchronous operation completes
        immediately or not, the handler will not be invoked from within
        this function. Invocation of the handler will be performed in a
        manner 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);

@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
 Regardless of whether the asynchronous operation completes
 immediately or not, the handler will not be invoked from within
 this function. Invocation of the handler will be performed in a
 manner 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

cmd: