//////////////////////////////////////////////////////////////////////////////
|
//
|
// (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_PMR_MEMORY_RESOURCE_HPP
|
#define BOOST_CONTAINER_PMR_MEMORY_RESOURCE_HPP
|
|
#if defined (_MSC_VER)
|
# pragma once
|
#endif
|
|
#include <boost/container/detail/config_begin.hpp>
|
#include <boost/container/detail/workaround.hpp>
|
#include <boost/container/container_fwd.hpp>
|
#include <boost/move/detail/type_traits.hpp>
|
#include <cstddef>
|
|
namespace boost {
|
namespace container {
|
namespace pmr {
|
|
//! The memory_resource class is an abstract interface to an
|
//! unbounded set of classes encapsulating memory resources.
|
class memory_resource
|
{
|
public:
|
// For exposition only
|
static BOOST_CONSTEXPR_OR_CONST std::size_t max_align =
|
boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
|
|
//! <b>Effects</b>: Destroys
|
//! this memory_resource.
|
virtual ~memory_resource(){}
|
|
//! <b>Effects</b>: Equivalent to
|
//! `return do_allocate(bytes, alignment);`
|
void* allocate(std::size_t bytes, std::size_t alignment = max_align)
|
{ return this->do_allocate(bytes, alignment); }
|
|
//! <b>Effects</b>: Equivalent to
|
//! `return do_deallocate(bytes, alignment);`
|
void deallocate(void* p, std::size_t bytes, std::size_t alignment = max_align)
|
{ return this->do_deallocate(p, bytes, alignment); }
|
|
//! <b>Effects</b>: Equivalent to
|
//! `return return do_is_equal(other);`
|
bool is_equal(const memory_resource& other) const BOOST_NOEXCEPT
|
{ return this->do_is_equal(other); }
|
|
#if !defined(BOOST_EMBTC)
|
|
//! <b>Returns</b>:
|
//! `&a == &b || a.is_equal(b)`.
|
friend bool operator==(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
|
{ return &a == &b || a.is_equal(b); }
|
|
//! <b>Returns</b>:
|
//! !(a == b).
|
friend bool operator!=(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
|
{ return !(a == b); }
|
|
#else
|
|
//! <b>Returns</b>:
|
//! `&a == &b || a.is_equal(b)`.
|
friend bool operator==(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT;
|
|
//! <b>Returns</b>:
|
//! !(a == b).
|
friend bool operator!=(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT;
|
|
#endif
|
|
protected:
|
//! <b>Requires</b>: Alignment shall be a power of two.
|
//!
|
//! <b>Returns</b>: A derived class shall implement this function to return a pointer
|
//! to allocated storage with a size of at least bytes. The returned storage is
|
//! aligned to the specified alignment, if such alignment is supported; otherwise
|
//! it is aligned to max_align.
|
//!
|
//! <b>Throws</b>: A derived class implementation shall throw an appropriate exception if
|
//! it is unable to allocate memory with the requested size and alignment.
|
virtual void* do_allocate(std::size_t bytes, std::size_t alignment) = 0;
|
|
//! <b>Requires</b>: p shall have been returned from a prior call to
|
//! `allocate(bytes, alignment)` on a memory resource equal to *this, and the storage
|
//! at p shall not yet have been deallocated.
|
//!
|
//! <b>Effects</b>: A derived class shall implement this function to dispose of allocated storage.
|
//!
|
//! <b>Throws</b>: Nothing.
|
virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) = 0;
|
|
//! <b>Returns</b>: A derived class shall implement this function to return true if memory
|
//! allocated from this can be deallocated from other and vice-versa; otherwise it shall
|
//! return false. <i>[Note: The most-derived type of other might not match the type of this.
|
//! For a derived class, D, a typical implementation of this function will compute
|
//! `dynamic_cast<const D*>(&other)` and go no further (i.e., return false)
|
//! if it returns nullptr. - end note]</i>.
|
virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT = 0;
|
};
|
|
#if defined(BOOST_EMBTC)
|
|
//! <b>Returns</b>:
|
//! `&a == &b || a.is_equal(b)`.
|
inline bool operator==(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
|
{ return &a == &b || a.is_equal(b); }
|
|
//! <b>Returns</b>:
|
//! !(a == b).
|
inline bool operator!=(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
|
{ return !(a == b); }
|
|
#endif
|
|
} //namespace pmr {
|
} //namespace container {
|
} //namespace boost {
|
|
#include <boost/container/detail/config_end.hpp>
|
|
#endif //BOOST_CONTAINER_PMR_MEMORY_RESOURCE_HPP
|
