/* Copyright 2003-2008 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_COPY_MAP_HPP | |
#define BOOST_MULTI_INDEX_DETAIL_COPY_MAP_HPP | |
#if defined(_MSC_VER)&&(_MSC_VER>=1200) | |
#pragma once | |
#endif | |
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */ | |
#include <algorithm> | |
#include <boost/detail/no_exceptions_support.hpp> | |
#include <boost/multi_index/detail/auto_space.hpp> | |
#include <boost/multi_index/detail/prevent_eti.hpp> | |
#include <boost/noncopyable.hpp> | |
#include <cstddef> | |
#include <functional> | |
namespace boost{ | |
namespace multi_index{ | |
namespace detail{ | |
/* copy_map is used as an auxiliary structure during copy_() operations. | |
* When a container with n nodes is replicated, node_map holds the pairings | |
* between original and copied nodes, and provides a fast way to find a | |
* copied node from an original one. | |
* The semantics of the class are not simple, and no attempt has been made | |
* to enforce it: multi_index_container handles it right. On the other hand, | |
* the const interface, which is the one provided to index implementations, | |
* only allows for: | |
* - Enumeration of pairs of (original,copied) nodes (excluding the headers), | |
* - fast retrieval of copied nodes (including the headers.) | |
*/ | |
template <typename Node> | |
struct copy_map_entry | |
{ | |
copy_map_entry(Node* f,Node* s):first(f),second(s){} | |
Node* first; | |
Node* second; | |
bool operator<(const copy_map_entry<Node>& x)const | |
{ | |
return std::less<Node*>()(first,x.first); | |
} | |
}; | |
template <typename Node,typename Allocator> | |
class copy_map:private noncopyable | |
{ | |
public: | |
typedef const copy_map_entry<Node>* const_iterator; | |
copy_map( | |
const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy): | |
al_(al),size_(size),spc(al_,size_),n(0), | |
header_org_(header_org),header_cpy_(header_cpy),released(false) | |
{} | |
~copy_map() | |
{ | |
if(!released){ | |
for(std::size_t i=0;i<n;++i){ | |
boost::detail::allocator::destroy(&(spc.data()+i)->second->value()); | |
deallocate((spc.data()+i)->second); | |
} | |
} | |
} | |
const_iterator begin()const{return &*spc.data();} | |
const_iterator end()const{return &*(spc.data()+n);} | |
void clone(Node* node) | |
{ | |
(spc.data()+n)->first=node; | |
(spc.data()+n)->second=&*al_.allocate(1); | |
BOOST_TRY{ | |
boost::detail::allocator::construct( | |
&(spc.data()+n)->second->value(),node->value()); | |
} | |
BOOST_CATCH(...){ | |
deallocate((spc.data()+n)->second); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
++n; | |
if(n==size_)std::sort(&*spc.data(),&*spc.data()+size_); | |
} | |
Node* find(Node* node)const | |
{ | |
if(node==header_org_)return header_cpy_; | |
return std::lower_bound( | |
begin(),end(),copy_map_entry<Node>(node,0))->second; | |
} | |
void release() | |
{ | |
released=true; | |
} | |
private: | |
typedef typename prevent_eti< | |
Allocator, | |
typename boost::detail::allocator::rebind_to< | |
Allocator,Node>::type | |
>::type allocator_type; | |
typedef typename allocator_type::pointer allocator_pointer; | |
allocator_type al_; | |
std::size_t size_; | |
auto_space<copy_map_entry<Node>,Allocator> spc; | |
std::size_t n; | |
Node* header_org_; | |
Node* header_cpy_; | |
bool released; | |
void deallocate(Node* node) | |
{ | |
al_.deallocate(static_cast<allocator_pointer>(node),1); | |
} | |
}; | |
} /* namespace multi_index::detail */ | |
} /* namespace multi_index */ | |
} /* namespace boost */ | |
#endif |