1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2005-2013. // (C) Copyright Gennaro Prota 2003 - 2004. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/container for documentation. // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP #define BOOST_CONTAINER_DETAIL_ITERATORS_HPP #ifndef BOOST_CONFIG_HPP # include #endif #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif #include #include #include #include #include #include #include #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) #include #else #include #endif #include namespace boost { namespace container { template class constant_iterator : public ::boost::container::iterator { typedef constant_iterator this_type; public: inline explicit constant_iterator(const T &ref, std::size_t range_size) : m_ptr(&ref), m_num(range_size){} //Constructors inline constant_iterator() : m_ptr(0), m_num(0){} inline constant_iterator& operator++() { increment(); return *this; } inline constant_iterator operator++(int) { constant_iterator result (*this); increment(); return result; } inline constant_iterator& operator--() { decrement(); return *this; } inline constant_iterator operator--(int) { constant_iterator result (*this); decrement(); return result; } inline friend bool operator== (const constant_iterator& i, const constant_iterator& i2) { return i.equal(i2); } inline friend bool operator!= (const constant_iterator& i, const constant_iterator& i2) { return !(i == i2); } inline friend bool operator< (const constant_iterator& i, const constant_iterator& i2) { return i.less(i2); } inline friend bool operator> (const constant_iterator& i, const constant_iterator& i2) { return i2 < i; } inline friend bool operator<= (const constant_iterator& i, const constant_iterator& i2) { return !(i > i2); } inline friend bool operator>= (const constant_iterator& i, const constant_iterator& i2) { return !(i < i2); } inline friend std::ptrdiff_t operator- (const constant_iterator& i, const constant_iterator& i2) { return i2.distance_to(i); } //Arithmetic signed inline constant_iterator& operator+=(std::ptrdiff_t off) { this->advance(off); return *this; } inline constant_iterator operator+(std::ptrdiff_t off) const { constant_iterator other(*this); other.advance(off); return other; } inline friend constant_iterator operator+(std::ptrdiff_t off, const constant_iterator& right) { return right + off; } inline constant_iterator& operator-=(std::ptrdiff_t off) { this->advance(-off); return *this; } inline constant_iterator operator-(std::ptrdiff_t off) const { return *this + (-off); } inline const T& operator[] (std::ptrdiff_t ) const { return dereference(); } inline const T& operator*() const { return dereference(); } inline const T* operator->() const { return &(dereference()); } //Arithmetic unsigned inline constant_iterator& operator+=(std::size_t off) { return *this += std::ptrdiff_t(off); } inline constant_iterator operator+(std::size_t off) const { return *this + std::ptrdiff_t(off); } inline friend constant_iterator operator+(std::size_t off, const constant_iterator& right) { return std::ptrdiff_t(off) + right; } inline constant_iterator& operator-=(std::size_t off) { return *this -= std::ptrdiff_t(off); } inline constant_iterator operator-(std::size_t off) const { return *this - std::ptrdiff_t(off); } inline const T& operator[] (std::size_t off) const { return (*this)[std::ptrdiff_t(off)]; } private: const T * m_ptr; std::size_t m_num; inline void increment() { --m_num; } inline void decrement() { ++m_num; } inline bool equal(const this_type &other) const { return m_num == other.m_num; } inline bool less(const this_type &other) const { return other.m_num < m_num; } inline const T & dereference() const { return *m_ptr; } inline void advance(std::ptrdiff_t n) { m_num = std::size_t(std::ptrdiff_t(m_num) - n); } inline std::ptrdiff_t distance_to(const this_type &other)const { return std::ptrdiff_t(m_num - other.m_num); } }; template class value_init_construct_iterator : public ::boost::container::iterator { typedef value_init_construct_iterator this_type; public: inline explicit value_init_construct_iterator(std::size_t range_size) : m_num(range_size){} //Constructors inline value_init_construct_iterator() : m_num(0){} inline value_init_construct_iterator& operator++() { increment(); return *this; } inline value_init_construct_iterator operator++(int) { value_init_construct_iterator result (*this); increment(); return result; } inline value_init_construct_iterator& operator--() { decrement(); return *this; } inline value_init_construct_iterator operator--(int) { value_init_construct_iterator result (*this); decrement(); return result; } inline friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return i.equal(i2); } inline friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return !(i == i2); } inline friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return i.less(i2); } inline friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return i2 < i; } inline friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return !(i > i2); } inline friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return !(i < i2); } inline friend std::ptrdiff_t operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2) { return i2.distance_to(i); } //Arithmetic inline value_init_construct_iterator& operator+=(std::ptrdiff_t off) { this->advance(off); return *this; } inline value_init_construct_iterator operator+(std::ptrdiff_t off) const { value_init_construct_iterator other(*this); other.advance(off); return other; } inline friend value_init_construct_iterator operator+(std::ptrdiff_t off, const value_init_construct_iterator& right) { return right + off; } inline value_init_construct_iterator& operator-=(std::ptrdiff_t off) { this->advance(-off); return *this; } inline value_init_construct_iterator operator-(std::ptrdiff_t off) const { return *this + (-off); } //This pseudo-iterator's dereference operations have no sense since value is not //constructed until ::boost::container::construct_in_place is called. //So comment them to catch bad uses //const T& operator*() const; //const T& operator[](difference_type) const; //const T* operator->() const; private: std::size_t m_num; inline void increment() { --m_num; } inline void decrement() { ++m_num; } inline bool equal(const this_type &other) const { return m_num == other.m_num; } inline bool less(const this_type &other) const { return other.m_num < m_num; } inline const T & dereference() const { static T dummy; return dummy; } inline void advance(std::ptrdiff_t n) { m_num = std::size_t(std::ptrdiff_t(m_num) - n); } inline std::ptrdiff_t distance_to(const this_type &other)const { return std::ptrdiff_t(m_num - other.m_num); } }; template class default_init_construct_iterator : public ::boost::container::iterator { typedef default_init_construct_iterator this_type; public: inline explicit default_init_construct_iterator(std::size_t range_size) : m_num(range_size){} //Constructors inline default_init_construct_iterator() : m_num(0){} inline default_init_construct_iterator& operator++() { increment(); return *this; } inline default_init_construct_iterator operator++(int) { default_init_construct_iterator result (*this); increment(); return result; } inline default_init_construct_iterator& operator--() { decrement(); return *this; } inline default_init_construct_iterator operator--(int) { default_init_construct_iterator result (*this); decrement(); return result; } inline friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return i.equal(i2); } inline friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return !(i == i2); } inline friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return i.less(i2); } inline friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return i2 < i; } inline friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return !(i > i2); } inline friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return !(i < i2); } inline friend std::ptrdiff_t operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2) { return i2.distance_to(i); } //Arithmetic inline default_init_construct_iterator& operator+=(std::ptrdiff_t off) { this->advance(off); return *this; } inline default_init_construct_iterator operator+(std::ptrdiff_t off) const { default_init_construct_iterator other(*this); other.advance(off); return other; } inline friend default_init_construct_iterator operator+(std::ptrdiff_t off, const default_init_construct_iterator& right) { return right + off; } inline default_init_construct_iterator& operator-=(std::ptrdiff_t off) { this->advance(-off); return *this; } inline default_init_construct_iterator operator-(std::ptrdiff_t off) const { return *this + (-off); } //This pseudo-iterator's dereference operations have no sense since value is not //constructed until ::boost::container::construct_in_place is called. //So comment them to catch bad uses //const T& operator*() const; //const T& operator[](difference_type) const; //const T* operator->() const; private: std::size_t m_num; inline void increment() { --m_num; } inline void decrement() { ++m_num; } inline bool equal(const this_type &other) const { return m_num == other.m_num; } inline bool less(const this_type &other) const { return other.m_num < m_num; } inline const T & dereference() const { static T dummy; return dummy; } inline void advance(std::ptrdiff_t n) { m_num = std::size_t(std::ptrdiff_t(m_num) - n); } inline std::ptrdiff_t distance_to(const this_type &other) const { return std::ptrdiff_t(m_num - other.m_num); } }; template class repeat_iterator : public ::boost::container::iterator { typedef repeat_iterator this_type; public: inline explicit repeat_iterator(T &ref, std::size_t range_size) : m_ptr(&ref), m_num(range_size){} //Constructors inline repeat_iterator() : m_ptr(0), m_num(0){} inline this_type& operator++() { increment(); return *this; } inline this_type operator++(int) { this_type result (*this); increment(); return result; } inline this_type& operator--() { increment(); return *this; } inline this_type operator--(int) { this_type result (*this); increment(); return result; } inline friend bool operator== (const this_type& i, const this_type& i2) { return i.equal(i2); } inline friend bool operator!= (const this_type& i, const this_type& i2) { return !(i == i2); } inline friend bool operator< (const this_type& i, const this_type& i2) { return i.less(i2); } inline friend bool operator> (const this_type& i, const this_type& i2) { return i2 < i; } inline friend bool operator<= (const this_type& i, const this_type& i2) { return !(i > i2); } inline friend bool operator>= (const this_type& i, const this_type& i2) { return !(i < i2); } inline friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2) { return i2.distance_to(i); } //Arithmetic inline this_type& operator+=(std::ptrdiff_t off) { this->advance(off); return *this; } inline this_type operator+(std::ptrdiff_t off) const { this_type other(*this); other.advance(off); return other; } inline friend this_type operator+(std::ptrdiff_t off, const this_type& right) { return right + off; } inline this_type& operator-=(std::ptrdiff_t off) { this->advance(-off); return *this; } inline this_type operator-(std::ptrdiff_t off) const { return *this + (-off); } inline T& operator*() const { return dereference(); } inline T& operator[] (std::ptrdiff_t ) const { return dereference(); } inline T *operator->() const { return &(dereference()); } private: T * m_ptr; std::size_t m_num; inline void increment() { --m_num; } inline void decrement() { ++m_num; } inline bool equal(const this_type &other) const { return m_num == other.m_num; } inline bool less(const this_type &other) const { return other.m_num < m_num; } inline T & dereference() const { return *m_ptr; } inline void advance(std::ptrdiff_t n) { m_num = std::size_t(std::ptrdiff_t(m_num - n)); } inline std::ptrdiff_t distance_to(const this_type &other)const { return std::ptrdiff_t(m_num - other.m_num); } }; template class emplace_iterator : public ::boost::container::iterator { typedef emplace_iterator this_type; public: typedef std::ptrdiff_t difference_type; inline explicit emplace_iterator(EmplaceFunctor&e) : m_num(1), m_pe(&e){} inline emplace_iterator() : m_num(0), m_pe(0){} inline this_type& operator++() { increment(); return *this; } inline this_type operator++(int) { this_type result (*this); increment(); return result; } inline this_type& operator--() { decrement(); return *this; } inline this_type operator--(int) { this_type result (*this); decrement(); return result; } inline friend bool operator== (const this_type& i, const this_type& i2) { return i.equal(i2); } inline friend bool operator!= (const this_type& i, const this_type& i2) { return !(i == i2); } inline friend bool operator< (const this_type& i, const this_type& i2) { return i.less(i2); } inline friend bool operator> (const this_type& i, const this_type& i2) { return i2 < i; } inline friend bool operator<= (const this_type& i, const this_type& i2) { return !(i > i2); } inline friend bool operator>= (const this_type& i, const this_type& i2) { return !(i < i2); } inline friend difference_type operator- (const this_type& i, const this_type& i2) { return i2.distance_to(i); } //Arithmetic inline this_type& operator+=(difference_type off) { this->advance(off); return *this; } inline this_type operator+(difference_type off) const { this_type other(*this); other.advance(off); return other; } inline friend this_type operator+(difference_type off, const this_type& right) { return right + off; } inline this_type& operator-=(difference_type off) { this->advance(-off); return *this; } inline this_type operator-(difference_type off) const { return *this + (-off); } private: //This pseudo-iterator's dereference operations have no sense since value is not //constructed until ::boost::container::construct_in_place is called. //So comment them to catch bad uses const T& operator*() const; const T& operator[](difference_type) const; const T* operator->() const; public: template inline void construct_in_place(Allocator &a, T* ptr) { (*m_pe)(a, ptr); } template inline void assign_in_place(DestIt dest) { (*m_pe)(dest); } private: std::size_t m_num; EmplaceFunctor * m_pe; inline void increment() { --m_num; } inline void decrement() { ++m_num; } inline bool equal(const this_type &other) const { return m_num == other.m_num; } inline bool less(const this_type &other) const { return other.m_num < m_num; } inline const T & dereference() const { static T dummy; return dummy; } inline void advance(difference_type n) { m_num -= n; } inline difference_type distance_to(const this_type &other)const { return difference_type(m_num - other.m_num); } }; #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) template struct emplace_functor { typedef typename dtl::build_number_seq::type index_tuple_t; inline emplace_functor(BOOST_FWD_REF(Args)... args) : args_(args...) {} template inline void operator()(Allocator &a, T *ptr) { emplace_functor::inplace_impl(a, ptr, index_tuple_t()); } template inline void operator()(DestIt dest) { emplace_functor::inplace_impl(dest, index_tuple_t()); } private: template inline void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple&) { allocator_traits::construct (a, ptr, ::boost::forward(dtl::get(args_))...); } template inline void inplace_impl(DestIt dest, const dtl::index_tuple&) { typedef typename boost::container::iterator_traits::value_type value_type; value_type && tmp= value_type(::boost::forward(dtl::get(args_))...); *dest = ::boost::move(tmp); } dtl::tuple args_; }; template struct emplace_functor_type { typedef emplace_functor type; }; #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) //Partial specializations cannot match argument list for primary template, so add an extra argument template struct emplace_functor_type; #define BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE(N) \ BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \ struct emplace_functor##N\ {\ inline explicit emplace_functor##N( BOOST_MOVE_UREF##N )\ BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N{}\ \ template\ inline void operator()(Allocator &a, T *ptr)\ { allocator_traits::construct(a, ptr BOOST_MOVE_I##N BOOST_MOVE_MFWD##N); }\ \ template\ inline void operator()(DestIt dest)\ {\ typedef typename boost::container::iterator_traits::value_type value_type;\ BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), dtl::value_init tmp) ;\ *dest = ::boost::move(const_cast(BOOST_MOVE_IF(N, tmp, tmp.get())));\ }\ \ BOOST_MOVE_MREF##N\ };\ \ template \ struct emplace_functor_type\ {\ typedef emplace_functor##N BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N type;\ };\ // BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE) #undef BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE #endif namespace dtl { template struct has_iterator_category { struct two { char _[2]; }; template static char test(int, typename X::iterator_category*); template static two test(int, ...); BOOST_STATIC_CONSTEXPR bool value = (1 == sizeof(test(0, 0))); }; template::value > struct is_input_iterator { BOOST_STATIC_CONSTEXPR bool value = is_same::value; }; template struct is_input_iterator { BOOST_STATIC_CONSTEXPR bool value = false; }; template struct is_not_input_iterator { BOOST_STATIC_CONSTEXPR bool value = !is_input_iterator::value; }; template::value > struct is_forward_iterator { BOOST_STATIC_CONSTEXPR bool value = is_same::value; }; template struct is_forward_iterator { BOOST_STATIC_CONSTEXPR bool value = false; }; template::value > struct is_bidirectional_iterator { BOOST_STATIC_CONSTEXPR bool value = is_same::value; }; template struct is_bidirectional_iterator { BOOST_STATIC_CONSTEXPR bool value = false; }; template struct iiterator_node_value_type { typedef typename IINodeType::value_type type; }; template struct iiterator_types { typedef typename IIterator::value_type it_value_type; typedef typename iiterator_node_value_type::type value_type; typedef typename boost::container::iterator_traits::pointer it_pointer; typedef typename boost::container::iterator_traits::difference_type difference_type; typedef typename ::boost::intrusive::pointer_traits:: template rebind_pointer::type pointer; typedef typename ::boost::intrusive::pointer_traits:: template rebind_pointer::type const_pointer; typedef typename ::boost::intrusive:: pointer_traits::reference reference; typedef typename ::boost::intrusive:: pointer_traits::reference const_reference; typedef typename IIterator::iterator_category iterator_category; }; template struct iterator_types { typedef typename ::boost::container::iterator < typename iiterator_types::iterator_category , typename iiterator_types::value_type , typename iiterator_types::difference_type , typename iiterator_types::const_pointer , typename iiterator_types::const_reference> type; }; template struct iterator_types { typedef typename ::boost::container::iterator < typename iiterator_types::iterator_category , typename iiterator_types::value_type , typename iiterator_types::difference_type , typename iiterator_types::pointer , typename iiterator_types::reference> type; }; template class iterator_from_iiterator { typedef typename iterator_types::type types_t; class nat { public: IIterator get() const { return IIterator(); } }; typedef typename dtl::if_c< IsConst , iterator_from_iiterator , nat>::type nonconst_iterator; public: typedef typename types_t::pointer pointer; typedef typename types_t::reference reference; typedef typename types_t::difference_type difference_type; typedef typename types_t::iterator_category iterator_category; typedef typename types_t::value_type value_type; inline iterator_from_iiterator() : m_iit() {} inline explicit iterator_from_iiterator(IIterator iit) BOOST_NOEXCEPT_OR_NOTHROW : m_iit(iit) {} inline iterator_from_iiterator(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW : m_iit(other.get()) {} inline iterator_from_iiterator(const nonconst_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW : m_iit(other.get()) {} inline iterator_from_iiterator& operator=(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW { m_iit = other.get(); return *this; } inline iterator_from_iiterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW { ++this->m_iit; return *this; } inline iterator_from_iiterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW { iterator_from_iiterator result (*this); ++this->m_iit; return result; } inline iterator_from_iiterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW { //If the iterator_from_iiterator is not a bidirectional iterator, operator-- should not exist BOOST_CONTAINER_STATIC_ASSERT((is_bidirectional_iterator::value)); --this->m_iit; return *this; } inline iterator_from_iiterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW { iterator_from_iiterator result (*this); --this->m_iit; return result; } inline friend bool operator== (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_iit == r.m_iit; } inline friend bool operator!= (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW { return l.m_iit != r.m_iit; } inline reference operator*() const BOOST_NOEXCEPT_OR_NOTHROW { return this->m_iit->get_data(); } inline pointer operator->() const BOOST_NOEXCEPT_OR_NOTHROW { return ::boost::intrusive::pointer_traits::pointer_to(this->operator*()); } inline const IIterator &get() const BOOST_NOEXCEPT_OR_NOTHROW { return this->m_iit; } private: IIterator m_iit; }; } //namespace dtl { using ::boost::intrusive::reverse_iterator; } //namespace container { } //namespace boost { #include #endif //#ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP