buffers_adapter.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_BUFFERS_ADAPTER_HPP
#define BOOST_BEAST_BUFFERS_ADAPTER_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/core/type_traits.hpp>
#include <boost/asio/buffer.hpp>
#include <type_traits>

namespace boost {
namespace beast {

template<class MutableBufferSequence>
class buffers_adapter
{
    static_assert(is_mutable_buffer_sequence<MutableBufferSequence>::value,
        "MutableBufferSequence requirements not met");

    using iter_type = typename MutableBufferSequence::const_iterator;

    MutableBufferSequence bs_;
    iter_type begin_;
    iter_type out_;
    iter_type end_;
    std::size_t max_size_;
    std::size_t in_pos_ = 0;    // offset in *begin_
    std::size_t in_size_ = 0;   // size of input sequence
    std::size_t out_pos_ = 0;   // offset in *out_
    std::size_t out_end_ = 0;   // output end offset

    template<class Deduced>
    buffers_adapter(Deduced&& other,
        std::size_t nbegin, std::size_t nout,
            std::size_t nend)
        : bs_(std::forward<Deduced>(other).bs_)
        , begin_(std::next(bs_.begin(), nbegin))
        , out_(std::next(bs_.begin(), nout))
        , end_(std::next(bs_.begin(), nend))
        , max_size_(other.max_size_)
        , in_pos_(other.in_pos_)
        , in_size_(other.in_size_)
        , out_pos_(other.out_pos_)
        , out_end_(other.out_end_)
    {
    }

public:
#if BOOST_BEAST_DOXYGEN
    using const_buffers_type = implementation_defined;

    using mutable_buffers_type = implementation_defined;

#else
    class const_buffers_type;

    class mutable_buffers_type;

#endif

    buffers_adapter(buffers_adapter&& other);

    buffers_adapter(buffers_adapter const& other);

    buffers_adapter& operator=(buffers_adapter&& other);

    buffers_adapter& operator=(buffers_adapter const&);

    explicit
    buffers_adapter(MutableBufferSequence const& buffers);

    std::size_t
    max_size() const
    {
        return max_size_;
    }

    std::size_t
    size() const
    {
        return in_size_;
    }
    
    std::size_t
    capacity() const
    {
        return max_size_;
    }

    mutable_buffers_type
    prepare(std::size_t n);

    void
    commit(std::size_t n);

    const_buffers_type
    data() const;

    void
    consume(std::size_t n);
};

} // beast
} // boost

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

#endif