/* Multiply indexed container. | |
* | |
* Copyright 2003-2010 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_HPP | |
#define BOOST_MULTI_INDEX_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/allocator_utilities.hpp> | |
#include <boost/detail/no_exceptions_support.hpp> | |
#include <boost/detail/workaround.hpp> | |
#include <boost/mpl/at.hpp> | |
#include <boost/mpl/contains.hpp> | |
#include <boost/mpl/find_if.hpp> | |
#include <boost/mpl/identity.hpp> | |
#include <boost/mpl/int.hpp> | |
#include <boost/mpl/size.hpp> | |
#include <boost/mpl/deref.hpp> | |
#include <boost/multi_index_container_fwd.hpp> | |
#include <boost/multi_index/detail/access_specifier.hpp> | |
#include <boost/multi_index/detail/adl_swap.hpp> | |
#include <boost/multi_index/detail/base_type.hpp> | |
#include <boost/multi_index/detail/converter.hpp> | |
#include <boost/multi_index/detail/header_holder.hpp> | |
#include <boost/multi_index/detail/has_tag.hpp> | |
#include <boost/multi_index/detail/no_duplicate_tags.hpp> | |
#include <boost/multi_index/detail/prevent_eti.hpp> | |
#include <boost/multi_index/detail/safe_mode.hpp> | |
#include <boost/multi_index/detail/scope_guard.hpp> | |
#include <boost/static_assert.hpp> | |
#include <boost/type_traits/is_same.hpp> | |
#include <boost/utility/base_from_member.hpp> | |
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) | |
#include <boost/multi_index/detail/archive_constructed.hpp> | |
#include <boost/multi_index/detail/serialization_version.hpp> | |
#include <boost/serialization/collection_size_type.hpp> | |
#include <boost/serialization/nvp.hpp> | |
#include <boost/serialization/split_member.hpp> | |
#include <boost/serialization/version.hpp> | |
#include <boost/throw_exception.hpp> | |
#endif | |
#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) | |
#include <boost/multi_index/detail/invariant_assert.hpp> | |
#define BOOST_MULTI_INDEX_CHECK_INVARIANT \ | |
detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)= \ | |
detail::make_obj_guard(*this,&multi_index_container::check_invariant_); \ | |
BOOST_JOIN(check_invariant_,__LINE__).touch(); | |
#else | |
#define BOOST_MULTI_INDEX_CHECK_INVARIANT | |
#endif | |
namespace boost{ | |
namespace multi_index{ | |
template<typename Value,typename IndexSpecifierList,typename Allocator> | |
class multi_index_container: | |
private ::boost::base_from_member< | |
typename boost::detail::allocator::rebind_to< | |
Allocator, | |
typename detail::multi_index_node_type< | |
Value,IndexSpecifierList,Allocator>::type | |
>::type>, | |
BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder< | |
typename detail::prevent_eti< | |
Allocator, | |
typename boost::detail::allocator::rebind_to< | |
Allocator, | |
typename detail::multi_index_node_type< | |
Value,IndexSpecifierList,Allocator>::type | |
>::type | |
>::type::pointer, | |
multi_index_container<Value,IndexSpecifierList,Allocator> >, | |
public detail::multi_index_base_type< | |
Value,IndexSpecifierList,Allocator>::type | |
{ | |
#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ | |
BOOST_WORKAROUND(__MWERKS__,<=0x3003) | |
/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the | |
* lifetime of const references bound to temporaries --precisely what | |
* scopeguards are. | |
*/ | |
#pragma parse_mfunc_templ off | |
#endif | |
private: | |
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) | |
template <typename,typename,typename> friend class detail::index_base; | |
template <typename,typename> friend struct detail::header_holder; | |
template <typename,typename> friend struct detail::converter; | |
#endif | |
typedef typename detail::multi_index_base_type< | |
Value,IndexSpecifierList,Allocator>::type super; | |
typedef typename | |
boost::detail::allocator::rebind_to< | |
Allocator, | |
typename super::node_type | |
>::type node_allocator; | |
typedef ::boost::base_from_member< | |
node_allocator> bfm_allocator; | |
typedef detail::header_holder< | |
typename detail::prevent_eti< | |
Allocator, | |
node_allocator | |
>::type::pointer, | |
multi_index_container> bfm_header; | |
#if BOOST_WORKAROUND(BOOST_MSVC,<1300) | |
/* see definition of index_type_list below */ | |
typedef typename super::index_type_list super_index_type_list; | |
#endif | |
public: | |
/* All types are inherited from super, a few are explicitly | |
* brought forward here to save us some typename's. | |
*/ | |
typedef typename super::ctor_args_list ctor_args_list; | |
typedef IndexSpecifierList index_specifier_type_list; | |
#if BOOST_WORKAROUND(BOOST_MSVC,<1300) | |
/* MSVC++ 6.0 chokes on moderately long index lists (around 6 indices | |
* or more), with errors ranging from corrupt exes to duplicate | |
* comdats. The following type hiding hack alleviates this condition; | |
* best results combined with type hiding of the indexed_by construct | |
* itself, as explained in the "Compiler specifics" section of | |
* the documentation. | |
*/ | |
struct index_type_list:super_index_type_list | |
{ | |
typedef index_type_list type; | |
typedef typename super_index_type_list::back back; | |
typedef mpl::v_iter<type,0> begin; | |
typedef mpl::v_iter< | |
type, | |
mpl::size<super_index_type_list>::value> end; | |
}; | |
#else | |
typedef typename super::index_type_list index_type_list; | |
#endif | |
typedef typename super::iterator_type_list iterator_type_list; | |
typedef typename super::const_iterator_type_list const_iterator_type_list; | |
typedef typename super::value_type value_type; | |
typedef typename super::final_allocator_type allocator_type; | |
typedef typename super::iterator iterator; | |
typedef typename super::const_iterator const_iterator; | |
BOOST_STATIC_ASSERT( | |
detail::no_duplicate_tags_in_index_list<index_type_list>::value); | |
/* global project() needs to see this publicly */ | |
typedef typename super::node_type node_type; | |
/* construct/copy/destroy */ | |
explicit multi_index_container( | |
#if BOOST_WORKAROUND(__IBMCPP__,<=600) | |
/* VisualAge seems to have an ETI issue with the default values | |
* for arguments args_list and al. | |
*/ | |
const ctor_args_list& args_list= | |
typename mpl::identity<multi_index_container>::type:: | |
ctor_args_list(), | |
const allocator_type& al= | |
typename mpl::identity<multi_index_container>::type:: | |
allocator_type()): | |
#else | |
const ctor_args_list& args_list=ctor_args_list(), | |
const allocator_type& al=allocator_type()): | |
#endif | |
bfm_allocator(al), | |
super(args_list,bfm_allocator::member), | |
node_count(0) | |
{ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
} | |
explicit multi_index_container(const allocator_type& al): | |
bfm_allocator(al), | |
super(ctor_args_list(),bfm_allocator::member), | |
node_count(0) | |
{ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
} | |
template<typename InputIterator> | |
multi_index_container( | |
InputIterator first,InputIterator last, | |
#if BOOST_WORKAROUND(__IBMCPP__,<=600) | |
/* VisualAge seems to have an ETI issue with the default values | |
* for arguments args_list and al. | |
*/ | |
const ctor_args_list& args_list= | |
typename mpl::identity<multi_index_container>::type:: | |
ctor_args_list(), | |
const allocator_type& al= | |
typename mpl::identity<multi_index_container>::type:: | |
allocator_type()): | |
#else | |
const ctor_args_list& args_list=ctor_args_list(), | |
const allocator_type& al=allocator_type()): | |
#endif | |
bfm_allocator(al), | |
super(args_list,bfm_allocator::member), | |
node_count(0) | |
{ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
BOOST_TRY{ | |
iterator hint=super::end(); | |
for(;first!=last;++first){ | |
hint=super::make_iterator(insert_(*first,hint.get_node()).first); | |
} | |
} | |
BOOST_CATCH(...){ | |
clear_(); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
multi_index_container( | |
const multi_index_container<Value,IndexSpecifierList,Allocator>& x): | |
bfm_allocator(x.bfm_allocator::member), | |
bfm_header(), | |
super(x), | |
node_count(0) | |
{ | |
copy_map_type map(bfm_allocator::member,x.size(),x.header(),header()); | |
for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){ | |
map.clone(it.get_node()); | |
} | |
super::copy_(x,map); | |
map.release(); | |
node_count=x.size(); | |
/* Not until this point are the indices required to be consistent, | |
* hence the position of the invariant checker. | |
*/ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
} | |
~multi_index_container() | |
{ | |
delete_all_nodes_(); | |
} | |
multi_index_container<Value,IndexSpecifierList,Allocator>& operator=( | |
multi_index_container<Value,IndexSpecifierList,Allocator> x) | |
{ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
this->swap(x); | |
return *this; | |
} | |
allocator_type get_allocator()const | |
{ | |
return allocator_type(bfm_allocator::member); | |
} | |
/* retrieval of indices by number */ | |
#if !defined(BOOST_NO_MEMBER_TEMPLATES) | |
template<int N> | |
struct nth_index | |
{ | |
BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value); | |
typedef typename mpl::at_c<index_type_list,N>::type type; | |
}; | |
template<int N> | |
typename nth_index<N>::type& get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value); | |
return *this; | |
} | |
template<int N> | |
const typename nth_index<N>::type& get( | |
BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const | |
{ | |
BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value); | |
return *this; | |
} | |
#endif | |
/* retrieval of indices by tag */ | |
#if !defined(BOOST_NO_MEMBER_TEMPLATES) | |
template<typename Tag> | |
struct index | |
{ | |
typedef typename mpl::find_if< | |
index_type_list, | |
detail::has_tag<Tag> | |
>::type iter; | |
BOOST_STATIC_CONSTANT( | |
bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)); | |
BOOST_STATIC_ASSERT(index_found); | |
typedef typename mpl::deref<iter>::type type; | |
}; | |
template<typename Tag> | |
typename index<Tag>::type& get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
return *this; | |
} | |
template<typename Tag> | |
const typename index<Tag>::type& get( | |
BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))const | |
{ | |
return *this; | |
} | |
#endif | |
/* projection of iterators by number */ | |
#if !defined(BOOST_NO_MEMBER_TEMPLATES) | |
template<int N> | |
struct nth_index_iterator | |
{ | |
typedef typename nth_index<N>::type::iterator type; | |
}; | |
template<int N> | |
struct nth_index_const_iterator | |
{ | |
typedef typename nth_index<N>::type::const_iterator type; | |
}; | |
template<int N,typename IteratorType> | |
typename nth_index_iterator<N>::type project( | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
typedef typename nth_index<N>::type index; | |
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT( | |
(mpl::contains<iterator_type_list,IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER( | |
it,static_cast<typename IteratorType::container_type&>(*this)); | |
return index::make_iterator(static_cast<node_type*>(it.get_node())); | |
} | |
template<int N,typename IteratorType> | |
typename nth_index_const_iterator<N>::type project( | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const | |
{ | |
typedef typename nth_index<N>::type index; | |
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains<iterator_type_list,IteratorType>::value|| | |
mpl::contains<const_iterator_type_list,IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER( | |
it,static_cast<const typename IteratorType::container_type&>(*this)); | |
return index::make_iterator(static_cast<node_type*>(it.get_node())); | |
} | |
#endif | |
/* projection of iterators by tag */ | |
#if !defined(BOOST_NO_MEMBER_TEMPLATES) | |
template<typename Tag> | |
struct index_iterator | |
{ | |
typedef typename index<Tag>::type::iterator type; | |
}; | |
template<typename Tag> | |
struct index_const_iterator | |
{ | |
typedef typename index<Tag>::type::const_iterator type; | |
}; | |
template<typename Tag,typename IteratorType> | |
typename index_iterator<Tag>::type project( | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
typedef typename index<Tag>::type index; | |
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT( | |
(mpl::contains<iterator_type_list,IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER( | |
it,static_cast<typename IteratorType::container_type&>(*this)); | |
return index::make_iterator(static_cast<node_type*>(it.get_node())); | |
} | |
template<typename Tag,typename IteratorType> | |
typename index_const_iterator<Tag>::type project( | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const | |
{ | |
typedef typename index<Tag>::type index; | |
#if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains<iterator_type_list,IteratorType>::value|| | |
mpl::contains<const_iterator_type_list,IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER( | |
it,static_cast<const typename IteratorType::container_type&>(*this)); | |
return index::make_iterator(static_cast<node_type*>(it.get_node())); | |
} | |
#endif | |
BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS: | |
typedef typename super::copy_map_type copy_map_type; | |
node_type* header()const | |
{ | |
return &*bfm_header::member; | |
} | |
node_type* allocate_node() | |
{ | |
return &*bfm_allocator::member.allocate(1); | |
} | |
void deallocate_node(node_type* x) | |
{ | |
typedef typename node_allocator::pointer node_pointer; | |
bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1); | |
} | |
bool empty_()const | |
{ | |
return node_count==0; | |
} | |
std::size_t size_()const | |
{ | |
return node_count; | |
} | |
std::size_t max_size_()const | |
{ | |
return static_cast<std::size_t >(-1); | |
} | |
std::pair<node_type*,bool> insert_(const Value& v) | |
{ | |
node_type* x=allocate_node(); | |
BOOST_TRY{ | |
node_type* res=super::insert_(v,x); | |
if(res==x){ | |
++node_count; | |
return std::pair<node_type*,bool>(res,true); | |
} | |
else{ | |
deallocate_node(x); | |
return std::pair<node_type*,bool>(res,false); | |
} | |
} | |
BOOST_CATCH(...){ | |
deallocate_node(x); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
std::pair<node_type*,bool> insert_(const Value& v,node_type* position) | |
{ | |
node_type* x=allocate_node(); | |
BOOST_TRY{ | |
node_type* res=super::insert_(v,position,x); | |
if(res==x){ | |
++node_count; | |
return std::pair<node_type*,bool>(res,true); | |
} | |
else{ | |
deallocate_node(x); | |
return std::pair<node_type*,bool>(res,false); | |
} | |
} | |
BOOST_CATCH(...){ | |
deallocate_node(x); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
void erase_(node_type* x) | |
{ | |
--node_count; | |
super::erase_(x); | |
deallocate_node(x); | |
} | |
void delete_node_(node_type* x) | |
{ | |
super::delete_node_(x); | |
deallocate_node(x); | |
} | |
void delete_all_nodes_() | |
{ | |
super::delete_all_nodes_(); | |
} | |
void clear_() | |
{ | |
delete_all_nodes_(); | |
super::clear_(); | |
node_count=0; | |
} | |
void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x) | |
{ | |
if(bfm_allocator::member!=x.bfm_allocator::member){ | |
detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member); | |
} | |
std::swap(bfm_header::member,x.bfm_header::member); | |
super::swap_(x); | |
std::swap(node_count,x.node_count); | |
} | |
bool replace_(const Value& k,node_type* x) | |
{ | |
return super::replace_(k,x); | |
} | |
template<typename Modifier> | |
bool modify_(Modifier& mod,node_type* x) | |
{ | |
mod(const_cast<value_type&>(x->value())); | |
BOOST_TRY{ | |
if(!super::modify_(x)){ | |
deallocate_node(x); | |
--node_count; | |
return false; | |
} | |
else return true; | |
} | |
BOOST_CATCH(...){ | |
deallocate_node(x); | |
--node_count; | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
template<typename Modifier,typename Rollback> | |
bool modify_(Modifier& mod,Rollback& back,node_type* x) | |
{ | |
mod(const_cast<value_type&>(x->value())); | |
bool b; | |
BOOST_TRY{ | |
b=super::modify_rollback_(x); | |
} | |
BOOST_CATCH(...){ | |
BOOST_TRY{ | |
back(const_cast<value_type&>(x->value())); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH(...){ | |
this->erase_(x); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
BOOST_CATCH_END | |
BOOST_TRY{ | |
if(!b){ | |
back(const_cast<value_type&>(x->value())); | |
return false; | |
} | |
else return true; | |
} | |
BOOST_CATCH(...){ | |
this->erase_(x); | |
BOOST_RETHROW; | |
} | |
BOOST_CATCH_END | |
} | |
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION) | |
/* serialization */ | |
friend class boost::serialization::access; | |
BOOST_SERIALIZATION_SPLIT_MEMBER() | |
typedef typename super::index_saver_type index_saver_type; | |
typedef typename super::index_loader_type index_loader_type; | |
template<class Archive> | |
void save(Archive& ar,const unsigned int version)const | |
{ | |
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) | |
const serialization::collection_size_type s(size_()); | |
const detail::serialization_version<value_type> value_version; | |
ar<<serialization::make_nvp("count",s); | |
ar<<serialization::make_nvp("value_version",value_version); | |
#else | |
const std::size_t s=size_(); | |
const unsigned int value_version=0; | |
ar<<serialization::make_nvp("count",s); | |
#endif | |
index_saver_type sm(bfm_allocator::member,s); | |
for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){ | |
serialization::save_construct_data_adl(ar,&*it,value_version); | |
ar<<serialization::make_nvp("item",*it); | |
sm.add(it.get_node(),ar,version); | |
} | |
sm.add_track(header(),ar,version); | |
super::save_(ar,version,sm); | |
} | |
template<class Archive> | |
void load(Archive& ar,const unsigned int version) | |
{ | |
BOOST_MULTI_INDEX_CHECK_INVARIANT; | |
clear_(); | |
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) | |
serialization::collection_size_type s; | |
detail::serialization_version<value_type> value_version; | |
if(version<1){ | |
std::size_t sz; | |
ar>>serialization::make_nvp("count",sz); | |
s=sz; | |
} | |
else{ | |
ar>>serialization::make_nvp("count",s); | |
} | |
if(version<2){ | |
value_version=0; | |
} | |
else{ | |
ar>>serialization::make_nvp("value_version",value_version); | |
} | |
#else | |
std::size_t s; | |
unsigned int value_version=0; | |
ar>>serialization::make_nvp("count",s); | |
#endif | |
index_loader_type lm(bfm_allocator::member,s); | |
for(std::size_t n=0;n<s;++n){ | |
detail::archive_constructed<Value> value("item",ar,value_version); | |
std::pair<node_type*,bool> p=insert_( | |
value.get(),super::end().get_node()); | |
if(!p.second)throw_exception( | |
archive::archive_exception( | |
archive::archive_exception::other_exception)); | |
ar.reset_object_address(&p.first->value(),&value.get()); | |
lm.add(p.first,ar,version); | |
} | |
lm.add_track(header(),ar,version); | |
super::load_(ar,version,lm); | |
} | |
#endif | |
#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) | |
/* invariant stuff */ | |
bool invariant_()const | |
{ | |
return super::invariant_(); | |
} | |
void check_invariant_()const | |
{ | |
BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_()); | |
} | |
#endif | |
private: | |
std::size_t node_count; | |
#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ | |
BOOST_WORKAROUND(__MWERKS__,<=0x3003) | |
#pragma parse_mfunc_templ reset | |
#endif | |
}; | |
/* retrieval of indices by number */ | |
template<typename MultiIndexContainer,int N> | |
struct nth_index | |
{ | |
BOOST_STATIC_CONSTANT( | |
int, | |
M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value); | |
BOOST_STATIC_ASSERT(N>=0&&N<M); | |
typedef typename mpl::at_c< | |
typename MultiIndexContainer::index_type_list,N>::type type; | |
}; | |
template<int N,typename Value,typename IndexSpecifierList,typename Allocator> | |
typename nth_index< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type& | |
get( | |
multi_index_container<Value,IndexSpecifierList,Allocator>& m | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename nth_index< | |
multi_index_container< | |
Value,IndexSpecifierList,Allocator>, | |
N | |
>::type index; | |
BOOST_STATIC_ASSERT(N>=0&& | |
N< | |
mpl::size< | |
BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list | |
>::type::value); | |
return detail::converter<multi_index_type,index>::index(m); | |
} | |
template<int N,typename Value,typename IndexSpecifierList,typename Allocator> | |
const typename nth_index< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type& | |
get( | |
const multi_index_container<Value,IndexSpecifierList,Allocator>& m | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename nth_index< | |
multi_index_container< | |
Value,IndexSpecifierList,Allocator>, | |
N | |
>::type index; | |
BOOST_STATIC_ASSERT(N>=0&& | |
N< | |
mpl::size< | |
BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list | |
>::type::value); | |
return detail::converter<multi_index_type,index>::index(m); | |
} | |
/* retrieval of indices by tag */ | |
template<typename MultiIndexContainer,typename Tag> | |
struct index | |
{ | |
typedef typename MultiIndexContainer::index_type_list index_type_list; | |
typedef typename mpl::find_if< | |
index_type_list, | |
detail::has_tag<Tag> | |
>::type iter; | |
BOOST_STATIC_CONSTANT( | |
bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)); | |
BOOST_STATIC_ASSERT(index_found); | |
typedef typename mpl::deref<iter>::type type; | |
}; | |
template< | |
typename Tag,typename Value,typename IndexSpecifierList,typename Allocator | |
> | |
typename ::boost::multi_index::index< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type& | |
get( | |
multi_index_container<Value,IndexSpecifierList,Allocator>& m | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename ::boost::multi_index::index< | |
multi_index_container< | |
Value,IndexSpecifierList,Allocator>, | |
Tag | |
>::type index; | |
return detail::converter<multi_index_type,index>::index(m); | |
} | |
template< | |
typename Tag,typename Value,typename IndexSpecifierList,typename Allocator | |
> | |
const typename ::boost::multi_index::index< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type& | |
get( | |
const multi_index_container<Value,IndexSpecifierList,Allocator>& m | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename ::boost::multi_index::index< | |
multi_index_container< | |
Value,IndexSpecifierList,Allocator>, | |
Tag | |
>::type index; | |
return detail::converter<multi_index_type,index>::index(m); | |
} | |
/* projection of iterators by number */ | |
template<typename MultiIndexContainer,int N> | |
struct nth_index_iterator | |
{ | |
typedef typename detail::prevent_eti< | |
nth_index<MultiIndexContainer,N>, | |
typename nth_index<MultiIndexContainer,N>::type>::type::iterator type; | |
}; | |
template<typename MultiIndexContainer,int N> | |
struct nth_index_const_iterator | |
{ | |
typedef typename detail::prevent_eti< | |
nth_index<MultiIndexContainer,N>, | |
typename nth_index<MultiIndexContainer,N>::type | |
>::type::const_iterator type; | |
}; | |
template< | |
int N,typename IteratorType, | |
typename Value,typename IndexSpecifierList,typename Allocator> | |
typename nth_index_iterator< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type | |
project( | |
multi_index_container<Value,IndexSpecifierList,Allocator>& m, | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename nth_index<multi_index_type,N>::type index; | |
#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ | |
(!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, | |
IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) | |
typedef detail::converter< | |
multi_index_type, | |
BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); | |
#endif | |
return detail::converter<multi_index_type,index>::iterator( | |
m,static_cast<typename multi_index_type::node_type*>(it.get_node())); | |
} | |
template< | |
int N,typename IteratorType, | |
typename Value,typename IndexSpecifierList,typename Allocator> | |
typename nth_index_const_iterator< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type | |
project( | |
const multi_index_container<Value,IndexSpecifierList,Allocator>& m, | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename nth_index<multi_index_type,N>::type index; | |
#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ | |
(!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, | |
IteratorType>::value|| | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, | |
IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) | |
typedef detail::converter< | |
multi_index_type, | |
BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); | |
#endif | |
return detail::converter<multi_index_type,index>::const_iterator( | |
m,static_cast<typename multi_index_type::node_type*>(it.get_node())); | |
} | |
/* projection of iterators by tag */ | |
template<typename MultiIndexContainer,typename Tag> | |
struct index_iterator | |
{ | |
typedef typename ::boost::multi_index::index< | |
MultiIndexContainer,Tag>::type::iterator type; | |
}; | |
template<typename MultiIndexContainer,typename Tag> | |
struct index_const_iterator | |
{ | |
typedef typename ::boost::multi_index::index< | |
MultiIndexContainer,Tag>::type::const_iterator type; | |
}; | |
template< | |
typename Tag,typename IteratorType, | |
typename Value,typename IndexSpecifierList,typename Allocator> | |
typename index_iterator< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type | |
project( | |
multi_index_container<Value,IndexSpecifierList,Allocator>& m, | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename ::boost::multi_index::index< | |
multi_index_type,Tag>::type index; | |
#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ | |
(!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, | |
IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) | |
typedef detail::converter< | |
multi_index_type, | |
BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); | |
#endif | |
return detail::converter<multi_index_type,index>::iterator( | |
m,static_cast<typename multi_index_type::node_type*>(it.get_node())); | |
} | |
template< | |
typename Tag,typename IteratorType, | |
typename Value,typename IndexSpecifierList,typename Allocator> | |
typename index_const_iterator< | |
multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type | |
project( | |
const multi_index_container<Value,IndexSpecifierList,Allocator>& m, | |
IteratorType it | |
BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) | |
{ | |
typedef multi_index_container< | |
Value,IndexSpecifierList,Allocator> multi_index_type; | |
typedef typename ::boost::multi_index::index< | |
multi_index_type,Tag>::type index; | |
#if (!defined(BOOST_MSVC)||!(BOOST_MSVC<1310))&& /* MSVC++ 6.0/7.0 fails */\ | |
(!defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580)) /* as does Sun C++ 5.7 */ | |
BOOST_STATIC_ASSERT(( | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, | |
IteratorType>::value|| | |
mpl::contains< | |
BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, | |
IteratorType>::value)); | |
#endif | |
BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); | |
#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) | |
typedef detail::converter< | |
multi_index_type, | |
BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; | |
BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); | |
#endif | |
return detail::converter<multi_index_type,index>::const_iterator( | |
m,static_cast<typename multi_index_type::node_type*>(it.get_node())); | |
} | |
/* Comparison. Simple forward to first index. */ | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator==( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)==get<0>(y); | |
} | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator<( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)<get<0>(y); | |
} | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator!=( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)!=get<0>(y); | |
} | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator>( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)>get<0>(y); | |
} | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator>=( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)>=get<0>(y); | |
} | |
template< | |
typename Value1,typename IndexSpecifierList1,typename Allocator1, | |
typename Value2,typename IndexSpecifierList2,typename Allocator2 | |
> | |
bool operator<=( | |
const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x, | |
const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y) | |
{ | |
return get<0>(x)<=get<0>(y); | |
} | |
/* specialized algorithms */ | |
template<typename Value,typename IndexSpecifierList,typename Allocator> | |
void swap( | |
multi_index_container<Value,IndexSpecifierList,Allocator>& x, | |
multi_index_container<Value,IndexSpecifierList,Allocator>& y) | |
{ | |
x.swap(y); | |
} | |
} /* namespace multi_index */ | |
#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)&&\ | |
!defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) | |
/* class version = 1 : we now serialize the size through | |
* boost::serialization::collection_size_type. | |
* class version = 2 : proper use of {save|load}_construct_data. | |
*/ | |
namespace serialization { | |
template<typename Value,typename IndexSpecifierList,typename Allocator> | |
struct version< | |
boost::multi_index_container<Value,IndexSpecifierList,Allocator> | |
> | |
{ | |
BOOST_STATIC_CONSTANT(int,value=2); | |
}; | |
} /* namespace serialization */ | |
#endif | |
/* Associated global functions are promoted to namespace boost, except | |
* comparison operators and swap, which are meant to be Koenig looked-up. | |
*/ | |
using multi_index::get; | |
using multi_index::project; | |
} /* namespace boost */ | |
#undef BOOST_MULTI_INDEX_CHECK_INVARIANT | |
#endif |