1//////////////////////////////////////////////////////////////////////////////
2//
3// (C) Copyright Ion Gaztanaga 2005-2013.
4// (C) Copyright Gennaro Prota 2003 - 2004.
5//
6// Distributed under the Boost Software License, Version 1.0.
7// (See accompanying file LICENSE_1_0.txt or copy at
8// http://www.boost.org/LICENSE_1_0.txt)
9//
10// See http://www.boost.org/libs/container for documentation.
11//
12//////////////////////////////////////////////////////////////////////////////
13
14#ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP
15#define BOOST_CONTAINER_DETAIL_ITERATORS_HPP
16
17#ifndef BOOST_CONFIG_HPP
18# include <boost/config.hpp>
19#endif
20
21#if defined(BOOST_HAS_PRAGMA_ONCE)
22# pragma once
23#endif
24
25#include <boost/container/detail/config_begin.hpp>
26#include <boost/container/detail/workaround.hpp>
27#include <boost/container/allocator_traits.hpp>
28#include <boost/container/detail/type_traits.hpp>
29#include <boost/container/detail/value_init.hpp>
30#include <boost/static_assert.hpp>
31#include <boost/move/utility_core.hpp>
32#include <boost/intrusive/detail/reverse_iterator.hpp>
33
34#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
35#include <boost/move/detail/fwd_macros.hpp>
36#else
37#include <boost/container/detail/variadic_templates_tools.hpp>
38#endif
39#include <boost/container/detail/iterator.hpp>
40
41namespace boost {
42namespace container {
43
44template <class T, class Difference = std::ptrdiff_t>
45class constant_iterator
46 : public ::boost::container::iterator
47 <std::random_access_iterator_tag, T, Difference, const T*, const T &>
48{
49 typedef constant_iterator<T, Difference> this_type;
50
51 public:
52 explicit constant_iterator(const T &ref, Difference range_size)
53 : m_ptr(&ref), m_num(range_size){}
54
55 //Constructors
56 constant_iterator()
57 : m_ptr(0), m_num(0){}
58
59 constant_iterator& operator++()
60 { increment(); return *this; }
61
62 constant_iterator operator++(int)
63 {
64 constant_iterator result (*this);
65 increment();
66 return result;
67 }
68
69 constant_iterator& operator--()
70 { decrement(); return *this; }
71
72 constant_iterator operator--(int)
73 {
74 constant_iterator result (*this);
75 decrement();
76 return result;
77 }
78
79 friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
80 { return i.equal(i2); }
81
82 friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
83 { return !(i == i2); }
84
85 friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
86 { return i.less(i2); }
87
88 friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
89 { return i2 < i; }
90
91 friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
92 { return !(i > i2); }
93
94 friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
95 { return !(i < i2); }
96
97 friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
98 { return i2.distance_to(i); }
99
100 //Arithmetic
101 constant_iterator& operator+=(Difference off)
102 { this->advance(off); return *this; }
103
104 constant_iterator operator+(Difference off) const
105 {
106 constant_iterator other(*this);
107 other.advance(off);
108 return other;
109 }
110
111 friend constant_iterator operator+(Difference off, const constant_iterator& right)
112 { return right + off; }
113
114 constant_iterator& operator-=(Difference off)
115 { this->advance(-off); return *this; }
116
117 constant_iterator operator-(Difference off) const
118 { return *this + (-off); }
119
120 const T& operator*() const
121 { return dereference(); }
122
123 const T& operator[] (Difference ) const
124 { return dereference(); }
125
126 const T* operator->() const
127 { return &(dereference()); }
128
129 private:
130 const T * m_ptr;
131 Difference m_num;
132
133 void increment()
134 { --m_num; }
135
136 void decrement()
137 { ++m_num; }
138
139 bool equal(const this_type &other) const
140 { return m_num == other.m_num; }
141
142 bool less(const this_type &other) const
143 { return other.m_num < m_num; }
144
145 const T & dereference() const
146 { return *m_ptr; }
147
148 void advance(Difference n)
149 { m_num -= n; }
150
151 Difference distance_to(const this_type &other)const
152 { return m_num - other.m_num; }
153};
154
155template <class T, class Difference>
156class value_init_construct_iterator
157 : public ::boost::container::iterator
158 <std::random_access_iterator_tag, T, Difference, const T*, const T &>
159{
160 typedef value_init_construct_iterator<T, Difference> this_type;
161
162 public:
163 explicit value_init_construct_iterator(Difference range_size)
164 : m_num(range_size){}
165
166 //Constructors
167 value_init_construct_iterator()
168 : m_num(0){}
169
170 value_init_construct_iterator& operator++()
171 { increment(); return *this; }
172
173 value_init_construct_iterator operator++(int)
174 {
175 value_init_construct_iterator result (*this);
176 increment();
177 return result;
178 }
179
180 value_init_construct_iterator& operator--()
181 { decrement(); return *this; }
182
183 value_init_construct_iterator operator--(int)
184 {
185 value_init_construct_iterator result (*this);
186 decrement();
187 return result;
188 }
189
190 friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
191 { return i.equal(i2); }
192
193 friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
194 { return !(i == i2); }
195
196 friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
197 { return i.less(i2); }
198
199 friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
200 { return i2 < i; }
201
202 friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
203 { return !(i > i2); }
204
205 friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
206 { return !(i < i2); }
207
208 friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
209 { return i2.distance_to(i); }
210
211 //Arithmetic
212 value_init_construct_iterator& operator+=(Difference off)
213 { this->advance(off); return *this; }
214
215 value_init_construct_iterator operator+(Difference off) const
216 {
217 value_init_construct_iterator other(*this);
218 other.advance(off);
219 return other;
220 }
221
222 friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
223 { return right + off; }
224
225 value_init_construct_iterator& operator-=(Difference off)
226 { this->advance(-off); return *this; }
227
228 value_init_construct_iterator operator-(Difference off) const
229 { return *this + (-off); }
230
231 //This pseudo-iterator's dereference operations have no sense since value is not
232 //constructed until ::boost::container::construct_in_place is called.
233 //So comment them to catch bad uses
234 //const T& operator*() const;
235 //const T& operator[](difference_type) const;
236 //const T* operator->() const;
237
238 private:
239 Difference m_num;
240
241 void increment()
242 { --m_num; }
243
244 void decrement()
245 { ++m_num; }
246
247 bool equal(const this_type &other) const
248 { return m_num == other.m_num; }
249
250 bool less(const this_type &other) const
251 { return other.m_num < m_num; }
252
253 const T & dereference() const
254 {
255 static T dummy;
256 return dummy;
257 }
258
259 void advance(Difference n)
260 { m_num -= n; }
261
262 Difference distance_to(const this_type &other)const
263 { return m_num - other.m_num; }
264};
265
266template <class T, class Difference>
267class default_init_construct_iterator
268 : public ::boost::container::iterator
269 <std::random_access_iterator_tag, T, Difference, const T*, const T &>
270{
271 typedef default_init_construct_iterator<T, Difference> this_type;
272
273 public:
274 explicit default_init_construct_iterator(Difference range_size)
275 : m_num(range_size){}
276
277 //Constructors
278 default_init_construct_iterator()
279 : m_num(0){}
280
281 default_init_construct_iterator& operator++()
282 { increment(); return *this; }
283
284 default_init_construct_iterator operator++(int)
285 {
286 default_init_construct_iterator result (*this);
287 increment();
288 return result;
289 }
290
291 default_init_construct_iterator& operator--()
292 { decrement(); return *this; }
293
294 default_init_construct_iterator operator--(int)
295 {
296 default_init_construct_iterator result (*this);
297 decrement();
298 return result;
299 }
300
301 friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
302 { return i.equal(i2); }
303
304 friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
305 { return !(i == i2); }
306
307 friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
308 { return i.less(i2); }
309
310 friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
311 { return i2 < i; }
312
313 friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
314 { return !(i > i2); }
315
316 friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
317 { return !(i < i2); }
318
319 friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
320 { return i2.distance_to(i); }
321
322 //Arithmetic
323 default_init_construct_iterator& operator+=(Difference off)
324 { this->advance(off); return *this; }
325
326 default_init_construct_iterator operator+(Difference off) const
327 {
328 default_init_construct_iterator other(*this);
329 other.advance(off);
330 return other;
331 }
332
333 friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
334 { return right + off; }
335
336 default_init_construct_iterator& operator-=(Difference off)
337 { this->advance(-off); return *this; }
338
339 default_init_construct_iterator operator-(Difference off) const
340 { return *this + (-off); }
341
342 //This pseudo-iterator's dereference operations have no sense since value is not
343 //constructed until ::boost::container::construct_in_place is called.
344 //So comment them to catch bad uses
345 //const T& operator*() const;
346 //const T& operator[](difference_type) const;
347 //const T* operator->() const;
348
349 private:
350 Difference m_num;
351
352 void increment()
353 { --m_num; }
354
355 void decrement()
356 { ++m_num; }
357
358 bool equal(const this_type &other) const
359 { return m_num == other.m_num; }
360
361 bool less(const this_type &other) const
362 { return other.m_num < m_num; }
363
364 const T & dereference() const
365 {
366 static T dummy;
367 return dummy;
368 }
369
370 void advance(Difference n)
371 { m_num -= n; }
372
373 Difference distance_to(const this_type &other)const
374 { return m_num - other.m_num; }
375};
376
377
378template <class T, class Difference = std::ptrdiff_t>
379class repeat_iterator
380 : public ::boost::container::iterator
381 <std::random_access_iterator_tag, T, Difference, T*, T&>
382{
383 typedef repeat_iterator<T, Difference> this_type;
384 public:
385 explicit repeat_iterator(T &ref, Difference range_size)
386 : m_ptr(&ref), m_num(range_size){}
387
388 //Constructors
389 repeat_iterator()
390 : m_ptr(0), m_num(0){}
391
392 this_type& operator++()
393 { increment(); return *this; }
394
395 this_type operator++(int)
396 {
397 this_type result (*this);
398 increment();
399 return result;
400 }
401
402 this_type& operator--()
403 { increment(); return *this; }
404
405 this_type operator--(int)
406 {
407 this_type result (*this);
408 increment();
409 return result;
410 }
411
412 friend bool operator== (const this_type& i, const this_type& i2)
413 { return i.equal(i2); }
414
415 friend bool operator!= (const this_type& i, const this_type& i2)
416 { return !(i == i2); }
417
418 friend bool operator< (const this_type& i, const this_type& i2)
419 { return i.less(i2); }
420
421 friend bool operator> (const this_type& i, const this_type& i2)
422 { return i2 < i; }
423
424 friend bool operator<= (const this_type& i, const this_type& i2)
425 { return !(i > i2); }
426
427 friend bool operator>= (const this_type& i, const this_type& i2)
428 { return !(i < i2); }
429
430 friend Difference operator- (const this_type& i, const this_type& i2)
431 { return i2.distance_to(i); }
432
433 //Arithmetic
434 this_type& operator+=(Difference off)
435 { this->advance(off); return *this; }
436
437 this_type operator+(Difference off) const
438 {
439 this_type other(*this);
440 other.advance(off);
441 return other;
442 }
443
444 friend this_type operator+(Difference off, const this_type& right)
445 { return right + off; }
446
447 this_type& operator-=(Difference off)
448 { this->advance(-off); return *this; }
449
450 this_type operator-(Difference off) const
451 { return *this + (-off); }
452
453 T& operator*() const
454 { return dereference(); }
455
456 T& operator[] (Difference ) const
457 { return dereference(); }
458
459 T *operator->() const
460 { return &(dereference()); }
461
462 private:
463 T * m_ptr;
464 Difference m_num;
465
466 void increment()
467 { --m_num; }
468
469 void decrement()
470 { ++m_num; }
471
472 bool equal(const this_type &other) const
473 { return m_num == other.m_num; }
474
475 bool less(const this_type &other) const
476 { return other.m_num < m_num; }
477
478 T & dereference() const
479 { return *m_ptr; }
480
481 void advance(Difference n)
482 { m_num -= n; }
483
484 Difference distance_to(const this_type &other)const
485 { return m_num - other.m_num; }
486};
487
488template <class T, class EmplaceFunctor, class Difference /*= std::ptrdiff_t*/>
489class emplace_iterator
490 : public ::boost::container::iterator
491 <std::random_access_iterator_tag, T, Difference, const T*, const T &>
492{
493 typedef emplace_iterator this_type;
494
495 public:
496 typedef Difference difference_type;
497 BOOST_CONTAINER_FORCEINLINE explicit emplace_iterator(EmplaceFunctor&e)
498 : m_num(1), m_pe(&e){}
499
500 BOOST_CONTAINER_FORCEINLINE emplace_iterator()
501 : m_num(0), m_pe(0){}
502
503 BOOST_CONTAINER_FORCEINLINE this_type& operator++()
504 { increment(); return *this; }
505
506 this_type operator++(int)
507 {
508 this_type result (*this);
509 increment();
510 return result;
511 }
512
513 BOOST_CONTAINER_FORCEINLINE this_type& operator--()
514 { decrement(); return *this; }
515
516 this_type operator--(int)
517 {
518 this_type result (*this);
519 decrement();
520 return result;
521 }
522
523 BOOST_CONTAINER_FORCEINLINE friend bool operator== (const this_type& i, const this_type& i2)
524 { return i.equal(i2); }
525
526 BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const this_type& i, const this_type& i2)
527 { return !(i == i2); }
528
529 BOOST_CONTAINER_FORCEINLINE friend bool operator< (const this_type& i, const this_type& i2)
530 { return i.less(i2); }
531
532 BOOST_CONTAINER_FORCEINLINE friend bool operator> (const this_type& i, const this_type& i2)
533 { return i2 < i; }
534
535 BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const this_type& i, const this_type& i2)
536 { return !(i > i2); }
537
538 BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const this_type& i, const this_type& i2)
539 { return !(i < i2); }
540
541 BOOST_CONTAINER_FORCEINLINE friend difference_type operator- (const this_type& i, const this_type& i2)
542 { return i2.distance_to(i); }
543
544 //Arithmetic
545 BOOST_CONTAINER_FORCEINLINE this_type& operator+=(difference_type off)
546 { this->advance(off); return *this; }
547
548 this_type operator+(difference_type off) const
549 {
550 this_type other(*this);
551 other.advance(off);
552 return other;
553 }
554
555 BOOST_CONTAINER_FORCEINLINE friend this_type operator+(difference_type off, const this_type& right)
556 { return right + off; }
557
558 BOOST_CONTAINER_FORCEINLINE this_type& operator-=(difference_type off)
559 { this->advance(-off); return *this; }
560
561 BOOST_CONTAINER_FORCEINLINE this_type operator-(difference_type off) const
562 { return *this + (-off); }
563
564 private:
565 //This pseudo-iterator's dereference operations have no sense since value is not
566 //constructed until ::boost::container::construct_in_place is called.
567 //So comment them to catch bad uses
568 const T& operator*() const;
569 const T& operator[](difference_type) const;
570 const T* operator->() const;
571
572 public:
573 template<class Allocator>
574 void construct_in_place(Allocator &a, T* ptr)
575 { (*m_pe)(a, ptr); }
576
577 template<class DestIt>
578 void assign_in_place(DestIt dest)
579 { (*m_pe)(dest); }
580
581 private:
582 difference_type m_num;
583 EmplaceFunctor * m_pe;
584
585 BOOST_CONTAINER_FORCEINLINE void increment()
586 { --m_num; }
587
588 BOOST_CONTAINER_FORCEINLINE void decrement()
589 { ++m_num; }
590
591 BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
592 { return m_num == other.m_num; }
593
594 BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
595 { return other.m_num < m_num; }
596
597 BOOST_CONTAINER_FORCEINLINE const T & dereference() const
598 {
599 static T dummy;
600 return dummy;
601 }
602
603 BOOST_CONTAINER_FORCEINLINE void advance(difference_type n)
604 { m_num -= n; }
605
606 BOOST_CONTAINER_FORCEINLINE difference_type distance_to(const this_type &other)const
607 { return difference_type(m_num - other.m_num); }
608};
609
610#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
611
612template<class ...Args>
613struct emplace_functor
614{
615 typedef typename container_detail::build_number_seq<sizeof...(Args)>::type index_tuple_t;
616
617 emplace_functor(BOOST_FWD_REF(Args)... args)
618 : args_(args...)
619 {}
620
621 template<class Allocator, class T>
622 BOOST_CONTAINER_FORCEINLINE void operator()(Allocator &a, T *ptr)
623 { emplace_functor::inplace_impl(a, ptr, index_tuple_t()); }
624
625 template<class DestIt>
626 BOOST_CONTAINER_FORCEINLINE void operator()(DestIt dest)
627 { emplace_functor::inplace_impl(dest, index_tuple_t()); }
628
629 private:
630 template<class Allocator, class T, std::size_t ...IdxPack>
631 BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const container_detail::index_tuple<IdxPack...>&)
632 {
633 allocator_traits<Allocator>::construct
634 (a, ptr, ::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
635 }
636
637 template<class DestIt, std::size_t ...IdxPack>
638 BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const container_detail::index_tuple<IdxPack...>&)
639 {
640 typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;
641 value_type && tmp= value_type(::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
642 *dest = ::boost::move(tmp);
643 }
644
645 container_detail::tuple<Args&...> args_;
646};
647
648template<class ...Args>
649struct emplace_functor_type
650{
651 typedef emplace_functor<Args...> type;
652};
653
654#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
655
656//Partial specializations cannot match argument list for primary template, so add an extra argument
657template <BOOST_MOVE_CLASSDFLT9, class Dummy = void>
658struct emplace_functor_type;
659
660#define BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE(N) \
661BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
662struct emplace_functor##N\
663{\
664 explicit emplace_functor##N( BOOST_MOVE_UREF##N )\
665 BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N{}\
666 \
667 template<class Allocator, class T>\
668 void operator()(Allocator &a, T *ptr)\
669 { allocator_traits<Allocator>::construct(a, ptr BOOST_MOVE_I##N BOOST_MOVE_MFWD##N); }\
670 \
671 template<class DestIt>\
672 void operator()(DestIt dest)\
673 {\
674 typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;\
675 BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), container_detail::value_init<value_type> tmp) ;\
676 *dest = ::boost::move(const_cast<value_type &>(BOOST_MOVE_IF(N, tmp, tmp.get())));\
677 }\
678 \
679 BOOST_MOVE_MREF##N\
680};\
681\
682template <BOOST_MOVE_CLASS##N>\
683struct emplace_functor_type<BOOST_MOVE_TARG##N>\
684{\
685 typedef emplace_functor##N BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N type;\
686};\
687//
688
689BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE)
690
691#undef BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE
692
693#endif
694
695namespace container_detail {
696
697template<class T>
698struct has_iterator_category
699{
700 struct two { char _[2]; };
701
702 template <typename X>
703 static char test(int, typename X::iterator_category*);
704
705 template <typename X>
706 static two test(int, ...);
707
708 static const bool value = (1 == sizeof(test<T>(0, 0)));
709};
710
711
712template<class T, bool = has_iterator_category<T>::value >
713struct is_input_iterator
714{
715 static const bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
716};
717
718template<class T>
719struct is_input_iterator<T, false>
720{
721 static const bool value = false;
722};
723
724template<class T>
725struct is_not_input_iterator
726{
727 static const bool value = !is_input_iterator<T>::value;
728};
729
730template<class T, bool = has_iterator_category<T>::value >
731struct is_forward_iterator
732{
733 static const bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
734};
735
736template<class T>
737struct is_forward_iterator<T, false>
738{
739 static const bool value = false;
740};
741
742template<class T, bool = has_iterator_category<T>::value >
743struct is_bidirectional_iterator
744{
745 static const bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
746};
747
748template<class T>
749struct is_bidirectional_iterator<T, false>
750{
751 static const bool value = false;
752};
753
754template<class IINodeType>
755struct iiterator_node_value_type {
756 typedef typename IINodeType::value_type type;
757};
758
759template<class IIterator>
760struct iiterator_types
761{
762 typedef typename IIterator::value_type it_value_type;
763 typedef typename iiterator_node_value_type<it_value_type>::type value_type;
764 typedef typename boost::container::iterator_traits<IIterator>::pointer it_pointer;
765 typedef typename boost::container::iterator_traits<IIterator>::difference_type difference_type;
766 typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
767 template rebind_pointer<value_type>::type pointer;
768 typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
769 template rebind_pointer<const value_type>::type const_pointer;
770 typedef typename ::boost::intrusive::
771 pointer_traits<pointer>::reference reference;
772 typedef typename ::boost::intrusive::
773 pointer_traits<const_pointer>::reference const_reference;
774 typedef typename IIterator::iterator_category iterator_category;
775};
776
777template<class IIterator, bool IsConst>
778struct iterator_types
779{
780 typedef typename ::boost::container::iterator
781 < typename iiterator_types<IIterator>::iterator_category
782 , typename iiterator_types<IIterator>::value_type
783 , typename iiterator_types<IIterator>::difference_type
784 , typename iiterator_types<IIterator>::const_pointer
785 , typename iiterator_types<IIterator>::const_reference> type;
786};
787
788template<class IIterator>
789struct iterator_types<IIterator, false>
790{
791 typedef typename ::boost::container::iterator
792 < typename iiterator_types<IIterator>::iterator_category
793 , typename iiterator_types<IIterator>::value_type
794 , typename iiterator_types<IIterator>::difference_type
795 , typename iiterator_types<IIterator>::pointer
796 , typename iiterator_types<IIterator>::reference> type;
797};
798
799template<class IIterator, bool IsConst>
800class iterator_from_iiterator
801{
802 typedef typename iterator_types<IIterator, IsConst>::type types_t;
803
804 public:
805 typedef typename types_t::pointer pointer;
806 typedef typename types_t::reference reference;
807 typedef typename types_t::difference_type difference_type;
808 typedef typename types_t::iterator_category iterator_category;
809 typedef typename types_t::value_type value_type;
810
811 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator()
812 : m_iit()
813 {}
814
815 BOOST_CONTAINER_FORCEINLINE explicit iterator_from_iiterator(IIterator iit) BOOST_NOEXCEPT_OR_NOTHROW
816 : m_iit(iit)
817 {}
818
819 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(iterator_from_iiterator<IIterator, false> const& other) BOOST_NOEXCEPT_OR_NOTHROW
820 : m_iit(other.get())
821 {}
822
823 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
824 { ++this->m_iit; return *this; }
825
826 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
827 {
828 iterator_from_iiterator result (*this);
829 ++this->m_iit;
830 return result;
831 }
832
833 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
834 {
835 //If the iterator_from_iiterator is not a bidirectional iterator, operator-- should not exist
836 BOOST_STATIC_ASSERT((is_bidirectional_iterator<iterator_from_iiterator>::value));
837 --this->m_iit; return *this;
838 }
839
840 BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
841 {
842 iterator_from_iiterator result (*this);
843 --this->m_iit;
844 return result;
845 }
846
847 BOOST_CONTAINER_FORCEINLINE friend bool operator== (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
848 { return l.m_iit == r.m_iit; }
849
850 BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
851 { return !(l == r); }
852
853 BOOST_CONTAINER_FORCEINLINE reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW
854 { return this->m_iit->get_data(); }
855
856 BOOST_CONTAINER_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW
857 { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*()); }
858
859 BOOST_CONTAINER_FORCEINLINE const IIterator &get() const BOOST_NOEXCEPT_OR_NOTHROW
860 { return this->m_iit; }
861
862 private:
863 IIterator m_iit;
864};
865
866} //namespace container_detail {
867
868using ::boost::intrusive::reverse_iterator;
869
870} //namespace container {
871} //namespace boost {
872
873#include <boost/container/detail/config_end.hpp>
874
875#endif //#ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP
876