flat_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_BUFFER_HPP
#define BOOST_BEAST_FLAT_BUFFER_HPP

#include <boost/beast/config.hpp>
#include <boost/beast/core/detail/allocator.hpp>
#include <boost/beast/core/detail/empty_base_optimization.hpp>
#include <boost/asio/buffer.hpp>
#include <limits>
#include <memory>

namespace boost {
namespace beast {

template<class Allocator>
class basic_flat_buffer
#if ! BOOST_BEAST_DOXYGEN
    : private detail::empty_base_optimization<
        typename detail::allocator_traits<Allocator>::
            template rebind_alloc<char>>
#endif
{
    enum
    {
        min_size = 512
    };

    template<class OtherAlloc>
    friend class basic_flat_buffer;

    using base_alloc_type = typename
        detail::allocator_traits<Allocator>::
            template rebind_alloc<char>;

    using alloc_traits =
        detail::allocator_traits<base_alloc_type>;

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

    char* begin_;
    char* in_;
    char* out_;
    char* last_;
    char* end_;
    std::size_t max_;

public:
    using allocator_type = Allocator;

    using const_buffers_type = boost::asio::mutable_buffers_1;

    using mutable_buffers_type = boost::asio::mutable_buffers_1;

    ~basic_flat_buffer();

    basic_flat_buffer();

    explicit
    basic_flat_buffer(std::size_t limit);

    explicit
    basic_flat_buffer(Allocator const& alloc);

    basic_flat_buffer(
        std::size_t limit, Allocator const& alloc);

    basic_flat_buffer(basic_flat_buffer&& other);

    basic_flat_buffer(
        basic_flat_buffer&& other, Allocator const& alloc);

    basic_flat_buffer(basic_flat_buffer const& other);

    basic_flat_buffer(basic_flat_buffer const& other,
        Allocator const& alloc);

    template<class OtherAlloc>
    basic_flat_buffer(
        basic_flat_buffer<OtherAlloc> const& other);

    template<class OtherAlloc>
    basic_flat_buffer(
        basic_flat_buffer<OtherAlloc> const& other,
            Allocator const& alloc);

    basic_flat_buffer&
    operator=(basic_flat_buffer&& other);

    basic_flat_buffer&
    operator=(basic_flat_buffer const& other);

    template<class OtherAlloc>
    basic_flat_buffer&
    operator=(basic_flat_buffer<OtherAlloc> const& other);

    allocator_type
    get_allocator() const
    {
        return this->member();
    }

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

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

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

    const_buffers_type
    data() const
    {
        return {in_, dist(in_, out_)};
    }

    mutable_buffers_type
    prepare(std::size_t n);

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

    void
    consume(std::size_t n);

    void
    shrink_to_fit();

    template<class Alloc>
    friend
    void
    swap(
        basic_flat_buffer<Alloc>& lhs,
        basic_flat_buffer<Alloc>& rhs);

private:
    void
    reset();

    template<class DynamicBuffer>
    void
    copy_from(DynamicBuffer const& other);

    void
    move_assign(basic_flat_buffer&, std::true_type);

    void
    move_assign(basic_flat_buffer&, std::false_type);

    void
    copy_assign(basic_flat_buffer const&, std::true_type);

    void
    copy_assign(basic_flat_buffer const&, std::false_type);

    void
    swap(basic_flat_buffer&);

    void
    swap(basic_flat_buffer&, std::true_type);

    void
    swap(basic_flat_buffer&, std::false_type);
};

using flat_buffer =
    basic_flat_buffer<std::allocator<char>>;

} // beast
} // boost

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

#endif