flat_static_buffer.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_FLAT_STATIC_BUFFER_HPP
#define BOOST_BEAST_FLAT_STATIC_BUFFER_HPP

#include <boost/beast/config.hpp>
#include <boost/asio/buffer.hpp>
#include <algorithm>
#include <cstddef>
#include <cstring>

namespace boost {
namespace beast {

class flat_static_buffer_base
{
    char* begin_;
    char* in_;
    char* out_;
    char* last_;
    char* end_;

    flat_static_buffer_base(flat_static_buffer_base const& other) = delete;
    flat_static_buffer_base& operator=(flat_static_buffer_base const&) = delete;

public:
    using const_buffers_type = boost::asio::mutable_buffers_1;

    using mutable_buffers_type = boost::asio::mutable_buffers_1;

    flat_static_buffer_base(void* p, std::size_t n)
    {
        reset_impl(p, n);
    }

    std::size_t
    size() const
    {
        return out_ - in_;
    }

    std::size_t
    max_size() const
    {
        return dist(begin_, end_);
    }

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

    const_buffers_type
    data() const;

    void
    reset();

    mutable_buffers_type
    prepare(std::size_t n);

    void
    commit(std::size_t n)
    {
        out_ += std::min<std::size_t>(n, last_ - out_);
    }

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

protected:
    flat_static_buffer_base() = default;

    void
    reset(void* p, std::size_t n);

private:
    static
    inline
    std::size_t
    dist(char const* first, char const* last)
    {
        return static_cast<std::size_t>(last - first);
    }

    template<class = void>
    void
    reset_impl();

    template<class = void>
    void
    reset_impl(void* p, std::size_t n);

    template<class = void>
    mutable_buffers_type
    prepare_impl(std::size_t n);

    template<class = void>
    void
    consume_impl(std::size_t n);
};

//------------------------------------------------------------------------------

template<std::size_t N>
class flat_static_buffer : public flat_static_buffer_base
{
    char buf_[N];

public:
    flat_static_buffer(flat_static_buffer const&);

    flat_static_buffer()
        : flat_static_buffer_base(buf_, N)
    {
    }

    flat_static_buffer& operator=(flat_static_buffer const&);

    flat_static_buffer_base&
    base()
    {
        return *this;
    }

    flat_static_buffer_base const&
    base() const
    {
        return *this;
    }

    std::size_t constexpr
    max_size() const
    {
        return N;
    }

    std::size_t constexpr
    capacity() const
    {
        return N;
    }
};

} // beast
} // boost

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

#endif