boost_mirror/multi_index
1
0
Fork 0
mirror of https://github.com/boostorg/multi_index.git synced 2025-05-09 23:14:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
multi_index/include/boost/multi_index_container.hpp
Joaquín M. López Muñoz b35bef74e4 initial commit 
[SVN r22759]
2004-05-07 10:44:23 +00:00

865 lines
25 KiB
C++
Raw Blame History

/* Multiply indexed container.
*
* Copyright Joaquín M López Muñoz 2003-2004. Use, modification, and
* distribution are subject to 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
#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
#include <algorithm>
#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/int.hpp>
#include <boost/mpl/size.hpp>
#include <boost/multi_index_container_fwd.hpp>
#include <boost/multi_index/detail/access_specifier.hpp>
#include <boost/multi_index/detail/allocator.hpp>
#include <boost/multi_index/detail/base_type.hpp>
#include <boost/multi_index/detail/converter.hpp>
#include <boost/multi_index/detail/def_ctor_tuple_cons.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_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 base_from_member<
typename 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::multi_index_node_type<
Value,IndexSpecifierList,Allocator>::type,
multi_index_container<Value,IndexSpecifierList,Allocator> >,
public detail::multi_index_base_type<Value,IndexSpecifierList,Allocator>::type
{
private:
#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template <typename,typename,typename> friend class detail::index_base;
template <typename,typename> friend class detail::header_holder;
template <typename,typename> friend class detail::converter;
#endif
typedef typename detail::multi_index_base_type<
Value,IndexSpecifierList,Allocator>::type super;
typedef base_from_member<
typename detail::allocator::rebind_to<
Allocator,
typename super::node_type
>::type> bfm_allocator;
typedef detail::header_holder<
typename super::node_type,
multi_index_container> bfm_header;
public:
/* All types are inherited from super, a few are explicitly
* brought forward here to save us some typename's.
*/
#if defined(BOOST_MSVC)
typedef
detail::default_constructible_tuple_cons<
typename super::ctor_args_list> ctor_args_list;
#else
typedef typename super::ctor_args_list ctor_args_list;
#endif
typedef typename IndexSpecifierList::type index_specifier_type_list;
typedef typename super::index_type_list index_type_list;
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(
const ctor_args_list& args_list=ctor_args_list(),
const allocator_type& al=allocator_type()):
bfm_allocator(al),
super(args_list,bfm_allocator::member),
node_count(0)
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
}
template<typename InputIterator>
multi_index_container(
InputIterator first,InputIterator last,
const ctor_args_list& args_list=ctor_args_list(),
const allocator_type& al=allocator_type()):
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(...){
clean_up();
BOOST_RETHROW;
}
BOOST_CATCH_END
}
multi_index_container(
const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
bfm_allocator(x.bfm_allocator::member),
super(x),
node_count(0)
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
for(const_iterator it=x.begin();it!=x.end();++it)map.clone(it.get_node());
super::copy_(x,map);
map.release();
node_count=x.size();
}
~multi_index_container()
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
clean_up();
}
multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
{
BOOST_MULTI_INDEX_CHECK_INVARIANT;
multi_index_container<Value,IndexSpecifierList,Allocator> tmp(x);
swap(tmp);
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,mpl::end<index_type_list> >::value));
BOOST_STATIC_ASSERT(index_found);
typedef typename 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;
BOOST_STATIC_ASSERT(
(mpl::contains<iterator_type_list,IteratorType>::value));
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;
BOOST_STATIC_ASSERT((
mpl::contains<iterator_type_list,IteratorType>::value||
mpl::contains<const_iterator_type_list,IteratorType>::value));
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;
BOOST_STATIC_ASSERT(
(mpl::contains<iterator_type_list,IteratorType>::value));
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;
BOOST_STATIC_ASSERT((
mpl::contains<iterator_type_list,IteratorType>::value||
mpl::contains<const_iterator_type_list,IteratorType>::value));
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 detail::allocator::allocate<node_type>(bfm_allocator::member,1);
}
void deallocate_node(node_type* x)
{
detail::allocator::deallocate(bfm_allocator::member,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)
{
super::erase_(x);
deallocate_node(x);
--node_count;
}
void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
{
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
}
#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:
void clean_up()
{
for(iterator it=super::begin();it!=super::end();)erase_(it++.get_node());
}
std::size_t node_count;
};
/* 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,mpl::end<index_type_list> >::value));
BOOST_STATIC_ASSERT(index_found);
typedef typename iter::type type;
};
template<
typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
>
typename 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 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 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 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<1300) /* this ain't work in MSVC++ 6.0 */
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<1300) /* this ain't work in MSVC++ 6.0 */
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 index<MultiIndexContainer,Tag>::type::iterator type;
};
template<typename MultiIndexContainer,typename Tag>
struct index_const_iterator
{
typedef typename 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 index<multi_index_type,Tag>::type index;
#if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */
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 index<multi_index_type,Tag>::type index;
#if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */
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 */
/* 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
Reference in New Issue View Git Blame Copy Permalink