1 /* Multiply indexed container.
2  *
3  * Copyright 2003-2018 Joaquin M Lopez Munoz.
4  * Distributed under the Boost Software License, Version 1.0.
5  * (See accompanying file LICENSE_1_0.txt or copy at
6  * http://www.boost.org/LICENSE_1_0.txt)
7  *
8  * See http://www.boost.org/libs/multi_index for library home page.
9  */
10 
11 #ifndef BOOST_MULTI_INDEX_HPP
12 #define BOOST_MULTI_INDEX_HPP
13 
14 #if defined(_MSC_VER)
15 #pragma once
16 #endif
17 
18 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
19 #include <algorithm>
20 #include <boost/core/addressof.hpp>
21 #include <boost/detail/no_exceptions_support.hpp>
22 #include <boost/detail/workaround.hpp>
23 #include <boost/move/core.hpp>
24 #include <boost/move/utility_core.hpp>
25 #include <boost/mpl/at.hpp>
26 #include <boost/mpl/contains.hpp>
27 #include <boost/mpl/find_if.hpp>
28 #include <boost/mpl/identity.hpp>
29 #include <boost/mpl/int.hpp>
30 #include <boost/mpl/size.hpp>
31 #include <boost/mpl/deref.hpp>
32 #include <boost/multi_index_container_fwd.hpp>
33 #include <boost/multi_index/detail/access_specifier.hpp>
34 #include <boost/multi_index/detail/adl_swap.hpp>
35 #include <boost/multi_index/detail/allocator_traits.hpp>
36 #include <boost/multi_index/detail/base_type.hpp>
37 #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
38 #include <boost/multi_index/detail/converter.hpp>
39 #include <boost/multi_index/detail/header_holder.hpp>
40 #include <boost/multi_index/detail/has_tag.hpp>
41 #include <boost/multi_index/detail/no_duplicate_tags.hpp>
42 #include <boost/multi_index/detail/safe_mode.hpp>
43 #include <boost/multi_index/detail/scope_guard.hpp>
44 #include <boost/multi_index/detail/vartempl_support.hpp>
45 #include <boost/static_assert.hpp>
46 #include <boost/type_traits/is_same.hpp>
47 #include <boost/utility/base_from_member.hpp>
48 
49 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
50 #include <initializer_list>
51 #endif
52 
53 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
54 #include <boost/multi_index/detail/archive_constructed.hpp>
55 #include <boost/multi_index/detail/serialization_version.hpp>
56 #include <boost/serialization/collection_size_type.hpp>
57 #include <boost/serialization/nvp.hpp>
58 #include <boost/serialization/split_member.hpp>
59 #include <boost/serialization/version.hpp>
60 #include <boost/throw_exception.hpp>
61 #endif
62 
63 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
64 #include <boost/multi_index/detail/invariant_assert.hpp>
65 #define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)                              \
66   detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
67     detail::make_obj_guard(x,&multi_index_container::check_invariant_);      \
68   BOOST_JOIN(check_invariant_,__LINE__).touch();
69 #define BOOST_MULTI_INDEX_CHECK_INVARIANT                                    \
70   BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(*this)
71 #else
72 #define BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x)
73 #define BOOST_MULTI_INDEX_CHECK_INVARIANT
74 #endif
75 
76 namespace boost{
77 
78 namespace multi_index{
79 
80 #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
81 #pragma warning(push)
82 #pragma warning(disable:4522) /* spurious warning on multiple operator=()'s */
83 #endif
84 
85 template<typename Value,typename IndexSpecifierList,typename Allocator>
86 class multi_index_container:
87   private ::boost::base_from_member<
88     typename detail::rebind_alloc_for<
89       Allocator,
90       typename detail::multi_index_node_type<
91         Value,IndexSpecifierList,Allocator>::type
92     >::type
93   >,
94   BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder<
95     typename detail::allocator_traits<
96       typename detail::rebind_alloc_for<
97         Allocator,
98         typename detail::multi_index_node_type<
99           Value,IndexSpecifierList,Allocator>::type
100       >::type
101     >::pointer,
102     multi_index_container<Value,IndexSpecifierList,Allocator> >,
103   public detail::multi_index_base_type<
104     Value,IndexSpecifierList,Allocator>::type
105 {
106 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
107     BOOST_WORKAROUND(__MWERKS__,<=0x3003)
108 /* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
109  * lifetime of const references bound to temporaries --precisely what
110  * scopeguards are.
111  */
112 
113 #pragma parse_mfunc_templ off
114 #endif
115 
116 private:
117   BOOST_COPYABLE_AND_MOVABLE(multi_index_container)
118 
119 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
120   template <typename,typename,typename> friend class  detail::index_base;
121   template <typename,typename>          friend struct detail::header_holder;
122   template <typename,typename>          friend struct detail::converter;
123 #endif
124 
125   typedef typename detail::multi_index_base_type<
126       Value,IndexSpecifierList,Allocator>::type   super;
127   typedef typename detail::rebind_alloc_for<
128     Allocator,
129     typename super::node_type
130   >::type                                          node_allocator;
131   typedef detail::allocator_traits<node_allocator> node_alloc_traits;
132   typedef typename node_alloc_traits::pointer      node_pointer;
133   typedef ::boost::base_from_member<
134     node_allocator>                                bfm_allocator;
135   typedef detail::header_holder<
136     node_pointer,
137     multi_index_container>                         bfm_header;
138 
139 public:
140   /* All types are inherited from super, a few are explicitly
141    * brought forward here to save us some typename's.
142    */
143 
144   typedef typename super::ctor_args_list           ctor_args_list;
145   typedef IndexSpecifierList                       index_specifier_type_list;
146 
147   typedef typename super::index_type_list          index_type_list;
148 
149   typedef typename super::iterator_type_list       iterator_type_list;
150   typedef typename super::const_iterator_type_list const_iterator_type_list;
151   typedef typename super::value_type               value_type;
152   typedef typename super::final_allocator_type     allocator_type;
153   typedef typename super::size_type                size_type;
154   typedef typename super::iterator                 iterator;
155   typedef typename super::const_iterator           const_iterator;
156 
157   BOOST_STATIC_ASSERT(
158     detail::no_duplicate_tags_in_index_list<index_type_list>::value);
159 
160   /* global project() needs to see this publicly */
161 
162   typedef typename super::node_type node_type;
163 
164   /* construct/copy/destroy */
165 
multi_index_container()166   multi_index_container():
167     bfm_allocator(allocator_type()),
168     super(ctor_args_list(),bfm_allocator::member),
169     node_count(0)
170   {
171     BOOST_MULTI_INDEX_CHECK_INVARIANT;
172   }
173 
multi_index_container(const ctor_args_list & args_list,const allocator_type & al=typename mpl::identity<multi_index_container>::type::allocator_type ())174   explicit multi_index_container(
175     const ctor_args_list& args_list,
176 
177 #if BOOST_WORKAROUND(__IBMCPP__,<=600)
178     /* VisualAge seems to have an ETI issue with the default value for
179      * argument al.
180      */
181 
182     const allocator_type& al=
183       typename mpl::identity<multi_index_container>::type::
184         allocator_type()):
185 #else
186     const allocator_type& al=allocator_type()):
187 #endif
188 
189     bfm_allocator(al),
190     super(args_list,bfm_allocator::member),
191     node_count(0)
192   {
193     BOOST_MULTI_INDEX_CHECK_INVARIANT;
194   }
195 
multi_index_container(const allocator_type & al)196   explicit multi_index_container(const allocator_type& al):
197     bfm_allocator(al),
198     super(ctor_args_list(),bfm_allocator::member),
199     node_count(0)
200   {
201     BOOST_MULTI_INDEX_CHECK_INVARIANT;
202   }
203 
204   template<typename InputIterator>
multi_index_container(InputIterator first,InputIterator last,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 ())205   multi_index_container(
206     InputIterator first,InputIterator last,
207 
208 #if BOOST_WORKAROUND(__IBMCPP__,<=600)
209     /* VisualAge seems to have an ETI issue with the default values
210      * for arguments args_list and al.
211      */
212 
213     const ctor_args_list& args_list=
214       typename mpl::identity<multi_index_container>::type::
215         ctor_args_list(),
216     const allocator_type& al=
217       typename mpl::identity<multi_index_container>::type::
218         allocator_type()):
219 #else
220     const ctor_args_list& args_list=ctor_args_list(),
221     const allocator_type& al=allocator_type()):
222 #endif
223 
224     bfm_allocator(al),
225     super(args_list,bfm_allocator::member),
226     node_count(0)
227   {
228     BOOST_MULTI_INDEX_CHECK_INVARIANT;
229     BOOST_TRY{
230       iterator hint=super::end();
231       for(;first!=last;++first){
232         hint=super::make_iterator(
233           insert_ref_(*first,hint.get_node()).first);
234         ++hint;
235       }
236     }
237     BOOST_CATCH(...){
238       clear_();
239       BOOST_RETHROW;
240     }
241     BOOST_CATCH_END
242   }
243 
244 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
multi_index_container(std::initializer_list<Value> list,const ctor_args_list & args_list=ctor_args_list (),const allocator_type & al=allocator_type ())245   multi_index_container(
246     std::initializer_list<Value> list,
247     const ctor_args_list& args_list=ctor_args_list(),
248     const allocator_type& al=allocator_type()):
249     bfm_allocator(al),
250     super(args_list,bfm_allocator::member),
251     node_count(0)
252   {
253     BOOST_MULTI_INDEX_CHECK_INVARIANT;
254     BOOST_TRY{
255       typedef const Value* init_iterator;
256 
257       iterator hint=super::end();
258       for(init_iterator first=list.begin(),last=list.end();
259           first!=last;++first){
260         hint=super::make_iterator(insert_(*first,hint.get_node()).first);
261         ++hint;
262       }
263     }
264     BOOST_CATCH(...){
265       clear_();
266       BOOST_RETHROW;
267     }
268     BOOST_CATCH_END
269   }
270 #endif
271 
multi_index_container(const multi_index_container<Value,IndexSpecifierList,Allocator> & x)272   multi_index_container(
273     const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
274     bfm_allocator(x.bfm_allocator::member),
275     bfm_header(),
276     super(x),
277     node_count(0)
278   {
279     copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
280     for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
281       map.clone(it.get_node());
282     }
283     super::copy_(x,map);
284     map.release();
285     node_count=x.size();
286 
287     /* Not until this point are the indices required to be consistent,
288      * hence the position of the invariant checker.
289      */
290 
291     BOOST_MULTI_INDEX_CHECK_INVARIANT;
292   }
293 
multi_index_container(BOOST_RV_REF (multi_index_container)x)294   multi_index_container(BOOST_RV_REF(multi_index_container) x):
295     bfm_allocator(x.bfm_allocator::member),
296     bfm_header(),
297     super(x,detail::do_not_copy_elements_tag()),
298     node_count(0)
299   {
300     BOOST_MULTI_INDEX_CHECK_INVARIANT;
301     BOOST_MULTI_INDEX_CHECK_INVARIANT_OF(x);
302     swap_elements_(x);
303   }
304 
~multi_index_container()305   ~multi_index_container()
306   {
307     delete_all_nodes_();
308   }
309 
310 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
311   /* As per http://www.boost.org/doc/html/move/emulation_limitations.html
312    * #move.emulation_limitations.assignment_operator
313    */
314 
operator =(const multi_index_container<Value,IndexSpecifierList,Allocator> & x)315   multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
316     const multi_index_container<Value,IndexSpecifierList,Allocator>& x)
317   {
318     multi_index_container y(x);
319     this->swap(y);
320     return *this;
321   }
322 #endif
323 
operator =(BOOST_COPY_ASSIGN_REF (multi_index_container)x)324   multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
325     BOOST_COPY_ASSIGN_REF(multi_index_container) x)
326   {
327     multi_index_container y(x);
328     this->swap(y);
329     return *this;
330   }
331 
operator =(BOOST_RV_REF (multi_index_container)x)332   multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
333     BOOST_RV_REF(multi_index_container) x)
334   {
335     this->swap(x);
336     return *this;
337   }
338 
339 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
operator =(std::initializer_list<Value> list)340   multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
341     std::initializer_list<Value> list)
342   {
343     BOOST_MULTI_INDEX_CHECK_INVARIANT;
344     typedef const Value* init_iterator;
345 
346     multi_index_container x(*this,detail::do_not_copy_elements_tag());
347     iterator hint=x.end();
348     for(init_iterator first=list.begin(),last=list.end();
349         first!=last;++first){
350       hint=x.make_iterator(x.insert_(*first,hint.get_node()).first);
351       ++hint;
352     }
353     x.swap_elements_(*this);
354     return*this;
355   }
356 #endif
357 
get_allocator() const358   allocator_type get_allocator()const BOOST_NOEXCEPT
359   {
360     return allocator_type(bfm_allocator::member);
361   }
362 
363   /* retrieval of indices by number */
364 
365 #if !defined(BOOST_NO_MEMBER_TEMPLATES)
366   template<int N>
367   struct nth_index
368   {
369     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
370     typedef typename mpl::at_c<index_type_list,N>::type type;
371   };
372 
373   template<int N>
get()374   typename nth_index<N>::type& get()BOOST_NOEXCEPT
375   {
376     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
377     return *this;
378   }
379 
380   template<int N>
get() const381   const typename nth_index<N>::type& get()const BOOST_NOEXCEPT
382   {
383     BOOST_STATIC_ASSERT(N>=0&&N<mpl::size<index_type_list>::type::value);
384     return *this;
385   }
386 #endif
387 
388   /* retrieval of indices by tag */
389 
390 #if !defined(BOOST_NO_MEMBER_TEMPLATES)
391   template<typename Tag>
392   struct index
393   {
394     typedef typename mpl::find_if<
395       index_type_list,
396       detail::has_tag<Tag>
397     >::type                                    iter;
398 
399     BOOST_STATIC_CONSTANT(
400       bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
401     BOOST_STATIC_ASSERT(index_found);
402 
403     typedef typename mpl::deref<iter>::type    type;
404   };
405 
406   template<typename Tag>
get()407   typename index<Tag>::type& get()BOOST_NOEXCEPT
408   {
409     return *this;
410   }
411 
412   template<typename Tag>
get() const413   const typename index<Tag>::type& get()const BOOST_NOEXCEPT
414   {
415     return *this;
416   }
417 #endif
418 
419   /* projection of iterators by number */
420 
421 #if !defined(BOOST_NO_MEMBER_TEMPLATES)
422   template<int N>
423   struct nth_index_iterator
424   {
425     typedef typename nth_index<N>::type::iterator type;
426   };
427 
428   template<int N>
429   struct nth_index_const_iterator
430   {
431     typedef typename nth_index<N>::type::const_iterator type;
432   };
433 
434   template<int N,typename IteratorType>
project(IteratorType it)435   typename nth_index_iterator<N>::type project(IteratorType it)
436   {
437     typedef typename nth_index<N>::type index_type;
438 
439 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
440     BOOST_STATIC_ASSERT(
441       (mpl::contains<iterator_type_list,IteratorType>::value));
442 #endif
443 
444     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
445     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
446       it,static_cast<typename IteratorType::container_type&>(*this));
447 
448     return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
449   }
450 
451   template<int N,typename IteratorType>
project(IteratorType it) const452   typename nth_index_const_iterator<N>::type project(IteratorType it)const
453   {
454     typedef typename nth_index<N>::type index_type;
455 
456 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
457     BOOST_STATIC_ASSERT((
458       mpl::contains<iterator_type_list,IteratorType>::value||
459       mpl::contains<const_iterator_type_list,IteratorType>::value));
460 #endif
461 
462     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
463     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
464       it,static_cast<const typename IteratorType::container_type&>(*this));
465     return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
466   }
467 #endif
468 
469   /* projection of iterators by tag */
470 
471 #if !defined(BOOST_NO_MEMBER_TEMPLATES)
472   template<typename Tag>
473   struct index_iterator
474   {
475     typedef typename index<Tag>::type::iterator type;
476   };
477 
478   template<typename Tag>
479   struct index_const_iterator
480   {
481     typedef typename index<Tag>::type::const_iterator type;
482   };
483 
484   template<typename Tag,typename IteratorType>
project(IteratorType it)485   typename index_iterator<Tag>::type project(IteratorType it)
486   {
487     typedef typename index<Tag>::type index_type;
488 
489 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
490     BOOST_STATIC_ASSERT(
491       (mpl::contains<iterator_type_list,IteratorType>::value));
492 #endif
493 
494     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
495     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
496       it,static_cast<typename IteratorType::container_type&>(*this));
497     return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
498   }
499 
500   template<typename Tag,typename IteratorType>
project(IteratorType it) const501   typename index_const_iterator<Tag>::type project(IteratorType it)const
502   {
503     typedef typename index<Tag>::type index_type;
504 
505 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
506     BOOST_STATIC_ASSERT((
507       mpl::contains<iterator_type_list,IteratorType>::value||
508       mpl::contains<const_iterator_type_list,IteratorType>::value));
509 #endif
510 
511     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
512     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
513       it,static_cast<const typename IteratorType::container_type&>(*this));
514     return index_type::make_iterator(static_cast<node_type*>(it.get_node()));
515   }
516 #endif
517 
518 BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
519   typedef typename super::copy_map_type copy_map_type;
520 
521 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
multi_index_container(const multi_index_container<Value,IndexSpecifierList,Allocator> & x,detail::do_not_copy_elements_tag)522   multi_index_container(
523     const multi_index_container<Value,IndexSpecifierList,Allocator>& x,
524     detail::do_not_copy_elements_tag):
525     bfm_allocator(x.bfm_allocator::member),
526     bfm_header(),
527     super(x,detail::do_not_copy_elements_tag()),
528     node_count(0)
529   {
530     BOOST_MULTI_INDEX_CHECK_INVARIANT;
531   }
532 #endif
533 
header() const534   node_type* header()const
535   {
536     return &*bfm_header::member;
537   }
538 
allocate_node()539   node_type* allocate_node()
540   {
541     return &*node_alloc_traits::allocate(bfm_allocator::member,1);
542   }
543 
deallocate_node(node_type * x)544   void deallocate_node(node_type* x)
545   {
546     node_alloc_traits::deallocate(
547       bfm_allocator::member,static_cast<node_pointer>(x),1);
548   }
549 
construct_value(node_type * x,const Value & v)550   void construct_value(node_type* x,const Value& v)
551   {
552     node_alloc_traits::construct(
553       bfm_allocator::member,boost::addressof(x->value()),v);
554   }
555 
construct_value(node_type * x,BOOST_RV_REF (Value)v)556   void construct_value(node_type* x,BOOST_RV_REF(Value) v)
557   {
558     node_alloc_traits::construct(
559       bfm_allocator::member,boost::addressof(x->value()),boost::move(v));
560   }
561 
BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(void,construct_value,vartempl_construct_value_impl,node_type *,x)562   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
563     void,construct_value,vartempl_construct_value_impl,node_type*,x)
564 
565   void destroy_value(node_type* x)
566   {
567     node_alloc_traits::destroy(
568       bfm_allocator::member,boost::addressof(x->value()));
569   }
570 
empty_() const571   bool empty_()const
572   {
573     return node_count==0;
574   }
575 
size_() const576   size_type size_()const
577   {
578     return node_count;
579   }
580 
max_size_() const581   size_type max_size_()const
582   {
583     return static_cast<size_type>(-1);
584   }
585 
586   template<typename Variant>
insert_(const Value & v,Variant variant)587   std::pair<node_type*,bool> insert_(const Value& v,Variant variant)
588   {
589     node_type* x=0;
590     node_type* res=super::insert_(v,x,variant);
591     if(res==x){
592       ++node_count;
593       return std::pair<node_type*,bool>(res,true);
594     }
595     else{
596       return std::pair<node_type*,bool>(res,false);
597     }
598   }
599 
insert_(const Value & v)600   std::pair<node_type*,bool> insert_(const Value& v)
601   {
602     return insert_(v,detail::lvalue_tag());
603   }
604 
insert_rv_(const Value & v)605   std::pair<node_type*,bool> insert_rv_(const Value& v)
606   {
607     return insert_(v,detail::rvalue_tag());
608   }
609 
610   template<typename T>
insert_ref_(T & t)611   std::pair<node_type*,bool> insert_ref_(T& t)
612   {
613     node_type* x=allocate_node();
614     BOOST_TRY{
615       construct_value(x,t);
616       BOOST_TRY{
617         node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
618         if(res==x){
619           ++node_count;
620           return std::pair<node_type*,bool>(res,true);
621         }
622         else{
623           destroy_value(x);
624           deallocate_node(x);
625           return std::pair<node_type*,bool>(res,false);
626         }
627       }
628       BOOST_CATCH(...){
629         destroy_value(x);
630         BOOST_RETHROW;
631       }
632       BOOST_CATCH_END
633     }
634     BOOST_CATCH(...){
635       deallocate_node(x);
636       BOOST_RETHROW;
637     }
638     BOOST_CATCH_END
639   }
640 
insert_ref_(const value_type & x)641   std::pair<node_type*,bool> insert_ref_(const value_type& x)
642   {
643     return insert_(x);
644   }
645 
insert_ref_(value_type & x)646   std::pair<node_type*,bool> insert_ref_(value_type& x)
647   {
648     return insert_(x);
649   }
650 
651   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
emplace_(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)652   std::pair<node_type*,bool> emplace_(
653     BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
654   {
655     node_type* x=allocate_node();
656     BOOST_TRY{
657       construct_value(x,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
658       BOOST_TRY{
659         node_type* res=super::insert_(x->value(),x,detail::emplaced_tag());
660         if(res==x){
661           ++node_count;
662           return std::pair<node_type*,bool>(res,true);
663         }
664         else{
665           destroy_value(x);
666           deallocate_node(x);
667           return std::pair<node_type*,bool>(res,false);
668         }
669       }
670       BOOST_CATCH(...){
671         destroy_value(x);
672         BOOST_RETHROW;
673       }
674       BOOST_CATCH_END
675     }
676     BOOST_CATCH(...){
677       deallocate_node(x);
678       BOOST_RETHROW;
679     }
680     BOOST_CATCH_END
681   }
682 
683   template<typename Variant>
insert_(const Value & v,node_type * position,Variant variant)684   std::pair<node_type*,bool> insert_(
685     const Value& v,node_type* position,Variant variant)
686   {
687     node_type* x=0;
688     node_type* res=super::insert_(v,position,x,variant);
689     if(res==x){
690       ++node_count;
691       return std::pair<node_type*,bool>(res,true);
692     }
693     else{
694       return std::pair<node_type*,bool>(res,false);
695     }
696   }
697 
insert_(const Value & v,node_type * position)698   std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
699   {
700     return insert_(v,position,detail::lvalue_tag());
701   }
702 
insert_rv_(const Value & v,node_type * position)703   std::pair<node_type*,bool> insert_rv_(const Value& v,node_type* position)
704   {
705     return insert_(v,position,detail::rvalue_tag());
706   }
707 
708   template<typename T>
insert_ref_(T & t,node_type * position)709   std::pair<node_type*,bool> insert_ref_(
710     T& t,node_type* position)
711   {
712     node_type* x=allocate_node();
713     BOOST_TRY{
714       construct_value(x,t);
715       BOOST_TRY{
716         node_type* res=super::insert_(
717           x->value(),position,x,detail::emplaced_tag());
718         if(res==x){
719           ++node_count;
720           return std::pair<node_type*,bool>(res,true);
721         }
722         else{
723           destroy_value(x);
724           deallocate_node(x);
725           return std::pair<node_type*,bool>(res,false);
726         }
727       }
728       BOOST_CATCH(...){
729         destroy_value(x);
730         BOOST_RETHROW;
731       }
732       BOOST_CATCH_END
733     }
734     BOOST_CATCH(...){
735       deallocate_node(x);
736       BOOST_RETHROW;
737     }
738     BOOST_CATCH_END
739   }
740 
insert_ref_(const value_type & x,node_type * position)741   std::pair<node_type*,bool> insert_ref_(
742     const value_type& x,node_type* position)
743   {
744     return insert_(x,position);
745   }
746 
insert_ref_(value_type & x,node_type * position)747   std::pair<node_type*,bool> insert_ref_(
748     value_type& x,node_type* position)
749   {
750     return insert_(x,position);
751   }
752 
753   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
emplace_hint_(node_type * position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)754   std::pair<node_type*,bool> emplace_hint_(
755     node_type* position,
756     BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
757   {
758     node_type* x=allocate_node();
759     BOOST_TRY{
760       construct_value(x,BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
761       BOOST_TRY{
762         node_type* res=super::insert_(
763           x->value(),position,x,detail::emplaced_tag());
764         if(res==x){
765           ++node_count;
766           return std::pair<node_type*,bool>(res,true);
767         }
768         else{
769           destroy_value(x);
770           deallocate_node(x);
771           return std::pair<node_type*,bool>(res,false);
772         }
773       }
774       BOOST_CATCH(...){
775         destroy_value(x);
776         BOOST_RETHROW;
777       }
778       BOOST_CATCH_END
779     }
780     BOOST_CATCH(...){
781       deallocate_node(x);
782       BOOST_RETHROW;
783     }
784     BOOST_CATCH_END
785   }
786 
erase_(node_type * x)787   void erase_(node_type* x)
788   {
789     --node_count;
790     super::erase_(x);
791     deallocate_node(x);
792   }
793 
delete_node_(node_type * x)794   void delete_node_(node_type* x)
795   {
796     super::delete_node_(x);
797     deallocate_node(x);
798   }
799 
delete_all_nodes_()800   void delete_all_nodes_()
801   {
802     super::delete_all_nodes_();
803   }
804 
clear_()805   void clear_()
806   {
807     delete_all_nodes_();
808     super::clear_();
809     node_count=0;
810   }
811 
swap_(multi_index_container<Value,IndexSpecifierList,Allocator> & x)812   void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
813   {
814     if(bfm_allocator::member!=x.bfm_allocator::member){
815       detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
816     }
817     std::swap(bfm_header::member,x.bfm_header::member);
818     super::swap_(x);
819     std::swap(node_count,x.node_count);
820   }
821 
swap_elements_(multi_index_container<Value,IndexSpecifierList,Allocator> & x)822   void swap_elements_(
823     multi_index_container<Value,IndexSpecifierList,Allocator>& x)
824   {
825     std::swap(bfm_header::member,x.bfm_header::member);
826     super::swap_elements_(x);
827     std::swap(node_count,x.node_count);
828   }
829 
replace_(const Value & k,node_type * x)830   bool replace_(const Value& k,node_type* x)
831   {
832     return super::replace_(k,x,detail::lvalue_tag());
833   }
834 
replace_rv_(const Value & k,node_type * x)835   bool replace_rv_(const Value& k,node_type* x)
836   {
837     return super::replace_(k,x,detail::rvalue_tag());
838   }
839 
840   template<typename Modifier>
modify_(Modifier & mod,node_type * x)841   bool modify_(Modifier& mod,node_type* x)
842   {
843     BOOST_TRY{
844       mod(const_cast<value_type&>(x->value()));
845     }
846     BOOST_CATCH(...){
847       this->erase_(x);
848       BOOST_RETHROW;
849     }
850     BOOST_CATCH_END
851 
852     BOOST_TRY{
853       if(!super::modify_(x)){
854         deallocate_node(x);
855         --node_count;
856         return false;
857       }
858       else return true;
859     }
860     BOOST_CATCH(...){
861       deallocate_node(x);
862       --node_count;
863       BOOST_RETHROW;
864     }
865     BOOST_CATCH_END
866   }
867 
868   template<typename Modifier,typename Rollback>
modify_(Modifier & mod,Rollback & back_,node_type * x)869   bool modify_(Modifier& mod,Rollback& back_,node_type* x)
870   {
871     BOOST_TRY{
872       mod(const_cast<value_type&>(x->value()));
873     }
874     BOOST_CATCH(...){
875       this->erase_(x);
876       BOOST_RETHROW;
877     }
878     BOOST_CATCH_END
879 
880     bool b;
881     BOOST_TRY{
882       b=super::modify_rollback_(x);
883     }
884     BOOST_CATCH(...){
885       BOOST_TRY{
886         back_(const_cast<value_type&>(x->value()));
887         if(!super::check_rollback_(x))this->erase_(x);
888         BOOST_RETHROW;
889       }
890       BOOST_CATCH(...){
891         this->erase_(x);
892         BOOST_RETHROW;
893       }
894       BOOST_CATCH_END
895     }
896     BOOST_CATCH_END
897 
898     BOOST_TRY{
899       if(!b){
900         back_(const_cast<value_type&>(x->value()));
901         if(!super::check_rollback_(x))this->erase_(x);
902         return false;
903       }
904       else return true;
905     }
906     BOOST_CATCH(...){
907       this->erase_(x);
908       BOOST_RETHROW;
909     }
910     BOOST_CATCH_END
911   }
912 
913 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
914   /* serialization */
915 
916   friend class boost::serialization::access;
917 
918   BOOST_SERIALIZATION_SPLIT_MEMBER()
919 
920   typedef typename super::index_saver_type        index_saver_type;
921   typedef typename super::index_loader_type       index_loader_type;
922 
923   template<class Archive>
save(Archive & ar,const unsigned int version) const924   void save(Archive& ar,const unsigned int version)const
925   {
926     const serialization::collection_size_type       s(size_());
927     const detail::serialization_version<value_type> value_version;
928     ar<<serialization::make_nvp("count",s);
929     ar<<serialization::make_nvp("value_version",value_version);
930 
931     index_saver_type sm(bfm_allocator::member,s);
932 
933     for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
934       serialization::save_construct_data_adl(
935         ar,boost::addressof(*it),value_version);
936       ar<<serialization::make_nvp("item",*it);
937       sm.add(it.get_node(),ar,version);
938     }
939     sm.add_track(header(),ar,version);
940 
941     super::save_(ar,version,sm);
942   }
943 
944   template<class Archive>
load(Archive & ar,const unsigned int version)945   void load(Archive& ar,const unsigned int version)
946   {
947     BOOST_MULTI_INDEX_CHECK_INVARIANT;
948 
949     clear_();
950     serialization::collection_size_type       s;
951     detail::serialization_version<value_type> value_version;
952     if(version<1){
953       std::size_t sz;
954       ar>>serialization::make_nvp("count",sz);
955       s=static_cast<serialization::collection_size_type>(sz);
956     }
957     else{
958       ar>>serialization::make_nvp("count",s);
959     }
960     if(version<2){
961       value_version=0;
962     }
963     else{
964       ar>>serialization::make_nvp("value_version",value_version);
965     }
966 
967     index_loader_type lm(bfm_allocator::member,s);
968 
969     for(std::size_t n=0;n<s;++n){
970       detail::archive_constructed<Value> value("item",ar,value_version);
971       std::pair<node_type*,bool> p=insert_rv_(
972         value.get(),super::end().get_node());
973       if(!p.second)throw_exception(
974         archive::archive_exception(
975           archive::archive_exception::other_exception));
976       ar.reset_object_address(
977         boost::addressof(p.first->value()),boost::addressof(value.get()));
978       lm.add(p.first,ar,version);
979     }
980     lm.add_track(header(),ar,version);
981 
982     super::load_(ar,version,lm);
983   }
984 #endif
985 
986 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
987   /* invariant stuff */
988 
invariant_() const989   bool invariant_()const
990   {
991     return super::invariant_();
992   }
993 
check_invariant_() const994   void check_invariant_()const
995   {
996     BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_());
997   }
998 #endif
999 
1000 private:
1001   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
vartempl_construct_value_impl(node_type * x,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)1002   void vartempl_construct_value_impl(
1003     node_type* x,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
1004   {
1005     node_alloc_traits::construct(
1006       bfm_allocator::member,boost::addressof(x->value()),
1007       BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
1008   }
1009 
1010   size_type node_count;
1011 
1012 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
1013     BOOST_WORKAROUND(__MWERKS__,<=0x3003)
1014 #pragma parse_mfunc_templ reset
1015 #endif
1016 };
1017 
1018 #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500))
1019 #pragma warning(pop) /* C4522 */
1020 #endif
1021 
1022 /* retrieval of indices by number */
1023 
1024 template<typename MultiIndexContainer,int N>
1025 struct nth_index
1026 {
1027   BOOST_STATIC_CONSTANT(
1028     int,
1029     M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value);
1030   BOOST_STATIC_ASSERT(N>=0&&N<M);
1031   typedef typename mpl::at_c<
1032     typename MultiIndexContainer::index_type_list,N>::type type;
1033 };
1034 
1035 template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
1036 typename nth_index<
1037   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(multi_index_container<Value,IndexSpecifierList,Allocator> & m)1038 get(
1039   multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
1040 {
1041   typedef multi_index_container<
1042     Value,IndexSpecifierList,Allocator>    multi_index_type;
1043   typedef typename nth_index<
1044     multi_index_container<
1045       Value,IndexSpecifierList,Allocator>,
1046     N
1047   >::type                                  index_type;
1048 
1049   BOOST_STATIC_ASSERT(N>=0&&
1050     N<
1051     mpl::size<
1052       BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
1053     >::type::value);
1054 
1055   return detail::converter<multi_index_type,index_type>::index(m);
1056 }
1057 
1058 template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
1059 const typename nth_index<
1060   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(const multi_index_container<Value,IndexSpecifierList,Allocator> & m)1061 get(
1062   const multi_index_container<Value,IndexSpecifierList,Allocator>& m
1063 )BOOST_NOEXCEPT
1064 {
1065   typedef multi_index_container<
1066     Value,IndexSpecifierList,Allocator>    multi_index_type;
1067   typedef typename nth_index<
1068     multi_index_container<
1069       Value,IndexSpecifierList,Allocator>,
1070     N
1071   >::type                                  index_type;
1072 
1073   BOOST_STATIC_ASSERT(N>=0&&
1074     N<
1075     mpl::size<
1076       BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list
1077     >::type::value);
1078 
1079   return detail::converter<multi_index_type,index_type>::index(m);
1080 }
1081 
1082 /* retrieval of indices by tag */
1083 
1084 template<typename MultiIndexContainer,typename Tag>
1085 struct index
1086 {
1087   typedef typename MultiIndexContainer::index_type_list index_type_list;
1088 
1089   typedef typename mpl::find_if<
1090     index_type_list,
1091     detail::has_tag<Tag>
1092   >::type                                      iter;
1093 
1094   BOOST_STATIC_CONSTANT(
1095     bool,index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value));
1096   BOOST_STATIC_ASSERT(index_found);
1097 
1098   typedef typename mpl::deref<iter>::type       type;
1099 };
1100 
1101 template<
1102   typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
1103 >
1104 typename ::boost::multi_index::index<
1105   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(multi_index_container<Value,IndexSpecifierList,Allocator> & m)1106 get(
1107   multi_index_container<Value,IndexSpecifierList,Allocator>& m)BOOST_NOEXCEPT
1108 {
1109   typedef multi_index_container<
1110     Value,IndexSpecifierList,Allocator>         multi_index_type;
1111   typedef typename ::boost::multi_index::index<
1112     multi_index_container<
1113       Value,IndexSpecifierList,Allocator>,
1114     Tag
1115   >::type                                       index_type;
1116 
1117   return detail::converter<multi_index_type,index_type>::index(m);
1118 }
1119 
1120 template<
1121   typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
1122 >
1123 const typename ::boost::multi_index::index<
1124   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(const multi_index_container<Value,IndexSpecifierList,Allocator> & m)1125 get(
1126   const multi_index_container<Value,IndexSpecifierList,Allocator>& m
1127 )BOOST_NOEXCEPT
1128 {
1129   typedef multi_index_container<
1130     Value,IndexSpecifierList,Allocator>         multi_index_type;
1131   typedef typename ::boost::multi_index::index<
1132     multi_index_container<
1133       Value,IndexSpecifierList,Allocator>,
1134     Tag
1135   >::type                                       index_type;
1136 
1137   return detail::converter<multi_index_type,index_type>::index(m);
1138 }
1139 
1140 /* projection of iterators by number */
1141 
1142 template<typename MultiIndexContainer,int N>
1143 struct nth_index_iterator
1144 {
1145   typedef typename nth_index<MultiIndexContainer,N>::type::iterator type;
1146 };
1147 
1148 template<typename MultiIndexContainer,int N>
1149 struct nth_index_const_iterator
1150 {
1151   typedef typename nth_index<MultiIndexContainer,N>::type::const_iterator type;
1152 };
1153 
1154 template<
1155   int N,typename IteratorType,
1156   typename Value,typename IndexSpecifierList,typename Allocator>
1157 typename nth_index_iterator<
1158   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(multi_index_container<Value,IndexSpecifierList,Allocator> & m,IteratorType it)1159 project(
1160   multi_index_container<Value,IndexSpecifierList,Allocator>& m,
1161   IteratorType it)
1162 {
1163   typedef multi_index_container<
1164     Value,IndexSpecifierList,Allocator>                multi_index_type;
1165   typedef typename nth_index<multi_index_type,N>::type index_type;
1166 
1167 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
1168   BOOST_STATIC_ASSERT((
1169     mpl::contains<
1170       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
1171       IteratorType>::value));
1172 #endif
1173 
1174   BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
1175 
1176 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
1177   typedef detail::converter<
1178     multi_index_type,
1179     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
1180   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
1181 #endif
1182 
1183   return detail::converter<multi_index_type,index_type>::iterator(
1184     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
1185 }
1186 
1187 template<
1188   int N,typename IteratorType,
1189   typename Value,typename IndexSpecifierList,typename Allocator>
1190 typename nth_index_const_iterator<
1191   multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(const multi_index_container<Value,IndexSpecifierList,Allocator> & m,IteratorType it)1192 project(
1193   const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
1194   IteratorType it)
1195 {
1196   typedef multi_index_container<
1197     Value,IndexSpecifierList,Allocator>                multi_index_type;
1198   typedef typename nth_index<multi_index_type,N>::type index_type;
1199 
1200 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
1201   BOOST_STATIC_ASSERT((
1202     mpl::contains<
1203       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
1204       IteratorType>::value||
1205     mpl::contains<
1206       BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
1207       IteratorType>::value));
1208 #endif
1209 
1210   BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
1211 
1212 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
1213   typedef detail::converter<
1214     multi_index_type,
1215     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
1216   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
1217 #endif
1218 
1219   return detail::converter<multi_index_type,index_type>::const_iterator(
1220     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
1221 }
1222 
1223 /* projection of iterators by tag */
1224 
1225 template<typename MultiIndexContainer,typename Tag>
1226 struct index_iterator
1227 {
1228   typedef typename ::boost::multi_index::index<
1229     MultiIndexContainer,Tag>::type::iterator    type;
1230 };
1231 
1232 template<typename MultiIndexContainer,typename Tag>
1233 struct index_const_iterator
1234 {
1235   typedef typename ::boost::multi_index::index<
1236     MultiIndexContainer,Tag>::type::const_iterator type;
1237 };
1238 
1239 template<
1240   typename Tag,typename IteratorType,
1241   typename Value,typename IndexSpecifierList,typename Allocator>
1242 typename index_iterator<
1243   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(multi_index_container<Value,IndexSpecifierList,Allocator> & m,IteratorType it)1244 project(
1245   multi_index_container<Value,IndexSpecifierList,Allocator>& m,
1246   IteratorType it)
1247 {
1248   typedef multi_index_container<
1249     Value,IndexSpecifierList,Allocator>         multi_index_type;
1250   typedef typename ::boost::multi_index::index<
1251     multi_index_type,Tag>::type                 index_type;
1252 
1253 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
1254   BOOST_STATIC_ASSERT((
1255     mpl::contains<
1256       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
1257       IteratorType>::value));
1258 #endif
1259 
1260   BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
1261 
1262 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
1263   typedef detail::converter<
1264     multi_index_type,
1265     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
1266   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
1267 #endif
1268 
1269   return detail::converter<multi_index_type,index_type>::iterator(
1270     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
1271 }
1272 
1273 template<
1274   typename Tag,typename IteratorType,
1275   typename Value,typename IndexSpecifierList,typename Allocator>
1276 typename index_const_iterator<
1277   multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(const multi_index_container<Value,IndexSpecifierList,Allocator> & m,IteratorType it)1278 project(
1279   const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
1280   IteratorType it)
1281 {
1282   typedef multi_index_container<
1283     Value,IndexSpecifierList,Allocator>         multi_index_type;
1284   typedef typename ::boost::multi_index::index<
1285     multi_index_type,Tag>::type                 index_type;
1286 
1287 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* Sun C++ 5.7 fails */
1288   BOOST_STATIC_ASSERT((
1289     mpl::contains<
1290       BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list,
1291       IteratorType>::value||
1292     mpl::contains<
1293       BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list,
1294       IteratorType>::value));
1295 #endif
1296 
1297   BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
1298 
1299 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
1300   typedef detail::converter<
1301     multi_index_type,
1302     BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter;
1303   BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m));
1304 #endif
1305 
1306   return detail::converter<multi_index_type,index_type>::const_iterator(
1307     m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
1308 }
1309 
1310 /* Comparison. Simple forward to first index. */
1311 
1312 template<
1313   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1314   typename Value2,typename IndexSpecifierList2,typename Allocator2
1315 >
operator ==(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1316 bool operator==(
1317   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1318   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1319 {
1320   return get<0>(x)==get<0>(y);
1321 }
1322 
1323 template<
1324   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1325   typename Value2,typename IndexSpecifierList2,typename Allocator2
1326 >
operator <(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1327 bool operator<(
1328   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1329   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1330 {
1331   return get<0>(x)<get<0>(y);
1332 }
1333 
1334 template<
1335   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1336   typename Value2,typename IndexSpecifierList2,typename Allocator2
1337 >
operator !=(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1338 bool operator!=(
1339   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1340   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1341 {
1342   return get<0>(x)!=get<0>(y);
1343 }
1344 
1345 template<
1346   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1347   typename Value2,typename IndexSpecifierList2,typename Allocator2
1348 >
operator >(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1349 bool operator>(
1350   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1351   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1352 {
1353   return get<0>(x)>get<0>(y);
1354 }
1355 
1356 template<
1357   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1358   typename Value2,typename IndexSpecifierList2,typename Allocator2
1359 >
operator >=(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1360 bool operator>=(
1361   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1362   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1363 {
1364   return get<0>(x)>=get<0>(y);
1365 }
1366 
1367 template<
1368   typename Value1,typename IndexSpecifierList1,typename Allocator1,
1369   typename Value2,typename IndexSpecifierList2,typename Allocator2
1370 >
operator <=(const multi_index_container<Value1,IndexSpecifierList1,Allocator1> & x,const multi_index_container<Value2,IndexSpecifierList2,Allocator2> & y)1371 bool operator<=(
1372   const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
1373   const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
1374 {
1375   return get<0>(x)<=get<0>(y);
1376 }
1377 
1378 /*  specialized algorithms */
1379 
1380 template<typename Value,typename IndexSpecifierList,typename Allocator>
swap(multi_index_container<Value,IndexSpecifierList,Allocator> & x,multi_index_container<Value,IndexSpecifierList,Allocator> & y)1381 void swap(
1382   multi_index_container<Value,IndexSpecifierList,Allocator>& x,
1383   multi_index_container<Value,IndexSpecifierList,Allocator>& y)
1384 {
1385   x.swap(y);
1386 }
1387 
1388 } /* namespace multi_index */
1389 
1390 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
1391 /* class version = 1 : we now serialize the size through
1392  * boost::serialization::collection_size_type.
1393  * class version = 2 : proper use of {save|load}_construct_data.
1394  */
1395 
1396 namespace serialization {
1397 template<typename Value,typename IndexSpecifierList,typename Allocator>
1398 struct version<
1399   boost::multi_index_container<Value,IndexSpecifierList,Allocator>
1400 >
1401 {
1402   BOOST_STATIC_CONSTANT(int,value=2);
1403 };
1404 } /* namespace serialization */
1405 #endif
1406 
1407 /* Associated global functions are promoted to namespace boost, except
1408  * comparison operators and swap, which are meant to be Koenig looked-up.
1409  */
1410 
1411 using multi_index::get;
1412 using multi_index::project;
1413 
1414 } /* namespace boost */
1415 
1416 #undef BOOST_MULTI_INDEX_CHECK_INVARIANT
1417 #undef BOOST_MULTI_INDEX_CHECK_INVARIANT_OF
1418 
1419 #endif
1420