Chris@101: /* Copyright 2003-2014 Joaquin M Lopez Munoz.
Chris@16:  * Distributed under the Boost Software License, Version 1.0.
Chris@16:  * (See accompanying file LICENSE_1_0.txt or copy at
Chris@16:  * http://www.boost.org/LICENSE_1_0.txt)
Chris@16:  *
Chris@16:  * See http://www.boost.org/libs/multi_index for library home page.
Chris@16:  *
Chris@16:  * The internal implementation of red-black trees is based on that of SGI STL
Chris@16:  * stl_tree.h file: 
Chris@16:  *
Chris@16:  * Copyright (c) 1996,1997
Chris@16:  * Silicon Graphics Computer Systems, Inc.
Chris@16:  *
Chris@16:  * Permission to use, copy, modify, distribute and sell this software
Chris@16:  * and its documentation for any purpose is hereby granted without fee,
Chris@16:  * provided that the above copyright notice appear in all copies and
Chris@16:  * that both that copyright notice and this permission notice appear
Chris@16:  * in supporting documentation.  Silicon Graphics makes no
Chris@16:  * representations about the suitability of this software for any
Chris@16:  * purpose.  It is provided "as is" without express or implied warranty.
Chris@16:  *
Chris@16:  *
Chris@16:  * Copyright (c) 1994
Chris@16:  * Hewlett-Packard Company
Chris@16:  *
Chris@16:  * Permission to use, copy, modify, distribute and sell this software
Chris@16:  * and its documentation for any purpose is hereby granted without fee,
Chris@16:  * provided that the above copyright notice appear in all copies and
Chris@16:  * that both that copyright notice and this permission notice appear
Chris@16:  * in supporting documentation.  Hewlett-Packard Company makes no
Chris@16:  * representations about the suitability of this software for any
Chris@16:  * purpose.  It is provided "as is" without express or implied warranty.
Chris@16:  *
Chris@16:  */
Chris@16: 
Chris@16: #ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
Chris@16: #define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
Chris@16: 
Chris@101: #if defined(_MSC_VER)
Chris@16: #pragma once
Chris@16: #endif
Chris@16: 
Chris@16: #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
Chris@16: #include <algorithm>
Chris@16: #include <boost/call_traits.hpp>
Chris@16: #include <boost/detail/no_exceptions_support.hpp>
Chris@16: #include <boost/detail/workaround.hpp>
Chris@16: #include <boost/foreach_fwd.hpp>
Chris@16: #include <boost/iterator/reverse_iterator.hpp>
Chris@16: #include <boost/move/core.hpp>
Chris@16: #include <boost/mpl/bool.hpp>
Chris@16: #include <boost/mpl/if.hpp>
Chris@16: #include <boost/mpl/push_front.hpp>
Chris@16: #include <boost/multi_index/detail/access_specifier.hpp>
Chris@16: #include <boost/multi_index/detail/bidir_node_iterator.hpp>
Chris@16: #include <boost/multi_index/detail/do_not_copy_elements_tag.hpp>
Chris@16: #include <boost/multi_index/detail/index_node_base.hpp>
Chris@16: #include <boost/multi_index/detail/modify_key_adaptor.hpp>
Chris@16: #include <boost/multi_index/detail/ord_index_node.hpp>
Chris@16: #include <boost/multi_index/detail/ord_index_ops.hpp>
Chris@16: #include <boost/multi_index/detail/safe_mode.hpp>
Chris@16: #include <boost/multi_index/detail/scope_guard.hpp>
Chris@16: #include <boost/multi_index/detail/unbounded.hpp>
Chris@16: #include <boost/multi_index/detail/value_compare.hpp>
Chris@16: #include <boost/multi_index/detail/vartempl_support.hpp>
Chris@16: #include <boost/multi_index/ordered_index_fwd.hpp>
Chris@16: #include <boost/ref.hpp>
Chris@16: #include <boost/tuple/tuple.hpp>
Chris@16: #include <boost/type_traits/is_same.hpp>
Chris@16: #include <utility>
Chris@16: 
Chris@16: #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
Chris@16: #include <initializer_list>
Chris@16: #endif
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16: #include <boost/archive/archive_exception.hpp>
Chris@16: #include <boost/bind.hpp>
Chris@16: #include <boost/multi_index/detail/duplicates_iterator.hpp>
Chris@16: #include <boost/throw_exception.hpp> 
Chris@16: #endif
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
Chris@16: #define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)                    \
Chris@16:   detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
Chris@16:     detail::make_obj_guard(x,&ordered_index::check_invariant_);              \
Chris@16:   BOOST_JOIN(check_invariant_,__LINE__).touch();
Chris@16: #define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT                          \
Chris@16:   BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(*this)
Chris@16: #else
Chris@16: #define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x)
Chris@16: #define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
Chris@16: #endif
Chris@16: 
Chris@16: namespace boost{
Chris@16: 
Chris@16: namespace multi_index{
Chris@16: 
Chris@16: namespace detail{
Chris@16: 
Chris@16: /* ordered_index adds a layer of ordered indexing to a given Super */
Chris@16: 
Chris@16: /* Most of the implementation of unique and non-unique indices is
Chris@16:  * shared. We tell from one another on instantiation time by using
Chris@16:  * these tags.
Chris@16:  */
Chris@16: 
Chris@16: struct ordered_unique_tag{};
Chris@16: struct ordered_non_unique_tag{};
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue,typename Compare,
Chris@16:   typename SuperMeta,typename TagList,typename Category
Chris@16: >
Chris@16: class ordered_index:
Chris@16:   BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:   ,public safe_mode::safe_container<
Chris@16:     ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category> >
Chris@16: #endif
Chris@16: 
Chris@16: { 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
Chris@16:     BOOST_WORKAROUND(__MWERKS__,<=0x3003)
Chris@16: /* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
Chris@16:  * lifetime of const references bound to temporaries --precisely what
Chris@16:  * scopeguards are.
Chris@16:  */
Chris@16: 
Chris@16: #pragma parse_mfunc_templ off
Chris@16: #endif
Chris@16: 
Chris@16:   typedef typename SuperMeta::type                   super;
Chris@16: 
Chris@16: protected:
Chris@16:   typedef ordered_index_node<
Chris@16:     typename super::node_type>                       node_type;
Chris@16: 
Chris@16: private:
Chris@16:   typedef typename node_type::impl_type              node_impl_type;
Chris@16:   typedef typename node_impl_type::pointer           node_impl_pointer;
Chris@16: 
Chris@16: public:
Chris@16:   /* types */
Chris@16: 
Chris@16:   typedef typename KeyFromValue::result_type         key_type;
Chris@16:   typedef typename node_type::value_type             value_type;
Chris@16:   typedef KeyFromValue                               key_from_value;
Chris@16:   typedef Compare                                    key_compare;
Chris@16:   typedef value_comparison<
Chris@16:     value_type,KeyFromValue,Compare>                 value_compare;
Chris@16:   typedef tuple<key_from_value,key_compare>          ctor_args;
Chris@16:   typedef typename super::final_allocator_type       allocator_type;
Chris@16:   typedef typename allocator_type::reference         reference;
Chris@16:   typedef typename allocator_type::const_reference   const_reference;
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:   typedef safe_mode::safe_iterator<
Chris@16:     bidir_node_iterator<node_type>,
Chris@16:     ordered_index>                                   iterator;
Chris@16: #else
Chris@16:   typedef bidir_node_iterator<node_type>             iterator;
Chris@16: #endif
Chris@16: 
Chris@16:   typedef iterator                                   const_iterator;
Chris@16: 
Chris@16:   typedef std::size_t                                size_type;      
Chris@16:   typedef std::ptrdiff_t                             difference_type;
Chris@16:   typedef typename allocator_type::pointer           pointer;
Chris@16:   typedef typename allocator_type::const_pointer     const_pointer;
Chris@16:   typedef typename
Chris@16:     boost::reverse_iterator<iterator>                reverse_iterator;
Chris@16:   typedef typename
Chris@16:     boost::reverse_iterator<const_iterator>          const_reverse_iterator;
Chris@16:   typedef TagList                                    tag_list;
Chris@16: 
Chris@16: protected:
Chris@16:   typedef typename super::final_node_type            final_node_type;
Chris@16:   typedef tuples::cons<
Chris@16:     ctor_args, 
Chris@16:     typename super::ctor_args_list>                  ctor_args_list;
Chris@16:   typedef typename mpl::push_front<
Chris@16:     typename super::index_type_list,
Chris@16:     ordered_index>::type                             index_type_list;
Chris@16:   typedef typename mpl::push_front<
Chris@16:     typename super::iterator_type_list,
Chris@16:     iterator>::type    iterator_type_list;
Chris@16:   typedef typename mpl::push_front<
Chris@16:     typename super::const_iterator_type_list,
Chris@16:     const_iterator>::type                            const_iterator_type_list;
Chris@16:   typedef typename super::copy_map_type              copy_map_type;
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16:   typedef typename super::index_saver_type           index_saver_type;
Chris@16:   typedef typename super::index_loader_type          index_loader_type;
Chris@16: #endif
Chris@16: 
Chris@16: private:
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:   typedef safe_mode::safe_container<ordered_index>   safe_super;
Chris@16: #endif
Chris@16: 
Chris@16:   typedef typename call_traits<
Chris@16:     value_type>::param_type                          value_param_type;
Chris@16:   typedef typename call_traits<
Chris@16:     key_type>::param_type                            key_param_type;
Chris@16: 
Chris@16:   /* Needed to avoid commas in BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL
Chris@16:    * expansion.
Chris@16:    */
Chris@16: 
Chris@16:   typedef std::pair<iterator,bool>                   emplace_return_type;
Chris@16: 
Chris@16: public:
Chris@16: 
Chris@16:   /* construct/copy/destroy
Chris@16:    * Default and copy ctors are in the protected section as indices are
Chris@16:    * not supposed to be created on their own. No range ctor either.
Chris@16:    */
Chris@16: 
Chris@16:   ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& operator=(
Chris@16:     const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
Chris@16:   {
Chris@16:     this->final()=x.final();
Chris@16:     return *this;
Chris@16:   }
Chris@16: 
Chris@16: #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
Chris@16:   ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& operator=(
Chris@16:     std::initializer_list<value_type> list)
Chris@16:   {
Chris@16:     this->final()=list;
Chris@16:     return *this;
Chris@16:   }
Chris@16: #endif
Chris@16: 
Chris@101:   allocator_type get_allocator()const BOOST_NOEXCEPT
Chris@16:   {
Chris@16:     return this->final().get_allocator();
Chris@16:   }
Chris@16: 
Chris@16:   /* iterators */
Chris@16: 
Chris@101:   iterator
Chris@101:     begin()BOOST_NOEXCEPT{return make_iterator(leftmost());}
Chris@101:   const_iterator
Chris@101:     begin()const BOOST_NOEXCEPT{return make_iterator(leftmost());}
Chris@101:   iterator
Chris@101:     end()BOOST_NOEXCEPT{return make_iterator(header());}
Chris@101:   const_iterator
Chris@101:     end()const BOOST_NOEXCEPT{return make_iterator(header());}
Chris@101:   reverse_iterator
Chris@101:     rbegin()BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
Chris@101:   const_reverse_iterator
Chris@101:     rbegin()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(end());}
Chris@101:   reverse_iterator
Chris@101:     rend()BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
Chris@101:   const_reverse_iterator
Chris@101:     rend()const BOOST_NOEXCEPT{return boost::make_reverse_iterator(begin());}
Chris@101:   const_iterator
Chris@101:     cbegin()const BOOST_NOEXCEPT{return begin();}
Chris@101:   const_iterator
Chris@101:     cend()const BOOST_NOEXCEPT{return end();}
Chris@101:   const_reverse_iterator
Chris@101:     crbegin()const BOOST_NOEXCEPT{return rbegin();}
Chris@101:   const_reverse_iterator
Chris@101:     crend()const BOOST_NOEXCEPT{return rend();}
Chris@16:  
Chris@16:   iterator iterator_to(const value_type& x)
Chris@16:   {
Chris@16:     return make_iterator(node_from_value<node_type>(&x));
Chris@16:   }
Chris@16: 
Chris@16:   const_iterator iterator_to(const value_type& x)const
Chris@16:   {
Chris@16:     return make_iterator(node_from_value<node_type>(&x));
Chris@16:   }
Chris@16: 
Chris@16:   /* capacity */
Chris@16: 
Chris@101:   bool      empty()const BOOST_NOEXCEPT{return this->final_empty_();}
Chris@101:   size_type size()const BOOST_NOEXCEPT{return this->final_size_();}
Chris@101:   size_type max_size()const BOOST_NOEXCEPT{return this->final_max_size_();}
Chris@16: 
Chris@16:   /* modifiers */
Chris@16: 
Chris@16:   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL(
Chris@16:     emplace_return_type,emplace,emplace_impl)
Chris@16: 
Chris@16:   BOOST_MULTI_INDEX_OVERLOADS_TO_VARTEMPL_EXTRA_ARG(
Chris@16:     iterator,emplace_hint,emplace_hint_impl,iterator,position)
Chris@16: 
Chris@16:   std::pair<iterator,bool> insert(const value_type& x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool> p=this->final_insert_(x);
Chris@16:     return std::pair<iterator,bool>(make_iterator(p.first),p.second);
Chris@16:   }
Chris@16: 
Chris@16:   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool> p=this->final_insert_rv_(x);
Chris@16:     return std::pair<iterator,bool>(make_iterator(p.first),p.second);
Chris@16:   }
Chris@16: 
Chris@16:   iterator insert(iterator position,const value_type& x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool> p=this->final_insert_(
Chris@16:       x,static_cast<final_node_type*>(position.get_node()));
Chris@16:     return make_iterator(p.first);
Chris@16:   }
Chris@16:     
Chris@16:   iterator insert(iterator position,BOOST_RV_REF(value_type) x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool> p=this->final_insert_rv_(
Chris@16:       x,static_cast<final_node_type*>(position.get_node()));
Chris@16:     return make_iterator(p.first);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename InputIterator>
Chris@16:   void insert(InputIterator first,InputIterator last)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     node_type* hint=header(); /* end() */
Chris@16:     for(;first!=last;++first){
Chris@16:       hint=this->final_insert_ref_(
Chris@16:         *first,static_cast<final_node_type*>(hint)).first;
Chris@16:       node_type::increment(hint);
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16: #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
Chris@16:   void insert(std::initializer_list<value_type> list)
Chris@16:   {
Chris@16:     insert(list.begin(),list.end());
Chris@16:   }
Chris@16: #endif
Chris@16: 
Chris@16:   iterator erase(iterator position)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
Chris@16:     return position;
Chris@16:   }
Chris@16:   
Chris@16:   size_type erase(key_param_type x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<iterator,iterator> p=equal_range(x);
Chris@16:     size_type s=0;
Chris@16:     while(p.first!=p.second){
Chris@16:       p.first=erase(p.first);
Chris@16:       ++s;
Chris@16:     }
Chris@16:     return s;
Chris@16:   }
Chris@16: 
Chris@16:   iterator erase(iterator first,iterator last)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     while(first!=last){
Chris@16:       first=erase(first);
Chris@16:     }
Chris@16:     return first;
Chris@16:   }
Chris@16: 
Chris@16:   bool replace(iterator position,const value_type& x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     return this->final_replace_(
Chris@16:       x,static_cast<final_node_type*>(position.get_node()));
Chris@16:   }
Chris@16: 
Chris@16:   bool replace(iterator position,BOOST_RV_REF(value_type) x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     return this->final_replace_rv_(
Chris@16:       x,static_cast<final_node_type*>(position.get_node()));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Modifier>
Chris@16:   bool modify(iterator position,Modifier mod)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     /* MSVC++ 6.0 optimizer on safe mode code chokes if this
Chris@16:      * this is not added. Left it for all compilers as it does no
Chris@16:      * harm.
Chris@16:      */
Chris@16: 
Chris@16:     position.detach();
Chris@16: #endif
Chris@16: 
Chris@16:     return this->final_modify_(
Chris@16:       mod,static_cast<final_node_type*>(position.get_node()));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Modifier,typename Rollback>
Chris@101:   bool modify(iterator position,Modifier mod,Rollback back_)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     /* MSVC++ 6.0 optimizer on safe mode code chokes if this
Chris@16:      * this is not added. Left it for all compilers as it does no
Chris@16:      * harm.
Chris@16:      */
Chris@16: 
Chris@16:     position.detach();
Chris@16: #endif
Chris@16: 
Chris@16:     return this->final_modify_(
Chris@101:       mod,back_,static_cast<final_node_type*>(position.get_node()));
Chris@16:   }
Chris@16:   
Chris@16:   template<typename Modifier>
Chris@16:   bool modify_key(iterator position,Modifier mod)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     return modify(
Chris@16:       position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Modifier,typename Rollback>
Chris@101:   bool modify_key(iterator position,Modifier mod,Rollback back_)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     return modify(
Chris@16:       position,
Chris@16:       modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
Chris@101:       modify_key_adaptor<Rollback,value_type,KeyFromValue>(back_,key));
Chris@16:   }
Chris@16: 
Chris@16:   void swap(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF(x);
Chris@16:     this->final_swap_(x.final());
Chris@16:   }
Chris@16: 
Chris@101:   void clear()BOOST_NOEXCEPT
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     this->final_clear_();
Chris@16:   }
Chris@16: 
Chris@16:   /* observers */
Chris@16: 
Chris@16:   key_from_value key_extractor()const{return key;}
Chris@16:   key_compare    key_comp()const{return comp_;}
Chris@16:   value_compare  value_comp()const{return value_compare(key,comp_);}
Chris@16: 
Chris@16:   /* set operations */
Chris@16: 
Chris@16:   /* Internally, these ops rely on const_iterator being the same
Chris@16:    * type as iterator.
Chris@16:    */
Chris@16: 
Chris@16:   template<typename CompatibleKey>
Chris@16:   iterator find(const CompatibleKey& x)const
Chris@16:   {
Chris@16:     return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey,typename CompatibleCompare>
Chris@16:   iterator find(
Chris@16:     const CompatibleKey& x,const CompatibleCompare& comp)const
Chris@16:   {
Chris@16:     return make_iterator(ordered_index_find(root(),header(),key,x,comp));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey>
Chris@16:   size_type count(const CompatibleKey& x)const
Chris@16:   {
Chris@16:     return count(x,comp_);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey,typename CompatibleCompare>
Chris@16:   size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
Chris@16:   {
Chris@16:     std::pair<iterator,iterator> p=equal_range(x,comp);
Chris@16:     size_type n=std::distance(p.first,p.second);
Chris@16:     return n;
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey>
Chris@16:   iterator lower_bound(const CompatibleKey& x)const
Chris@16:   {
Chris@16:     return make_iterator(
Chris@16:       ordered_index_lower_bound(root(),header(),key,x,comp_));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey,typename CompatibleCompare>
Chris@16:   iterator lower_bound(
Chris@16:     const CompatibleKey& x,const CompatibleCompare& comp)const
Chris@16:   {
Chris@16:     return make_iterator(
Chris@16:       ordered_index_lower_bound(root(),header(),key,x,comp));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey>
Chris@16:   iterator upper_bound(const CompatibleKey& x)const
Chris@16:   {
Chris@16:     return make_iterator(
Chris@16:       ordered_index_upper_bound(root(),header(),key,x,comp_));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey,typename CompatibleCompare>
Chris@16:   iterator upper_bound(
Chris@16:     const CompatibleKey& x,const CompatibleCompare& comp)const
Chris@16:   {
Chris@16:     return make_iterator(
Chris@16:       ordered_index_upper_bound(root(),header(),key,x,comp));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey>
Chris@16:   std::pair<iterator,iterator> equal_range(
Chris@16:     const CompatibleKey& x)const
Chris@16:   {
Chris@16:     std::pair<node_type*,node_type*> p=
Chris@16:       ordered_index_equal_range(root(),header(),key,x,comp_);
Chris@16:     return std::pair<iterator,iterator>(
Chris@16:       make_iterator(p.first),make_iterator(p.second));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename CompatibleKey,typename CompatibleCompare>
Chris@16:   std::pair<iterator,iterator> equal_range(
Chris@16:     const CompatibleKey& x,const CompatibleCompare& comp)const
Chris@16:   {
Chris@16:     std::pair<node_type*,node_type*> p=
Chris@16:       ordered_index_equal_range(root(),header(),key,x,comp);
Chris@16:     return std::pair<iterator,iterator>(
Chris@16:       make_iterator(p.first),make_iterator(p.second));
Chris@16:   }
Chris@16: 
Chris@16:   /* range */
Chris@16: 
Chris@16:   template<typename LowerBounder,typename UpperBounder>
Chris@16:   std::pair<iterator,iterator>
Chris@16:   range(LowerBounder lower,UpperBounder upper)const
Chris@16:   {
Chris@16:     typedef typename mpl::if_<
Chris@16:       is_same<LowerBounder,unbounded_type>,
Chris@16:       BOOST_DEDUCED_TYPENAME mpl::if_<
Chris@16:         is_same<UpperBounder,unbounded_type>,
Chris@16:         both_unbounded_tag,
Chris@16:         lower_unbounded_tag
Chris@16:       >::type,
Chris@16:       BOOST_DEDUCED_TYPENAME mpl::if_<
Chris@16:         is_same<UpperBounder,unbounded_type>,
Chris@16:         upper_unbounded_tag,
Chris@16:         none_unbounded_tag
Chris@16:       >::type
Chris@16:     >::type dispatch;
Chris@16: 
Chris@16:     return range(lower,upper,dispatch());
Chris@16:   }
Chris@16: 
Chris@16: BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
Chris@16:   ordered_index(const ctor_args_list& args_list,const allocator_type& al):
Chris@16:     super(args_list.get_tail(),al),
Chris@16:     key(tuples::get<0>(args_list.get_head())),
Chris@16:     comp_(tuples::get<1>(args_list.get_head()))
Chris@16:   {
Chris@16:     empty_initialize();
Chris@16:   }
Chris@16: 
Chris@16:   ordered_index(
Chris@16:     const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x):
Chris@16:     super(x),
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     safe_super(),
Chris@16: #endif
Chris@16: 
Chris@16:     key(x.key),
Chris@16:     comp_(x.comp_)
Chris@16:   {
Chris@16:     /* Copy ctor just takes the key and compare objects from x. The rest is
Chris@16:      * done in a subsequent call to copy_().
Chris@16:      */
Chris@16:   }
Chris@16: 
Chris@16:   ordered_index(
Chris@16:      const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
Chris@16:      do_not_copy_elements_tag):
Chris@16:     super(x,do_not_copy_elements_tag()),
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     safe_super(),
Chris@16: #endif
Chris@16: 
Chris@16:     key(x.key),
Chris@16:     comp_(x.comp_)
Chris@16:   {
Chris@16:     empty_initialize();
Chris@16:   }
Chris@16: 
Chris@16:   ~ordered_index()
Chris@16:   {
Chris@16:     /* the container is guaranteed to be empty by now */
Chris@16:   }
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:   iterator       make_iterator(node_type* node){return iterator(node,this);}
Chris@16:   const_iterator make_iterator(node_type* node)const
Chris@16:     {return const_iterator(node,const_cast<ordered_index*>(this));}
Chris@16: #else
Chris@16:   iterator       make_iterator(node_type* node){return iterator(node);}
Chris@16:   const_iterator make_iterator(node_type* node)const
Chris@16:                    {return const_iterator(node);}
Chris@16: #endif
Chris@16: 
Chris@16:   void copy_(
Chris@16:     const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
Chris@16:     const copy_map_type& map)
Chris@16:   {
Chris@16:     if(!x.root()){
Chris@16:       empty_initialize();
Chris@16:     }
Chris@16:     else{
Chris@16:       header()->color()=x.header()->color();
Chris@16: 
Chris@16:       node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
Chris@16:       header()->parent()=root_cpy->impl();
Chris@16: 
Chris@16:       node_type* leftmost_cpy=map.find(
Chris@16:         static_cast<final_node_type*>(x.leftmost()));
Chris@16:       header()->left()=leftmost_cpy->impl();
Chris@16: 
Chris@16:       node_type* rightmost_cpy=map.find(
Chris@16:         static_cast<final_node_type*>(x.rightmost()));
Chris@16:       header()->right()=rightmost_cpy->impl();
Chris@16: 
Chris@16:       typedef typename copy_map_type::const_iterator copy_map_iterator;
Chris@16:       for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
Chris@16:         node_type* org=it->first;
Chris@16:         node_type* cpy=it->second;
Chris@16: 
Chris@16:         cpy->color()=org->color();
Chris@16: 
Chris@16:         node_impl_pointer parent_org=org->parent();
Chris@16:         if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
Chris@16:         else{
Chris@16:           node_type* parent_cpy=map.find(
Chris@16:             static_cast<final_node_type*>(node_type::from_impl(parent_org)));
Chris@16:           cpy->parent()=parent_cpy->impl();
Chris@16:           if(parent_org->left()==org->impl()){
Chris@16:             parent_cpy->left()=cpy->impl();
Chris@16:           }
Chris@16:           else if(parent_org->right()==org->impl()){
Chris@16:             /* header() does not satisfy this nor the previous check */
Chris@16:             parent_cpy->right()=cpy->impl();
Chris@16:           }
Chris@16:         }
Chris@16: 
Chris@16:         if(org->left()==node_impl_pointer(0))
Chris@16:           cpy->left()=node_impl_pointer(0);
Chris@16:         if(org->right()==node_impl_pointer(0))
Chris@16:           cpy->right()=node_impl_pointer(0);
Chris@16:       }
Chris@16:     }
Chris@16:     
Chris@16:     super::copy_(x,map);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Variant>
Chris@101:   final_node_type* insert_(
Chris@101:     value_param_type v,final_node_type*& x,Variant variant)
Chris@16:   {
Chris@16:     link_info inf;
Chris@16:     if(!link_point(key(v),inf,Category())){
Chris@101:       return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
Chris@16:     }
Chris@16: 
Chris@101:     final_node_type* res=super::insert_(v,x,variant);
Chris@16:     if(res==x){
Chris@101:       node_impl_type::link(
Chris@101:         static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
Chris@16:     }
Chris@16:     return res;
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Variant>
Chris@101:   final_node_type* insert_(
Chris@101:     value_param_type v,node_type* position,final_node_type*& x,Variant variant)
Chris@16:   {
Chris@16:     link_info inf;
Chris@16:     if(!hinted_link_point(key(v),position,inf,Category())){
Chris@101:       return static_cast<final_node_type*>(node_type::from_impl(inf.pos));
Chris@16:     }
Chris@16: 
Chris@101:     final_node_type* res=super::insert_(v,position,x,variant);
Chris@16:     if(res==x){
Chris@101:       node_impl_type::link(
Chris@101:         static_cast<node_type*>(x)->impl(),inf.side,inf.pos,header()->impl());
Chris@16:     }
Chris@16:     return res;
Chris@16:   }
Chris@16: 
Chris@16:   void erase_(node_type* x)
Chris@16:   {
Chris@16:     node_impl_type::rebalance_for_erase(
Chris@16:       x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16:     super::erase_(x);
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     detach_iterators(x);
Chris@16: #endif
Chris@16:   }
Chris@16: 
Chris@16:   void delete_all_nodes_()
Chris@16:   {
Chris@16:     delete_all_nodes(root());
Chris@16:   }
Chris@16: 
Chris@16:   void clear_()
Chris@16:   {
Chris@16:     super::clear_();
Chris@16:     empty_initialize();
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     safe_super::detach_dereferenceable_iterators();
Chris@16: #endif
Chris@16:   }
Chris@16: 
Chris@16:   void swap_(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
Chris@16:   {
Chris@16:     std::swap(key,x.key);
Chris@16:     std::swap(comp_,x.comp_);
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     safe_super::swap(x);
Chris@16: #endif
Chris@16: 
Chris@16:     super::swap_(x);
Chris@16:   }
Chris@16: 
Chris@16:   void swap_elements_(
Chris@16:     ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
Chris@16:   {
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:     safe_super::swap(x);
Chris@16: #endif
Chris@16: 
Chris@16:     super::swap_elements_(x);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Variant>
Chris@16:   bool replace_(value_param_type v,node_type* x,Variant variant)
Chris@16:   {
Chris@16:     if(in_place(v,x,Category())){
Chris@16:       return super::replace_(v,x,variant);
Chris@16:     }
Chris@16: 
Chris@16:     node_type* next=x;
Chris@16:     node_type::increment(next);
Chris@16: 
Chris@16:     node_impl_type::rebalance_for_erase(
Chris@16:       x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16: 
Chris@16:     BOOST_TRY{
Chris@16:       link_info inf;
Chris@16:       if(link_point(key(v),inf,Category())&&super::replace_(v,x,variant)){
Chris@16:         node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
Chris@16:         return true;
Chris@16:       }
Chris@16:       node_impl_type::restore(x->impl(),next->impl(),header()->impl());
Chris@16:       return false;
Chris@16:     }
Chris@16:     BOOST_CATCH(...){
Chris@16:       node_impl_type::restore(x->impl(),next->impl(),header()->impl());
Chris@16:       BOOST_RETHROW;
Chris@16:     }
Chris@16:     BOOST_CATCH_END
Chris@16:   }
Chris@16: 
Chris@16:   bool modify_(node_type* x)
Chris@16:   {
Chris@16:     bool b;
Chris@16:     BOOST_TRY{
Chris@16:       b=in_place(x->value(),x,Category());
Chris@16:     }
Chris@16:     BOOST_CATCH(...){
Chris@16:       erase_(x);
Chris@16:       BOOST_RETHROW;
Chris@16:     }
Chris@16:     BOOST_CATCH_END
Chris@16:     if(!b){
Chris@16:       node_impl_type::rebalance_for_erase(
Chris@16:         x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16:       BOOST_TRY{
Chris@16:         link_info inf;
Chris@16:         if(!link_point(key(x->value()),inf,Category())){
Chris@16:           super::erase_(x);
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:           detach_iterators(x);
Chris@16: #endif
Chris@16:           return false;
Chris@16:         }
Chris@16:         node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
Chris@16:       }
Chris@16:       BOOST_CATCH(...){
Chris@16:         super::erase_(x);
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:         detach_iterators(x);
Chris@16: #endif
Chris@16: 
Chris@16:         BOOST_RETHROW;
Chris@16:       }
Chris@16:       BOOST_CATCH_END
Chris@16:     }
Chris@16: 
Chris@16:     BOOST_TRY{
Chris@16:       if(!super::modify_(x)){
Chris@16:         node_impl_type::rebalance_for_erase(
Chris@16:           x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:         detach_iterators(x);
Chris@16: #endif
Chris@16: 
Chris@16:         return false;
Chris@16:       }
Chris@16:       else return true;
Chris@16:     }
Chris@16:     BOOST_CATCH(...){
Chris@16:       node_impl_type::rebalance_for_erase(
Chris@16:         x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:       detach_iterators(x);
Chris@16: #endif
Chris@16: 
Chris@16:       BOOST_RETHROW;
Chris@16:     }
Chris@16:     BOOST_CATCH_END
Chris@16:   }
Chris@16: 
Chris@16:   bool modify_rollback_(node_type* x)
Chris@16:   {
Chris@16:     if(in_place(x->value(),x,Category())){
Chris@16:       return super::modify_rollback_(x);
Chris@16:     }
Chris@16: 
Chris@16:     node_type* next=x;
Chris@16:     node_type::increment(next);
Chris@16: 
Chris@16:     node_impl_type::rebalance_for_erase(
Chris@16:       x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16: 
Chris@16:     BOOST_TRY{
Chris@16:       link_info inf;
Chris@16:       if(link_point(key(x->value()),inf,Category())&&
Chris@16:          super::modify_rollback_(x)){
Chris@16:         node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
Chris@16:         return true;
Chris@16:       }
Chris@16:       node_impl_type::restore(x->impl(),next->impl(),header()->impl());
Chris@16:       return false;
Chris@16:     }
Chris@16:     BOOST_CATCH(...){
Chris@16:       node_impl_type::restore(x->impl(),next->impl(),header()->impl());
Chris@16:       BOOST_RETHROW;
Chris@16:     }
Chris@16:     BOOST_CATCH_END
Chris@16:   }
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16:   /* serialization */
Chris@16: 
Chris@16:   template<typename Archive>
Chris@16:   void save_(
Chris@16:     Archive& ar,const unsigned int version,const index_saver_type& sm)const
Chris@16:   {
Chris@16:     save_(ar,version,sm,Category());
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Archive>
Chris@16:   void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
Chris@16:   {
Chris@16:     load_(ar,version,lm,Category());
Chris@16:   }
Chris@16: #endif
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
Chris@16:   /* invariant stuff */
Chris@16: 
Chris@16:   bool invariant_()const
Chris@16:   {
Chris@16:     if(size()==0||begin()==end()){
Chris@16:       if(size()!=0||begin()!=end()||
Chris@16:          header()->left()!=header()->impl()||
Chris@16:          header()->right()!=header()->impl())return false;
Chris@16:     }
Chris@16:     else{
Chris@16:       if((size_type)std::distance(begin(),end())!=size())return false;
Chris@16: 
Chris@16:       std::size_t len=node_impl_type::black_count(
Chris@16:         leftmost()->impl(),root()->impl());
Chris@16:       for(const_iterator it=begin(),it_end=end();it!=it_end;++it){
Chris@16:         node_type* x=it.get_node();
Chris@16:         node_type* left_x=node_type::from_impl(x->left());
Chris@16:         node_type* right_x=node_type::from_impl(x->right());
Chris@16: 
Chris@16:         if(x->color()==red){
Chris@16:           if((left_x&&left_x->color()==red)||
Chris@16:              (right_x&&right_x->color()==red))return false;
Chris@16:         }
Chris@16:         if(left_x&&comp_(key(x->value()),key(left_x->value())))return false;
Chris@16:         if(right_x&&comp_(key(right_x->value()),key(x->value())))return false;
Chris@16:         if(!left_x&&!right_x&&
Chris@16:            node_impl_type::black_count(x->impl(),root()->impl())!=len)
Chris@16:           return false;
Chris@16:       }
Chris@16:     
Chris@16:       if(leftmost()->impl()!=node_impl_type::minimum(root()->impl()))
Chris@16:         return false;
Chris@16:       if(rightmost()->impl()!=node_impl_type::maximum(root()->impl()))
Chris@16:         return false;
Chris@16:     }
Chris@16: 
Chris@16:     return super::invariant_();
Chris@16:   }
Chris@16: 
Chris@16:   
Chris@16:   /* This forwarding function eases things for the boost::mem_fn construct
Chris@16:    * in BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT. Actually,
Chris@16:    * final_check_invariant is already an inherited member function of
Chris@16:    * ordered_index.
Chris@16:    */
Chris@16:   void check_invariant_()const{this->final_check_invariant_();}
Chris@16: #endif
Chris@16: 
Chris@16: private:
Chris@16:   node_type* header()const{return this->final_header();}
Chris@16:   node_type* root()const{return node_type::from_impl(header()->parent());}
Chris@16:   node_type* leftmost()const{return node_type::from_impl(header()->left());}
Chris@16:   node_type* rightmost()const{return node_type::from_impl(header()->right());}
Chris@16: 
Chris@16:   void empty_initialize()
Chris@16:   {
Chris@16:     header()->color()=red;
Chris@16:     /* used to distinguish header() from root, in iterator.operator++ */
Chris@16:     
Chris@16:     header()->parent()=node_impl_pointer(0);
Chris@16:     header()->left()=header()->impl();
Chris@16:     header()->right()=header()->impl();
Chris@16:   }
Chris@16: 
Chris@16:   struct link_info
Chris@16:   {
Chris@101:     /* coverity[uninit_ctor]: suppress warning */
Chris@16:     link_info():side(to_left){}
Chris@16: 
Chris@16:     ordered_index_side side;
Chris@16:     node_impl_pointer  pos;
Chris@16:   };
Chris@16: 
Chris@16:   bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
Chris@16:   {
Chris@16:     node_type* y=header();
Chris@16:     node_type* x=root();
Chris@16:     bool c=true;
Chris@16:     while(x){
Chris@16:       y=x;
Chris@16:       c=comp_(k,key(x->value()));
Chris@16:       x=node_type::from_impl(c?x->left():x->right());
Chris@16:     }
Chris@16:     node_type* yy=y;
Chris@16:     if(c){
Chris@16:       if(yy==leftmost()){
Chris@16:         inf.side=to_left;
Chris@16:         inf.pos=y->impl();
Chris@16:         return true;
Chris@16:       }
Chris@16:       else node_type::decrement(yy);
Chris@16:     }
Chris@16: 
Chris@16:     if(comp_(key(yy->value()),k)){
Chris@16:       inf.side=c?to_left:to_right;
Chris@16:       inf.pos=y->impl();
Chris@16:       return true;
Chris@16:     }
Chris@16:     else{
Chris@16:       inf.pos=yy->impl();
Chris@16:       return false;
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
Chris@16:   {
Chris@16:     node_type* y=header();
Chris@16:     node_type* x=root();
Chris@16:     bool c=true;
Chris@16:     while (x){
Chris@16:      y=x;
Chris@16:      c=comp_(k,key(x->value()));
Chris@16:      x=node_type::from_impl(c?x->left():x->right());
Chris@16:     }
Chris@16:     inf.side=c?to_left:to_right;
Chris@16:     inf.pos=y->impl();
Chris@16:     return true;
Chris@16:   }
Chris@16: 
Chris@16:   bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
Chris@16:   {
Chris@16:     node_type* y=header();
Chris@16:     node_type* x=root();
Chris@16:     bool c=false;
Chris@16:     while (x){
Chris@16:      y=x;
Chris@16:      c=comp_(key(x->value()),k);
Chris@16:      x=node_type::from_impl(c?x->right():x->left());
Chris@16:     }
Chris@16:     inf.side=c?to_right:to_left;
Chris@16:     inf.pos=y->impl();
Chris@16:     return true;
Chris@16:   }
Chris@16: 
Chris@16:   bool hinted_link_point(
Chris@16:     key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
Chris@16:   {
Chris@16:     if(position->impl()==header()->left()){ 
Chris@16:       if(size()>0&&comp_(k,key(position->value()))){
Chris@16:         inf.side=to_left;
Chris@16:         inf.pos=position->impl();
Chris@16:         return true;
Chris@16:       }
Chris@16:       else return link_point(k,inf,ordered_unique_tag());
Chris@16:     } 
Chris@16:     else if(position==header()){ 
Chris@16:       if(comp_(key(rightmost()->value()),k)){
Chris@16:         inf.side=to_right;
Chris@16:         inf.pos=rightmost()->impl();
Chris@16:         return true;
Chris@16:       }
Chris@16:       else return link_point(k,inf,ordered_unique_tag());
Chris@16:     } 
Chris@16:     else{
Chris@16:       node_type* before=position;
Chris@16:       node_type::decrement(before);
Chris@16:       if(comp_(key(before->value()),k)&&comp_(k,key(position->value()))){
Chris@16:         if(before->right()==node_impl_pointer(0)){
Chris@16:           inf.side=to_right;
Chris@16:           inf.pos=before->impl();
Chris@16:           return true;
Chris@16:         }
Chris@16:         else{
Chris@16:           inf.side=to_left;
Chris@16:           inf.pos=position->impl();
Chris@16:           return true;
Chris@16:         }
Chris@16:       } 
Chris@16:       else return link_point(k,inf,ordered_unique_tag());
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   bool hinted_link_point(
Chris@16:     key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
Chris@16:   {
Chris@16:     if(position->impl()==header()->left()){ 
Chris@16:       if(size()>0&&!comp_(key(position->value()),k)){
Chris@16:         inf.side=to_left;
Chris@16:         inf.pos=position->impl();
Chris@16:         return true;
Chris@16:       }
Chris@16:       else return lower_link_point(k,inf,ordered_non_unique_tag());
Chris@16:     } 
Chris@16:     else if(position==header()){
Chris@16:       if(!comp_(k,key(rightmost()->value()))){
Chris@16:         inf.side=to_right;
Chris@16:         inf.pos=rightmost()->impl();
Chris@16:         return true;
Chris@16:       }
Chris@16:       else return link_point(k,inf,ordered_non_unique_tag());
Chris@16:     } 
Chris@16:     else{
Chris@16:       node_type* before=position;
Chris@16:       node_type::decrement(before);
Chris@16:       if(!comp_(k,key(before->value()))){
Chris@16:         if(!comp_(key(position->value()),k)){
Chris@16:           if(before->right()==node_impl_pointer(0)){
Chris@16:             inf.side=to_right;
Chris@16:             inf.pos=before->impl();
Chris@16:             return true;
Chris@16:           }
Chris@16:           else{
Chris@16:             inf.side=to_left;
Chris@16:             inf.pos=position->impl();
Chris@16:             return true;
Chris@16:           }
Chris@16:         }
Chris@16:         else return lower_link_point(k,inf,ordered_non_unique_tag());
Chris@16:       } 
Chris@16:       else return link_point(k,inf,ordered_non_unique_tag());
Chris@16:     }
Chris@16:   }
Chris@16: 
Chris@16:   void delete_all_nodes(node_type* x)
Chris@16:   {
Chris@16:     if(!x)return;
Chris@16: 
Chris@16:     delete_all_nodes(node_type::from_impl(x->left()));
Chris@16:     delete_all_nodes(node_type::from_impl(x->right()));
Chris@16:     this->final_delete_node_(static_cast<final_node_type*>(x));
Chris@16:   }
Chris@16: 
Chris@16:   bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
Chris@16:   {
Chris@16:     node_type* y;
Chris@16:     if(x!=leftmost()){
Chris@16:       y=x;
Chris@16:       node_type::decrement(y);
Chris@16:       if(!comp_(key(y->value()),key(v)))return false;
Chris@16:     }
Chris@16: 
Chris@16:     y=x;
Chris@16:     node_type::increment(y);
Chris@16:     return y==header()||comp_(key(v),key(y->value()));
Chris@16:   }
Chris@16: 
Chris@16:   bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
Chris@16:   {
Chris@16:     node_type* y;
Chris@16:     if(x!=leftmost()){
Chris@16:       y=x;
Chris@16:       node_type::decrement(y);
Chris@16:       if(comp_(key(v),key(y->value())))return false;
Chris@16:     }
Chris@16: 
Chris@16:     y=x;
Chris@16:     node_type::increment(y);
Chris@16:     return y==header()||!comp_(key(y->value()),key(v));
Chris@16:   }
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
Chris@16:   void detach_iterators(node_type* x)
Chris@16:   {
Chris@16:     iterator it=make_iterator(x);
Chris@16:     safe_mode::detach_equivalent_iterators(it);
Chris@16:   }
Chris@16: #endif
Chris@16: 
Chris@16:   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
Chris@16:   std::pair<iterator,bool> emplace_impl(BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool>p=
Chris@16:       this->final_emplace_(BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
Chris@16:     return std::pair<iterator,bool>(make_iterator(p.first),p.second);
Chris@16:   }
Chris@16: 
Chris@16:   template<BOOST_MULTI_INDEX_TEMPLATE_PARAM_PACK>
Chris@16:   iterator emplace_hint_impl(
Chris@16:     iterator position,BOOST_MULTI_INDEX_FUNCTION_PARAM_PACK)
Chris@16:   {
Chris@16:     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
Chris@16:     BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
Chris@16:     BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
Chris@16:     std::pair<final_node_type*,bool>p=
Chris@16:       this->final_emplace_hint_(
Chris@16:         static_cast<final_node_type*>(position.get_node()),
Chris@16:         BOOST_MULTI_INDEX_FORWARD_PARAM_PACK);
Chris@16:     return make_iterator(p.first);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename LowerBounder,typename UpperBounder>
Chris@16:   std::pair<iterator,iterator>
Chris@16:   range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
Chris@16:   {
Chris@16:     node_type* y=header();
Chris@16:     node_type* z=root();
Chris@16: 
Chris@16:     while(z){
Chris@16:       if(!lower(key(z->value()))){
Chris@16:         z=node_type::from_impl(z->right());
Chris@16:       }
Chris@16:       else if(!upper(key(z->value()))){
Chris@16:         y=z;
Chris@16:         z=node_type::from_impl(z->left());
Chris@16:       }
Chris@16:       else{
Chris@16:         return std::pair<iterator,iterator>(
Chris@16:           make_iterator(
Chris@16:             lower_range(node_type::from_impl(z->left()),z,lower)),
Chris@16:           make_iterator(
Chris@16:             upper_range(node_type::from_impl(z->right()),y,upper)));
Chris@16:       }
Chris@16:     }
Chris@16: 
Chris@16:     return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename LowerBounder,typename UpperBounder>
Chris@16:   std::pair<iterator,iterator>
Chris@16:   range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
Chris@16:   {
Chris@16:     return std::pair<iterator,iterator>(
Chris@16:       begin(),
Chris@16:       make_iterator(upper_range(root(),header(),upper)));
Chris@16:   }
Chris@16: 
Chris@16:   template<typename LowerBounder,typename UpperBounder>
Chris@16:   std::pair<iterator,iterator>
Chris@16:   range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
Chris@16:   {
Chris@16:     return std::pair<iterator,iterator>(
Chris@16:       make_iterator(lower_range(root(),header(),lower)),
Chris@16:       end());
Chris@16:   }
Chris@16: 
Chris@16:   template<typename LowerBounder,typename UpperBounder>
Chris@16:   std::pair<iterator,iterator>
Chris@16:   range(LowerBounder,UpperBounder,both_unbounded_tag)const
Chris@16:   {
Chris@16:     return std::pair<iterator,iterator>(begin(),end());
Chris@16:   }
Chris@16: 
Chris@16:   template<typename LowerBounder>
Chris@16:   node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
Chris@16:   {
Chris@16:     while(top){
Chris@16:       if(lower(key(top->value()))){
Chris@16:         y=top;
Chris@16:         top=node_type::from_impl(top->left());
Chris@16:       }
Chris@16:       else top=node_type::from_impl(top->right());
Chris@16:     }
Chris@16: 
Chris@16:     return y;
Chris@16:   }
Chris@16: 
Chris@16:   template<typename UpperBounder>
Chris@16:   node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
Chris@16:   {
Chris@16:     while(top){
Chris@16:       if(!upper(key(top->value()))){
Chris@16:         y=top;
Chris@16:         top=node_type::from_impl(top->left());
Chris@16:       }
Chris@16:       else top=node_type::from_impl(top->right());
Chris@16:     }
Chris@16: 
Chris@16:     return y;
Chris@16:   }
Chris@16: 
Chris@16: #if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
Chris@16:   template<typename Archive>
Chris@16:   void save_(
Chris@16:     Archive& ar,const unsigned int version,const index_saver_type& sm,
Chris@16:     ordered_unique_tag)const
Chris@16:   {
Chris@16:     super::save_(ar,version,sm);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Archive>
Chris@16:   void load_(
Chris@16:     Archive& ar,const unsigned int version,const index_loader_type& lm,
Chris@16:     ordered_unique_tag)
Chris@16:   {
Chris@16:     super::load_(ar,version,lm);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Archive>
Chris@16:   void save_(
Chris@16:     Archive& ar,const unsigned int version,const index_saver_type& sm,
Chris@16:     ordered_non_unique_tag)const
Chris@16:   {
Chris@16:     typedef duplicates_iterator<node_type,value_compare> dup_iterator;
Chris@16: 
Chris@16:     sm.save(
Chris@16:       dup_iterator(begin().get_node(),end().get_node(),value_comp()),
Chris@16:       dup_iterator(end().get_node(),value_comp()),
Chris@16:       ar,version);
Chris@16:     super::save_(ar,version,sm);
Chris@16:   }
Chris@16: 
Chris@16:   template<typename Archive>
Chris@16:   void load_(
Chris@16:     Archive& ar,const unsigned int version,const index_loader_type& lm,
Chris@16:     ordered_non_unique_tag)
Chris@16:   {
Chris@16:     lm.load(
Chris@101:       ::boost::bind(
Chris@101:         &ordered_index::rearranger,this,::boost::arg<1>(),::boost::arg<2>()),
Chris@16:       ar,version);
Chris@16:     super::load_(ar,version,lm);
Chris@16:   }
Chris@16: 
Chris@16:   void rearranger(node_type* position,node_type *x)
Chris@16:   {
Chris@16:     if(!position||comp_(key(position->value()),key(x->value()))){
Chris@16:       position=lower_bound(key(x->value())).get_node();
Chris@16:     }
Chris@16:     else if(comp_(key(x->value()),key(position->value()))){
Chris@16:       /* inconsistent rearrangement */
Chris@16:       throw_exception(
Chris@16:         archive::archive_exception(
Chris@16:           archive::archive_exception::other_exception));
Chris@16:     }
Chris@16:     else node_type::increment(position);
Chris@16: 
Chris@16:     if(position!=x){
Chris@16:       node_impl_type::rebalance_for_erase(
Chris@16:         x->impl(),header()->parent(),header()->left(),header()->right());
Chris@16:       node_impl_type::restore(
Chris@16:         x->impl(),position->impl(),header()->impl());
Chris@16:     }
Chris@16:   }
Chris@16: #endif /* serialization */
Chris@16: 
Chris@16:   key_from_value key;
Chris@16:   key_compare    comp_;
Chris@16: 
Chris@16: #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
Chris@16:     BOOST_WORKAROUND(__MWERKS__,<=0x3003)
Chris@16: #pragma parse_mfunc_templ reset
Chris@16: #endif
Chris@16: };
Chris@16: 
Chris@16: /* comparison */
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator==(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
Chris@16: }
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator<(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
Chris@16: }
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator!=(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return !(x==y);
Chris@16: }
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator>(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return y<x;
Chris@16: }
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator>=(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return !(x<y);
Chris@16: }
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue1,typename Compare1,
Chris@16:   typename SuperMeta1,typename TagList1,typename Category1,
Chris@16:   typename KeyFromValue2,typename Compare2,
Chris@16:   typename SuperMeta2,typename TagList2,typename Category2
Chris@16: >
Chris@16: bool operator<=(
Chris@16:   const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
Chris@16:   const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
Chris@16: {
Chris@16:   return !(x>y);
Chris@16: }
Chris@16: 
Chris@16: /*  specialized algorithms */
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue,typename Compare,
Chris@16:   typename SuperMeta,typename TagList,typename Category
Chris@16: >
Chris@16: void swap(
Chris@16:   ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
Chris@16:   ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& y)
Chris@16: {
Chris@16:   x.swap(y);
Chris@16: }
Chris@16: 
Chris@16: } /* namespace multi_index::detail */
Chris@16: 
Chris@16: /* ordered_index specifiers */
Chris@16: 
Chris@16: template<typename Arg1,typename Arg2,typename Arg3>
Chris@16: struct ordered_unique
Chris@16: {
Chris@16:   typedef typename detail::ordered_index_args<
Chris@16:     Arg1,Arg2,Arg3>                                index_args;
Chris@16:   typedef typename index_args::tag_list_type::type tag_list_type;
Chris@16:   typedef typename index_args::key_from_value_type key_from_value_type;
Chris@16:   typedef typename index_args::compare_type        compare_type;
Chris@16: 
Chris@16:   template<typename Super>
Chris@16:   struct node_class
Chris@16:   {
Chris@16:     typedef detail::ordered_index_node<Super> type;
Chris@16:   };
Chris@16: 
Chris@16:   template<typename SuperMeta>
Chris@16:   struct index_class
Chris@16:   {
Chris@16:     typedef detail::ordered_index<
Chris@16:       key_from_value_type,compare_type,
Chris@16:       SuperMeta,tag_list_type,detail::ordered_unique_tag> type;
Chris@16:   };
Chris@16: };
Chris@16: 
Chris@16: template<typename Arg1,typename Arg2,typename Arg3>
Chris@16: struct ordered_non_unique
Chris@16: {
Chris@16:   typedef detail::ordered_index_args<
Chris@16:     Arg1,Arg2,Arg3>                                index_args;
Chris@16:   typedef typename index_args::tag_list_type::type tag_list_type;
Chris@16:   typedef typename index_args::key_from_value_type key_from_value_type;
Chris@16:   typedef typename index_args::compare_type        compare_type;
Chris@16: 
Chris@16:   template<typename Super>
Chris@16:   struct node_class
Chris@16:   {
Chris@16:     typedef detail::ordered_index_node<Super> type;
Chris@16:   };
Chris@16: 
Chris@16:   template<typename SuperMeta>
Chris@16:   struct index_class
Chris@16:   {
Chris@16:     typedef detail::ordered_index<
Chris@16:       key_from_value_type,compare_type,
Chris@16:       SuperMeta,tag_list_type,detail::ordered_non_unique_tag> type;
Chris@16:   };
Chris@16: };
Chris@16: 
Chris@16: } /* namespace multi_index */
Chris@16: 
Chris@16: } /* namespace boost */
Chris@16: 
Chris@16: /* Boost.Foreach compatibility */
Chris@16: 
Chris@16: template<
Chris@16:   typename KeyFromValue,typename Compare,
Chris@16:   typename SuperMeta,typename TagList,typename Category
Chris@16: >
Chris@16: inline boost::mpl::true_* boost_foreach_is_noncopyable(
Chris@16:   boost::multi_index::detail::ordered_index<
Chris@16:     KeyFromValue,Compare,SuperMeta,TagList,Category>*&,
Chris@16:   boost::foreach::tag)
Chris@16: {
Chris@16:   return 0;
Chris@16: }
Chris@16: 
Chris@16: #undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
Chris@16: #undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT_OF
Chris@16: 
Chris@16: #endif