1 /* Copyright 2003-2018 Joaquin M Lopez Munoz.
2 * Distributed under the Boost Software License, Version 1.0.
3 * (See accompanying file LICENSE_1_0.txt or copy at
4 * http://www.boost.org/LICENSE_1_0.txt)
6 * See http://www.boost.org/libs/multi_index for library home page.
9 #ifndef BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
10 #define BOOST_MULTI_INDEX_RANDOM_ACCESS_INDEX_HPP
16 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
18 #include <boost/bind.hpp>
19 #include <boost/call_traits.hpp>
20 #include <boost/core/addressof.hpp>
21 #include <boost/detail/no_exceptions_support.hpp>
22 #include <boost/detail/workaround.hpp>
23 #include <boost/foreach_fwd.hpp>
24 #include <boost/iterator/reverse_iterator.hpp>
25 #include <boost/move/core.hpp>
26 #include <boost/move/utility.hpp>
27 #include <boost/mpl/bool.hpp>
28 #include <boost/mpl/not.hpp>
29 #include <boost/mpl/push_front.hpp>
30 #include <boost/multi_index/detail/access_specifier.hpp>
31 #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
32 #include <boost/multi_index/detail/index_node_base.hpp>
33 #include <boost/multi_index/detail/rnd_node_iterator.hpp>
34 #include <boost/multi_index/detail/rnd_index_node.hpp>
35 #include <boost/multi_index/detail/rnd_index_ops.hpp>
36 #include <boost/multi_index/detail/rnd_index_ptr_array.hpp>
37 #include <boost/multi_index/detail/safe_mode.hpp>
38 #include <boost/multi_index/detail/scope_guard.hpp>
39 #include <boost/multi_index/detail/vartempl_support.hpp>
40 #include <boost/multi_index/random_access_index_fwd.hpp>
41 #include <boost/throw_exception.hpp>
42 #include <boost/tuple/tuple.hpp>
43 #include <boost/type_traits/is_integral.hpp>
50 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
51 #include<initializer_list>
54 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
55 #include <boost/multi_index/detail/rnd_index_loader.hpp>
58 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
59 #define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x) \
60 detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)= \
61 detail::make_obj_guard(x,&random_access_index::check_invariant_); \
62 BOOST_JOIN(check_invariant_,__LINE__).touch();
63 #define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT \
64 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(*this)
66 #define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x)
67 #define BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
72 namespace multi_index{
76 /* random_access_index adds a layer of random access indexing
80 template<typename SuperMeta,typename TagList>
81 class random_access_index:
82 BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
84 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
85 ,public safe_mode::safe_container<
86 random_access_index<SuperMeta,TagList> >
90 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
91 BOOST_WORKAROUND(__MWERKS__,<=0x3003)
92 /* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
93 * lifetime of const references bound to temporaries --precisely what
97 #pragma parse_mfunc_templ off
100 typedef typename SuperMeta::type super;
103 typedef random_access_index_node<
104 typename super::node_type> node_type;
107 typedef typename node_type::impl_type node_impl_type;
108 typedef random_access_index_ptr_array<
109 typename super::final_allocator_type> ptr_array;
110 typedef typename ptr_array::pointer node_impl_ptr_pointer;
115 typedef typename node_type::value_type value_type;
116 typedef tuples::null_type ctor_args;
117 typedef typename super::final_allocator_type allocator_type;
118 #ifdef BOOST_NO_CXX11_ALLOCATOR
119 typedef typename allocator_type::reference reference;
120 typedef typename allocator_type::const_reference const_reference;
122 typedef value_type& reference;
123 typedef const value_type& const_reference;
126 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
127 typedef safe_mode::safe_iterator<
128 rnd_node_iterator<node_type>,
129 random_access_index> iterator;
131 typedef rnd_node_iterator<node_type> iterator;
134 typedef iterator const_iterator;
136 typedef std::size_t size_type;
137 typedef std::ptrdiff_t difference_type;
138 #ifdef BOOST_NO_CXX11_ALLOCATOR
139 typedef typename allocator_type::pointer pointer;
140 typedef typename allocator_type::const_pointer const_pointer;
142 typedef std::allocator_traits<allocator_type> allocator_traits;
143 typedef typename allocator_traits::pointer pointer;
144 typedef typename allocator_traits::const_pointer const_pointer;
147 boost::reverse_iterator<iterator> reverse_iterator;
149 boost::reverse_iterator<const_iterator> const_reverse_iterator;
150 typedef TagList tag_list;
153 typedef typename super::final_node_type final_node_type;
154 typedef tuples::cons<
156 typename super::ctor_args_list> ctor_args_list;
157 typedef typename mpl::push_front<
158 typename super::index_type_list,
159 random_access_index>::type index_type_list;
160 typedef typename mpl::push_front<
161 typename super::iterator_type_list,
162 iterator>::type iterator_type_list;
163 typedef typename mpl::push_front<
164 typename super::const_iterator_type_list,
165 const_iterator>::type const_iterator_type_list;
166 typedef typename super::copy_map_type copy_map_type;
168 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
169 typedef typename super::index_saver_type index_saver_type;
170 typedef typename super::index_loader_type index_loader_type;
174 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
175 typedef safe_mode::safe_container<
176 random_access_index> safe_super;
179 typedef typename call_traits<
180 value_type>::param_type value_param_type;
182 /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
186 typedef std::pair<iterator,bool> emplace_return_type;
190 /* construct/copy/destroy
191 * Default and copy ctors are in the protected section as indices are
192 * not supposed to be created on their own. No range ctor either.
195 random_access_index<SuperMeta,TagList>& operator=(
196 const random_access_index<SuperMeta,TagList>& x)
198 this->final()=x.final();
202 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
203 random_access_index<SuperMeta,TagList>& operator=(
204 std::initializer_list<value_type> list)
211 template <class InputIterator>
212 void assign(InputIterator first,InputIterator last)
214 assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
217 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
218 void assign(std::initializer_list<value_type> list)
220 assign(list.begin(),list.end());
224 void assign(size_type n,value_param_type value)
226 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
228 for(size_type i=0;i<n;++i)push_back(value);
231 allocator_type get_allocator()const BOOST_NOEXCEPT
233 return this->final().get_allocator();
238 iterator begin()BOOST_NOEXCEPT
239 {return make_iterator(node_type::from_impl(*ptrs.begin()));}
240 const_iterator begin()const BOOST_NOEXCEPT
241 {return make_iterator(node_type::from_impl(*ptrs.begin()));}
243 end()BOOST_NOEXCEPT{return make_iterator(header());}
245 end()const BOOST_NOEXCEPT{return make_iterator(header());}
247 rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
248 const_reverse_iterator
249 rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
251 rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
252 const_reverse_iterator
253 rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
255 cbegin()const BOOST_NOEXCEPT{return begin();}
257 cend()const BOOST_NOEXCEPT{return end();}
258 const_reverse_iterator
259 crbegin()const BOOST_NOEXCEPT{return rbegin();}
260 const_reverse_iterator
261 crend()const BOOST_NOEXCEPT{return rend();}
263 iterator iterator_to(const value_type& x)
265 return make_iterator(node_from_value<node_type>(boost::addressof(x)));
268 const_iterator iterator_to(const value_type& x)const
270 return make_iterator(node_from_value<node_type>(boost::addressof(x)));
275 bool empty()const BOOST_NOEXCEPT{return this->final_empty_();}
276 size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
277 size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
278 size_type capacity()const BOOST_NOEXCEPT{return ptrs.capacity();}
280 void reserve(size_type n)
282 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
288 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
289 ptrs.shrink_to_fit();
292 void resize(size_type n)
294 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
296 for(size_type m=n-size();m--;)
297 this->final_emplace_(BOOST_MULTI_INDEX_NULL_PARAM_PACK);
298 else if(n<size())erase(begin()+n,end());
301 void resize(size_type n,value_param_type x)
303 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
304 if(n>size())for(size_type m=n-size();m--;)this->final_insert_(x);
305 else if(n<size())erase(begin()+n,end());
308 /* access: no non-const versions provided as random_access_index
309 * handles const elements.
312 const_reference operator[](size_type n)const
314 BOOST_MULTI_INDEX_SAFE_MODE_ASSERT(n<size(),safe_mode::out_of_bounds);
315 return node_type::from_impl(*ptrs.at(n))->value();
318 const_reference at(size_type n)const
320 if(n>=size())throw_exception(std::out_of_range("random access index"));
321 return node_type::from_impl(*ptrs.at(n))->value();
324 const_reference front()const{return operator[](0);}
325 const_reference back()const{return operator[](size()-1);}
329 BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
330 emplace_return_type,emplace_front,emplace_front_impl)
332 std::pair<iterator,bool> push_front(const value_type& x)
333 {return insert(begin(),x);}
334 std::pair<iterator,bool> push_front(BOOST_RV_REF(value_type) x)
335 {return insert(begin(),boost::move(x));}
336 void pop_front(){erase(begin());}
338 BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
339 emplace_return_type,emplace_back,emplace_back_impl)
341 std::pair<iterator,bool> push_back(const value_type& x)
342 {return insert(end(),x);}
343 std::pair<iterator,bool> push_back(BOOST_RV_REF(value_type) x)
344 {return insert(end(),boost::move(x));}
345 void pop_back(){erase(--end());}
347 BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
348 emplace_return_type,emplace,emplace_impl,iterator,position)
350 std::pair<iterator,bool> insert(iterator position,const value_type& x)
352 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
353 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
354 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
355 std::pair<final_node_type*,bool> p=this->final_insert_(x);
356 if(p.second&&position.get_node()!=header()){
357 relocate(position.get_node(),p.first);
359 return std::pair<iterator,bool>(make_iterator(p.first),p.second);
362 std::pair<iterator,bool> insert(iterator position,BOOST_RV_REF(value_type) x)
364 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
365 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
366 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
367 std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
368 if(p.second&&position.get_node()!=header()){
369 relocate(position.get_node(),p.first);
371 return std::pair<iterator,bool>(make_iterator(p.first),p.second);
374 void insert(iterator position,size_type n,value_param_type x)
376 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
377 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
378 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
382 if(push_back(x).second)++s;
386 relocate(position,end()-s,end());
390 relocate(position,end()-s,end());
393 template<typename InputIterator>
394 void insert(iterator position,InputIterator first,InputIterator last)
396 insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
399 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
400 void insert(iterator position,std::initializer_list<value_type> list)
402 insert(position,list.begin(),list.end());
406 iterator erase(iterator position)
408 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
409 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
410 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
411 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
412 this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
416 iterator erase(iterator first,iterator last)
418 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
419 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
420 BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
421 BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
422 BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
423 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
424 difference_type n=last-first;
425 relocate(end(),first,last);
426 while(n--)pop_back();
430 bool replace(iterator position,const value_type& x)
432 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
433 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
434 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
435 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
436 return this->final_replace_(
437 x,static_cast<final_node_type*>(position.get_node()));
440 bool replace(iterator position,BOOST_RV_REF(value_type) x)
442 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
443 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
444 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
445 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
446 return this->final_replace_rv_(
447 x,static_cast<final_node_type*>(position.get_node()));
450 template<typename Modifier>
451 bool modify(iterator position,Modifier mod)
453 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
454 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
455 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
456 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
458 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
459 /* MSVC++ 6.0 optimizer on safe mode code chokes if this
460 * this is not added. Left it for all compilers as it does no
467 return this->final_modify_(
468 mod,static_cast<final_node_type*>(position.get_node()));
471 template<typename Modifier,typename Rollback>
472 bool modify(iterator position,Modifier mod,Rollback back_)
474 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
475 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
476 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
477 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
479 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
480 /* MSVC++ 6.0 optimizer on safe mode code chokes if this
481 * this is not added. Left it for all compilers as it does no
488 return this->final_modify_(
489 mod,back_,static_cast<final_node_type*>(position.get_node()));
492 void swap(random_access_index<SuperMeta,TagList>& x)
494 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
495 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF(x);
496 this->final_swap_(x.final());
499 void clear()BOOST_NOEXCEPT
501 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
502 this->final_clear_();
505 /* list operations */
507 void splice(iterator position,random_access_index<SuperMeta,TagList>& x)
509 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
510 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
511 BOOST_MULTI_INDEX_CHECK_DIFFERENT_CONTAINER(*this,x);
512 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
513 iterator first=x.begin(),last=x.end();
517 if(push_back(*first).second){
518 first=x.erase(first);
525 relocate(position,end()-n,end());
529 relocate(position,end()-n,end());
533 iterator position,random_access_index<SuperMeta,TagList>& x,iterator i)
535 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
536 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
537 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
538 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
539 BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,x);
540 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
541 if(&x==this)relocate(position,i);
543 if(insert(position,*i).second){
545 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
546 /* MSVC++ 6.0 optimizer has a hard time with safe mode, and the following
547 * workaround is needed. Left it for all compilers as it does no
551 x.erase(x.make_iterator(i.get_node()));
561 iterator position,random_access_index<SuperMeta,TagList>& x,
562 iterator first,iterator last)
564 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
565 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
566 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
567 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
568 BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,x);
569 BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,x);
570 BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
571 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
572 if(&x==this)relocate(position,first,last);
577 if(push_back(*first).second){
578 first=x.erase(first);
585 relocate(position,end()-n,end());
589 relocate(position,end()-n,end());
593 void remove(value_param_type value)
595 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
598 random_access_index_remove<node_type>(
600 ::boost::bind(std::equal_to<value_type>(),::boost::arg<1>(),value)));
601 while(n--)pop_back();
604 template<typename Predicate>
605 void remove_if(Predicate pred)
607 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
609 end()-make_iterator(random_access_index_remove<node_type>(ptrs,pred));
610 while(n--)pop_back();
615 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
618 random_access_index_unique<node_type>(
619 ptrs,std::equal_to<value_type>()));
620 while(n--)pop_back();
623 template <class BinaryPredicate>
624 void unique(BinaryPredicate binary_pred)
626 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
629 random_access_index_unique<node_type>(ptrs,binary_pred));
630 while(n--)pop_back();
633 void merge(random_access_index<SuperMeta,TagList>& x)
636 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
639 random_access_index_inplace_merge<node_type>(
640 get_allocator(),ptrs,ptrs.at(s),std::less<value_type>());
644 template <typename Compare>
645 void merge(random_access_index<SuperMeta,TagList>& x,Compare comp)
648 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
651 random_access_index_inplace_merge<node_type>(
652 get_allocator(),ptrs,ptrs.at(s),comp);
658 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
659 random_access_index_sort<node_type>(
660 get_allocator(),ptrs,std::less<value_type>());
663 template <typename Compare>
664 void sort(Compare comp)
666 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
667 random_access_index_sort<node_type>(
668 get_allocator(),ptrs,comp);
671 void reverse()BOOST_NOEXCEPT
673 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
674 node_impl_type::reverse(ptrs.begin(),ptrs.end());
677 /* rearrange operations */
679 void relocate(iterator position,iterator i)
681 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
682 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
683 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(i);
684 BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(i);
685 BOOST_MULTI_INDEX_CHECK_IS_OWNER(i,*this);
686 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
687 if(position!=i)relocate(position.get_node(),i.get_node());
690 void relocate(iterator position,iterator first,iterator last)
692 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
693 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
694 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
695 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
696 BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
697 BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
698 BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
699 BOOST_MULTI_INDEX_CHECK_OUTSIDE_RANGE(position,first,last);
700 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
701 if(position!=last)relocate(
702 position.get_node(),first.get_node(),last.get_node());
705 template<typename InputIterator>
706 void rearrange(InputIterator first)
708 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
709 for(node_impl_ptr_pointer p0=ptrs.begin(),p0_end=ptrs.end();
710 p0!=p0_end;++first,++p0){
711 const value_type& v1=*first;
712 node_impl_ptr_pointer p1=node_from_value<node_type>(&v1)->up();
720 BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
722 const ctor_args_list& args_list,const allocator_type& al):
723 super(args_list.get_tail(),al),
724 ptrs(al,header()->impl(),0)
728 random_access_index(const random_access_index<SuperMeta,TagList>& x):
731 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
735 ptrs(x.get_allocator(),header()->impl(),x.size())
737 /* The actual copying takes place in subsequent call to copy_().
742 const random_access_index<SuperMeta,TagList>& x,do_not_copy_elements_tag):
743 super(x,do_not_copy_elements_tag()),
745 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
749 ptrs(x.get_allocator(),header()->impl(),0)
753 ~random_access_index()
755 /* the container is guaranteed to be empty by now */
758 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
759 iterator make_iterator(node_type* node){return iterator(node,this);}
760 const_iterator make_iterator(node_type* node)const
761 {return const_iterator(node,const_cast<random_access_index*>(this));}
763 iterator make_iterator(node_type* node){return iterator(node);}
764 const_iterator make_iterator(node_type* node)const
765 {return const_iterator(node);}
769 const random_access_index<SuperMeta,TagList>& x,const copy_map_type& map)
771 for(node_impl_ptr_pointer begin_org=x.ptrs.begin(),
772 begin_cpy=ptrs.begin(),
773 end_org=x.ptrs.end();
774 begin_org!=end_org;++begin_org,++begin_cpy){
776 static_cast<node_type*>(
778 static_cast<final_node_type*>(
779 node_type::from_impl(*begin_org))))->impl();
780 (*begin_cpy)->up()=begin_cpy;
786 template<typename Variant>
787 final_node_type* insert_(
788 value_param_type v,final_node_type*& x,Variant variant)
791 final_node_type* res=super::insert_(v,x,variant);
792 if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
796 template<typename Variant>
797 final_node_type* insert_(
798 value_param_type v,node_type* position,final_node_type*& x,Variant variant)
801 final_node_type* res=super::insert_(v,position,x,variant);
802 if(res==x)ptrs.push_back(static_cast<node_type*>(x)->impl());
806 void erase_(node_type* x)
808 ptrs.erase(x->impl());
811 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
816 void delete_all_nodes_()
818 for(node_impl_ptr_pointer x=ptrs.begin(),x_end=ptrs.end();x!=x_end;++x){
819 this->final_delete_node_(
820 static_cast<final_node_type*>(node_type::from_impl(*x)));
829 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
830 safe_super::detach_dereferenceable_iterators();
834 void swap_(random_access_index<SuperMeta,TagList>& x)
838 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
845 void swap_elements_(random_access_index<SuperMeta,TagList>& x)
849 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
853 super::swap_elements_(x);
856 template<typename Variant>
857 bool replace_(value_param_type v,node_type* x,Variant variant)
859 return super::replace_(v,x,variant);
862 bool modify_(node_type* x)
865 if(!super::modify_(x)){
866 ptrs.erase(x->impl());
868 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
877 ptrs.erase(x->impl());
879 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
888 bool modify_rollback_(node_type* x)
890 return super::modify_rollback_(x);
893 bool check_rollback_(node_type* x)const
895 return super::check_rollback_(x);
898 #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
901 template<typename Archive>
903 Archive& ar,const unsigned int version,const index_saver_type& sm)const
905 sm.save(begin(),end(),ar,version);
906 super::save_(ar,version,sm);
909 template<typename Archive>
911 Archive& ar,const unsigned int version,const index_loader_type& lm)
914 typedef random_access_index_loader<node_type,allocator_type> loader;
916 loader ld(get_allocator(),ptrs);
919 &loader::rearrange,&ld,::boost::arg<1>(),::boost::arg<2>()),
921 } /* exit scope so that ld frees its resources */
922 super::load_(ar,version,lm);
926 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
927 /* invariant stuff */
929 bool invariant_()const
931 if(size()>capacity())return false;
932 if(size()==0||begin()==end()){
933 if(size()!=0||begin()!=end())return false;
937 for(const_iterator it=begin(),it_end=end();;++it,++s){
938 if(*(it.get_node()->up())!=it.get_node()->impl())return false;
941 if(s!=size())return false;
944 return super::invariant_();
947 /* This forwarding function eases things for the boost::mem_fn construct
948 * in BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT. Actually,
949 * final_check_invariant is already an inherited member function of index.
951 void check_invariant_()const{this->final_check_invariant_();}
955 node_type* header()const{return this->final_header();}
957 static void relocate(node_type* position,node_type* x)
959 node_impl_type::relocate(position->up(),x->up());
962 static void relocate(node_type* position,node_type* first,node_type* last)
964 node_impl_type::relocate(
965 position->up(),first->up(),last->up());
968 #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
969 void detach_iterators(node_type* x)
971 iterator it=make_iterator(x);
972 safe_mode::detach_equivalent_iterators(it);
976 template <class InputIterator>
977 void assign_iter(InputIterator first,InputIterator last,mpl::true_)
979 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
981 for(;first!=last;++first)this->final_insert_ref_(*first);
984 void assign_iter(size_type n,value_param_type value,mpl::false_)
986 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
988 for(size_type i=0;i<n;++i)push_back(value);
991 template<typename InputIterator>
993 iterator position,InputIterator first,InputIterator last,mpl::true_)
995 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
998 for(;first!=last;++first){
999 if(this->final_insert_ref_(*first).second)++s;
1003 relocate(position,end()-s,end());
1007 relocate(position,end()-s,end());
1011 iterator position,size_type n,value_param_type x,mpl::false_)
1013 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
1014 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
1015 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
1019 if(push_back(x).second)++s;
1023 relocate(position,end()-s,end());
1027 relocate(position,end()-s,end());
1030 template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
1031 std::pair<iterator,bool> emplace_front_impl(
1032 BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
1034 return emplace_impl(begin(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
1037 template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
1038 std::pair<iterator,bool> emplace_back_impl(
1039 BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
1041 return emplace_impl(end(),BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
1044 template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
1045 std::pair<iterator,bool> emplace_impl(
1046 iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
1048 BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
1049 BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
1050 BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT;
1051 std::pair<final_node_type*,bool> p=
1052 this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
1053 if(p.second&&position.get_node()!=header()){
1054 relocate(position.get_node(),p.first);
1056 return std::pair<iterator,bool>(make_iterator(p.first),p.second);
1061 #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
1062 BOOST_WORKAROUND(__MWERKS__,<=0x3003)
1063 #pragma parse_mfunc_templ reset
1070 typename SuperMeta1,typename TagList1,
1071 typename SuperMeta2,typename TagList2
1074 const random_access_index<SuperMeta1,TagList1>& x,
1075 const random_access_index<SuperMeta2,TagList2>& y)
1077 return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
1081 typename SuperMeta1,typename TagList1,
1082 typename SuperMeta2,typename TagList2
1085 const random_access_index<SuperMeta1,TagList1>& x,
1086 const random_access_index<SuperMeta2,TagList2>& y)
1088 return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
1092 typename SuperMeta1,typename TagList1,
1093 typename SuperMeta2,typename TagList2
1096 const random_access_index<SuperMeta1,TagList1>& x,
1097 const random_access_index<SuperMeta2,TagList2>& y)
1103 typename SuperMeta1,typename TagList1,
1104 typename SuperMeta2,typename TagList2
1107 const random_access_index<SuperMeta1,TagList1>& x,
1108 const random_access_index<SuperMeta2,TagList2>& y)
1114 typename SuperMeta1,typename TagList1,
1115 typename SuperMeta2,typename TagList2
1118 const random_access_index<SuperMeta1,TagList1>& x,
1119 const random_access_index<SuperMeta2,TagList2>& y)
1125 typename SuperMeta1,typename TagList1,
1126 typename SuperMeta2,typename TagList2
1129 const random_access_index<SuperMeta1,TagList1>& x,
1130 const random_access_index<SuperMeta2,TagList2>& y)
1135 /* specialized algorithms */
1137 template<typename SuperMeta,typename TagList>
1139 random_access_index<SuperMeta,TagList>& x,
1140 random_access_index<SuperMeta,TagList>& y)
1145 } /* namespace multi_index::detail */
1147 /* random access index specifier */
1149 template <typename TagList>
1150 struct random_access
1152 BOOST_STATIC_ASSERT(detail::is_tag<TagList>::value);
1154 template<typename Super>
1157 typedef detail::random_access_index_node<Super> type;
1160 template<typename SuperMeta>
1163 typedef detail::random_access_index<
1164 SuperMeta,typename TagList::type> type;
1168 } /* namespace multi_index */
1170 } /* namespace boost */
1172 /* Boost.Foreach compatibility */
1174 template<typename SuperMeta,typename TagList>
1175 inline boost::mpl::true_* boost_foreach_is_noncopyable(
1176 boost::multi_index::detail::random_access_index<SuperMeta,TagList>*&,
1177 boost_foreach_argument_dependent_lookup_hack)
1182 #undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT
1183 #undef BOOST_MULTI_INDEX_RND_INDEX_CHECK_INVARIANT_OF