buffered_read_stream.hpp

Go to the documentation of this file.

//
// Copyright (c) 2016-2017 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_BUFFERED_READ_STREAM_HPP
#define BOOST_BEAST_BUFFERED_READ_STREAM_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/core/async_result.hpp>
#include <boost/beast/core/error.hpp>
#include <boost/beast/core/multi_buffer.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/io_service.hpp>
#include <cstdint>
#include <utility>

namespace boost {
namespace beast {

template<class Stream, class DynamicBuffer>
class buffered_read_stream
{
    static_assert(is_dynamic_buffer<DynamicBuffer>::value,
        "DynamicBuffer requirements not met");

    template<class Buffers, class Handler>
    class read_some_op;

    DynamicBuffer buffer_;
    std::size_t capacity_ = 0;
    Stream next_layer_;

public:
    using buffer_type = DynamicBuffer;

    using next_layer_type =
        typename std::remove_reference<Stream>::type;

    using lowest_layer_type =
        typename get_lowest_layer<next_layer_type>::type;

    buffered_read_stream(buffered_read_stream&&) = default;

    buffered_read_stream& operator=(buffered_read_stream&&) = default;

    template<class... Args>
    explicit
    buffered_read_stream(Args&&... args);

    next_layer_type&
    next_layer()
    {
        return next_layer_;
    }

    next_layer_type const&
    next_layer() const
    {
        return next_layer_;
    }
    
    lowest_layer_type&
    lowest_layer()
    {
        return next_layer_.lowest_layer();
    }

    lowest_layer_type const&
    lowest_layer() const
    {
        return next_layer_.lowest_layer();
    }

    boost::asio::io_service&
    get_io_service()
    {
        return next_layer_.get_io_service();
    }

    DynamicBuffer&
    buffer()
    {
        return buffer_;
    }

    DynamicBuffer const&
    buffer() const
    {
        return buffer_;
    }

    void
    capacity(std::size_t size)
    {
        capacity_ = size;
    }

    template<class MutableBufferSequence>
    std::size_t
    read_some(MutableBufferSequence const& buffers);

    template<class MutableBufferSequence>
    std::size_t
    read_some(MutableBufferSequence const& buffers,
        error_code& ec);

    template<class MutableBufferSequence, class ReadHandler>
#if BOOST_BEAST_DOXYGEN
    void_or_deduced
#else
    async_return_type<ReadHandler, void(error_code)>
#endif
    async_read_some(MutableBufferSequence const& buffers,
        ReadHandler&& handler);

    template<class ConstBufferSequence>
    std::size_t
    write_some(ConstBufferSequence const& buffers)
    {
        static_assert(is_sync_write_stream<next_layer_type>::value,
            "SyncWriteStream requirements not met");
        return next_layer_.write_some(buffers);
    }

    template<class ConstBufferSequence>
    std::size_t
    write_some(ConstBufferSequence const& buffers,
        error_code& ec)
    {
        static_assert(is_sync_write_stream<next_layer_type>::value,
            "SyncWriteStream requirements not met");
        return next_layer_.write_some(buffers, ec);
    }

    template<class ConstBufferSequence, class WriteHandler>
#if BOOST_BEAST_DOXYGEN
    void_or_deduced
#else
    async_return_type<WriteHandler, void(error_code)>
#endif
    async_write_some(ConstBufferSequence const& buffers,
        WriteHandler&& handler);
};

} // beast
} // boost

#include <boost/beast/core/impl/buffered_read_stream.ipp>

#endif