159 lines
4.4 KiB
C++
159 lines
4.4 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (C) Copyright Ion Gaztanaga 2015-2015. 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)
|
|
//
|
|
// See http://www.boost.org/libs/container for documentation.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER
|
|
#define BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER
|
|
|
|
#ifndef BOOST_CONFIG_HPP
|
|
# include <boost/config.hpp>
|
|
#endif
|
|
|
|
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
|
# pragma once
|
|
#endif
|
|
|
|
|
|
#include <boost/container/detail/config_begin.hpp>
|
|
#include <boost/container/detail/workaround.hpp>
|
|
#include <boost/container/container_fwd.hpp>
|
|
#include <boost/container/pmr/memory_resource.hpp>
|
|
#include <boost/container/throw_exception.hpp>
|
|
#include <boost/container/detail/placement_new.hpp>
|
|
|
|
#include <boost/move/detail/type_traits.hpp>
|
|
#include <boost/intrusive/linear_slist_algorithms.hpp>
|
|
#include <boost/assert.hpp>
|
|
|
|
#include <cstddef>
|
|
|
|
namespace boost {
|
|
namespace container {
|
|
namespace pmr {
|
|
|
|
struct slist_node
|
|
{
|
|
slist_node *next;
|
|
};
|
|
|
|
struct slist_node_traits
|
|
{
|
|
typedef slist_node node;
|
|
typedef slist_node* node_ptr;
|
|
typedef const slist_node* const_node_ptr;
|
|
|
|
static node_ptr get_next(const_node_ptr n)
|
|
{ return n->next; }
|
|
|
|
static void set_next(const node_ptr & n, const node_ptr & next)
|
|
{ n->next = next; }
|
|
};
|
|
|
|
struct block_slist_header
|
|
: public slist_node
|
|
{
|
|
std::size_t size;
|
|
};
|
|
|
|
typedef bi::linear_slist_algorithms<slist_node_traits> slist_algo;
|
|
|
|
template<class DerivedFromBlockSlistHeader = block_slist_header>
|
|
class block_slist_base
|
|
{
|
|
slist_node m_slist;
|
|
|
|
static const std::size_t MaxAlignMinus1 = memory_resource::max_align-1u;
|
|
|
|
public:
|
|
|
|
static const std::size_t header_size = std::size_t(sizeof(DerivedFromBlockSlistHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1);
|
|
|
|
explicit block_slist_base()
|
|
{ slist_algo::init_header(&m_slist); }
|
|
|
|
#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
|
|
block_slist_base(const block_slist_base&) = delete;
|
|
block_slist_base operator=(const block_slist_base&) = delete;
|
|
#else
|
|
private:
|
|
block_slist_base (const block_slist_base&);
|
|
block_slist_base operator=(const block_slist_base&);
|
|
public:
|
|
#endif
|
|
|
|
~block_slist_base()
|
|
{}
|
|
|
|
void *allocate(std::size_t size, memory_resource &mr)
|
|
{
|
|
if((size_t(-1) - header_size) < size)
|
|
throw_bad_alloc();
|
|
void *p = mr.allocate(size+header_size);
|
|
block_slist_header &mb = *::new((void*)p, boost_container_new_t()) DerivedFromBlockSlistHeader;
|
|
mb.size = size+header_size;
|
|
slist_algo::link_after(&m_slist, &mb);
|
|
return (char *)p + header_size;
|
|
}
|
|
|
|
void release(memory_resource &mr) BOOST_NOEXCEPT
|
|
{
|
|
slist_node *n = slist_algo::node_traits::get_next(&m_slist);
|
|
while(n){
|
|
DerivedFromBlockSlistHeader &d = static_cast<DerivedFromBlockSlistHeader&>(*n);
|
|
n = slist_algo::node_traits::get_next(n);
|
|
std::size_t size = d.block_slist_header::size;
|
|
d.~DerivedFromBlockSlistHeader();
|
|
mr.deallocate(reinterpret_cast<char*>(&d), size, memory_resource::max_align);
|
|
}
|
|
slist_algo::init_header(&m_slist);
|
|
}
|
|
};
|
|
|
|
class block_slist
|
|
: public block_slist_base<>
|
|
{
|
|
memory_resource &m_upstream_rsrc;
|
|
|
|
public:
|
|
|
|
explicit block_slist(memory_resource &upstream_rsrc)
|
|
: block_slist_base<>(), m_upstream_rsrc(upstream_rsrc)
|
|
{}
|
|
|
|
#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
|
|
block_slist(const block_slist&) = delete;
|
|
block_slist operator=(const block_slist&) = delete;
|
|
#else
|
|
private:
|
|
block_slist (const block_slist&);
|
|
block_slist operator=(const block_slist&);
|
|
public:
|
|
#endif
|
|
|
|
~block_slist()
|
|
{ this->release(); }
|
|
|
|
void *allocate(std::size_t size)
|
|
{ return this->block_slist_base<>::allocate(size, m_upstream_rsrc); }
|
|
|
|
void release() BOOST_NOEXCEPT
|
|
{ return this->block_slist_base<>::release(m_upstream_rsrc); }
|
|
|
|
memory_resource& upstream_resource() const BOOST_NOEXCEPT
|
|
{ return m_upstream_rsrc; }
|
|
};
|
|
|
|
} //namespace pmr {
|
|
} //namespace container {
|
|
} //namespace boost {
|
|
|
|
#include <boost/container/detail/config_end.hpp>
|
|
|
|
#endif //BOOST_CONTAINER_DETAIL_BLOCK_SLIST_HEADER
|