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_STATIC_BUFFER_HPP
#define BOOST_BEAST_STATIC_BUFFER_HPP

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

namespace boost {
namespace beast {

class static_buffer_base
{
    char* begin_;
    std::size_t in_off_ = 0;
    std::size_t in_size_ = 0;
    std::size_t out_size_ = 0;
    std::size_t capacity_;

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

public:
    using const_buffers_type =
        std::array<boost::asio::mutable_buffer, 2>;

    using mutable_buffers_type =
        std::array<boost::asio::mutable_buffer, 2>;

    static_buffer_base(void* p, std::size_t size);

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

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

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

    const_buffers_type
    data() const;

    mutable_buffers_type
    prepare(std::size_t size);

    void
    commit(std::size_t size);

    void
    consume(std::size_t size);

protected:
    static_buffer_base();

    void
    reset(void* p, std::size_t size);
};

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

template<std::size_t N>
class static_buffer : public static_buffer_base
{
    char buf_[N];

public:
    static_buffer(static_buffer const&);

    static_buffer()
        : static_buffer_base(buf_, N)
    {
    }

    static_buffer& operator=(static_buffer const&);

    static_buffer_base&
    base()
    {
        return *this;
    }

    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/static_buffer.ipp>

#endif