/* Copyright 2003-2020 Joaquin M Lopez Munoz.
|
* 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/multi_index for library home page.
|
*/
|
|
#ifndef BOOST_MULTI_INDEX_DETAIL_NODE_HANDLE_HPP
|
#define BOOST_MULTI_INDEX_DETAIL_NODE_HANDLE_HPP
|
|
#if defined(_MSC_VER)
|
#pragma once
|
#endif
|
|
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
|
#include <algorithm>
|
#include <boost/core/addressof.hpp>
|
#include <boost/detail/workaround.hpp>
|
#include <boost/move/core.hpp>
|
#include <boost/move/utility_core.hpp>
|
#include <boost/multi_index_container_fwd.hpp>
|
#include <boost/multi_index/detail/allocator_traits.hpp>
|
#include <boost/type_traits/aligned_storage.hpp>
|
#include <boost/type_traits/alignment_of.hpp>
|
#include <new>
|
|
namespace boost{
|
|
namespace multi_index{
|
|
namespace detail{
|
|
/* Node handle template class following [container.node] specs.
|
*/
|
|
#include <boost/multi_index/detail/define_if_constexpr_macro.hpp>
|
|
template<typename Node,typename Allocator>
|
class node_handle
|
{
|
public:
|
typedef typename Node::value_type value_type;
|
typedef Allocator allocator_type;
|
|
private:
|
typedef allocator_traits<allocator_type> alloc_traits;
|
|
public:
|
node_handle()BOOST_NOEXCEPT:node(0){}
|
|
node_handle(BOOST_RV_REF(node_handle) x)BOOST_NOEXCEPT:node(x.node)
|
{
|
if(!x.empty()){
|
move_construct_allocator(boost::move(x));
|
x.destroy_allocator();
|
x.node=0;
|
}
|
}
|
|
~node_handle()
|
{
|
if(!empty()){
|
delete_node();
|
destroy_allocator();
|
}
|
}
|
|
node_handle& operator=(BOOST_RV_REF(node_handle) x)
|
{
|
if(this!=&x){
|
if(!empty()){
|
delete_node();
|
if(!x.empty()){
|
BOOST_MULTI_INDEX_IF_CONSTEXPR(
|
alloc_traits::propagate_on_container_move_assignment::value){
|
move_assign_allocator(boost::move(x));
|
}
|
x.destroy_allocator();
|
}
|
else{
|
destroy_allocator();
|
}
|
}
|
else if(!x.empty()){
|
move_construct_allocator(boost::move(x));
|
x.destroy_allocator();
|
}
|
node=x.node;
|
x.node=0;
|
}
|
return *this;
|
}
|
|
value_type& value()const{return node->value();}
|
allocator_type get_allocator()const{return *allocator_ptr();}
|
|
#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
|
explicit
|
#endif
|
operator bool()const BOOST_NOEXCEPT{return (node!=0);}
|
|
#if BOOST_WORKAROUND(BOOST_GCC_VERSION,>=70000)&&__cplusplus<201103L
|
/* https://github.com/boostorg/config/issues/336 */
|
#else
|
BOOST_ATTRIBUTE_NODISCARD
|
#endif
|
bool empty()const BOOST_NOEXCEPT{return (node==0);}
|
|
void swap(node_handle& x)
|
BOOST_NOEXCEPT_IF(
|
alloc_traits::propagate_on_container_swap::value||
|
alloc_traits::is_always_equal::value)
|
{
|
if(!empty()){
|
if(!x.empty()){
|
BOOST_MULTI_INDEX_IF_CONSTEXPR(
|
alloc_traits::propagate_on_container_swap::value){
|
using std::swap;
|
swap(*allocator_ptr(),*x.allocator_ptr());
|
}
|
}
|
else{
|
x.move_construct_allocator(boost::move(*this));
|
destroy_allocator();
|
}
|
}
|
else if(!x.empty()){
|
move_construct_allocator(boost::move(x));
|
x.destroy_allocator();
|
}
|
std::swap(node,x.node);
|
}
|
|
friend void swap(node_handle& x,node_handle& y)
|
BOOST_NOEXCEPT_IF(noexcept(x.swap(y)))
|
{
|
x.swap(y);
|
}
|
|
private:
|
BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle)
|
|
template <typename,typename,typename>
|
friend class boost::multi_index::multi_index_container;
|
|
node_handle(Node* node_,const allocator_type& al):node(node_)
|
{
|
::new (static_cast<void*>(allocator_ptr())) allocator_type(al);
|
}
|
|
void release_node()
|
{
|
if(!empty()){
|
node=0;
|
destroy_allocator();
|
}
|
}
|
|
#include <boost/multi_index/detail/ignore_wstrict_aliasing.hpp>
|
|
const allocator_type* allocator_ptr()const
|
{
|
return reinterpret_cast<const allocator_type*>(&space);
|
}
|
|
allocator_type* allocator_ptr()
|
{
|
return reinterpret_cast<allocator_type*>(&space);
|
}
|
|
#include <boost/multi_index/detail/restore_wstrict_aliasing.hpp>
|
|
void move_construct_allocator(BOOST_RV_REF(node_handle) x)
|
{
|
::new (static_cast<void*>(allocator_ptr()))
|
allocator_type(boost::move(*x.allocator_ptr()));
|
}
|
|
void move_assign_allocator(BOOST_RV_REF(node_handle) x)
|
{
|
*allocator_ptr()=boost::move(*x.allocator_ptr());
|
}
|
|
void destroy_allocator(){allocator_ptr()->~allocator_type();}
|
|
void delete_node()
|
{
|
typedef typename rebind_alloc_for<
|
allocator_type,Node
|
>::type node_allocator;
|
typedef detail::allocator_traits<node_allocator> node_alloc_traits;
|
typedef typename node_alloc_traits::pointer node_pointer;
|
|
alloc_traits::destroy(*allocator_ptr(),boost::addressof(node->value()));
|
node_allocator nal(*allocator_ptr());
|
node_alloc_traits::deallocate(nal,static_cast<node_pointer>(node),1);
|
}
|
|
Node* node;
|
typename aligned_storage<
|
sizeof(allocator_type),
|
alignment_of<allocator_type>::value
|
>::type space;
|
};
|
|
#include <boost/multi_index/detail/undef_if_constexpr_macro.hpp>
|
|
/* node handle insert return type template class following
|
* [container.insert.return] specs.
|
*/
|
|
template<typename Iterator,typename NodeHandle>
|
struct insert_return_type
|
{
|
insert_return_type(
|
Iterator position_,bool inserted_,BOOST_RV_REF(NodeHandle) node_):
|
position(position_),inserted(inserted_),node(boost::move(node_)){}
|
insert_return_type(BOOST_RV_REF(insert_return_type) x):
|
position(x.position),inserted(x.inserted),node(boost::move(x.node)){}
|
|
insert_return_type& operator=(BOOST_RV_REF(insert_return_type) x)
|
{
|
position=x.position;
|
inserted=x.inserted;
|
node=boost::move(x.node);
|
return *this;
|
}
|
|
Iterator position;
|
bool inserted;
|
NodeHandle node;
|
|
private:
|
BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type)
|
};
|
|
} /* namespace multi_index::detail */
|
|
} /* namespace multi_index */
|
|
} /* namespace boost */
|
|
#endif
|
