PageRenderTime 111ms CodeModel.GetById 13ms app.highlight 88ms RepoModel.GetById 1ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/multi_index/ordered_index.hpp

http://hadesmem.googlecode.com/
C++ Header | 1390 lines | 1121 code | 187 blank | 82 comment | 77 complexity | d55baa0bae95d20868bc176ff65987ee MD5 | raw file
   1/* Copyright 2003-2010 Joaquin M Lopez Munoz.
   2 * Distributed under the Boost Software License, Version 1.0.
   3 * (See accompanying file LICENSE_1_0.txt or copy at
   4 * http://www.boost.org/LICENSE_1_0.txt)
   5 *
   6 * See http://www.boost.org/libs/multi_index for library home page.
   7 *
   8 * The internal implementation of red-black trees is based on that of SGI STL
   9 * stl_tree.h file: 
  10 *
  11 * Copyright (c) 1996,1997
  12 * Silicon Graphics Computer Systems, Inc.
  13 *
  14 * Permission to use, copy, modify, distribute and sell this software
  15 * and its documentation for any purpose is hereby granted without fee,
  16 * provided that the above copyright notice appear in all copies and
  17 * that both that copyright notice and this permission notice appear
  18 * in supporting documentation.  Silicon Graphics makes no
  19 * representations about the suitability of this software for any
  20 * purpose.  It is provided "as is" without express or implied warranty.
  21 *
  22 *
  23 * Copyright (c) 1994
  24 * Hewlett-Packard Company
  25 *
  26 * Permission to use, copy, modify, distribute and sell this software
  27 * and its documentation for any purpose is hereby granted without fee,
  28 * provided that the above copyright notice appear in all copies and
  29 * that both that copyright notice and this permission notice appear
  30 * in supporting documentation.  Hewlett-Packard Company makes no
  31 * representations about the suitability of this software for any
  32 * purpose.  It is provided "as is" without express or implied warranty.
  33 *
  34 */
  35
  36#ifndef BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
  37#define BOOST_MULTI_INDEX_ORDERED_INDEX_HPP
  38
  39#if defined(_MSC_VER)&&(_MSC_VER>=1200)
  40#pragma once
  41#endif
  42
  43#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
  44#include <algorithm>
  45#include <boost/call_traits.hpp>
  46#include <boost/detail/no_exceptions_support.hpp>
  47#include <boost/detail/workaround.hpp>
  48#include <boost/iterator/reverse_iterator.hpp>
  49#include <boost/mpl/if.hpp>
  50#include <boost/mpl/push_front.hpp>
  51#include <boost/multi_index/detail/access_specifier.hpp>
  52#include <boost/multi_index/detail/bidir_node_iterator.hpp>
  53#include <boost/multi_index/detail/index_node_base.hpp>
  54#include <boost/multi_index/detail/modify_key_adaptor.hpp>
  55#include <boost/multi_index/detail/ord_index_node.hpp>
  56#include <boost/multi_index/detail/ord_index_ops.hpp>
  57#include <boost/multi_index/detail/safe_ctr_proxy.hpp>
  58#include <boost/multi_index/detail/safe_mode.hpp>
  59#include <boost/multi_index/detail/scope_guard.hpp>
  60#include <boost/multi_index/detail/unbounded.hpp>
  61#include <boost/multi_index/detail/value_compare.hpp>
  62#include <boost/multi_index/ordered_index_fwd.hpp>
  63#include <boost/ref.hpp>
  64#include <boost/tuple/tuple.hpp>
  65#include <boost/type_traits/is_same.hpp>
  66#include <utility>
  67
  68#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
  69#include <boost/archive/archive_exception.hpp>
  70#include <boost/bind.hpp>
  71#include <boost/multi_index/detail/duplicates_iterator.hpp>
  72#include <boost/throw_exception.hpp> 
  73#endif
  74
  75#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
  76#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT                          \
  77  detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)=                 \
  78    detail::make_obj_guard(*this,&ordered_index::check_invariant_);          \
  79  BOOST_JOIN(check_invariant_,__LINE__).touch();
  80#else
  81#define BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
  82#endif
  83
  84namespace boost{
  85
  86namespace multi_index{
  87
  88namespace detail{
  89
  90/* ordered_index adds a layer of ordered indexing to a given Super */
  91
  92/* Most of the implementation of unique and non-unique indices is
  93 * shared. We tell from one another on instantiation time by using
  94 * these tags.
  95 */
  96
  97struct ordered_unique_tag{};
  98struct ordered_non_unique_tag{};
  99
 100template<
 101  typename KeyFromValue,typename Compare,
 102  typename SuperMeta,typename TagList,typename Category
 103>
 104class ordered_index:
 105  BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS SuperMeta::type
 106
 107#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 108#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
 109  ,public safe_ctr_proxy_impl<
 110    bidir_node_iterator<
 111      ordered_index_node<typename SuperMeta::type::node_type> >,
 112    ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category> >
 113#else
 114  ,public safe_mode::safe_container<
 115    ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category> >
 116#endif
 117#endif
 118
 119{ 
 120#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
 121    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
 122/* The "ISO C++ Template Parser" option in CW8.3 has a problem with the
 123 * lifetime of const references bound to temporaries --precisely what
 124 * scopeguards are.
 125 */
 126
 127#pragma parse_mfunc_templ off
 128#endif
 129
 130  typedef typename SuperMeta::type                   super;
 131
 132protected:
 133  typedef ordered_index_node<
 134    typename super::node_type>                       node_type;
 135
 136private:
 137  typedef typename node_type::impl_type              node_impl_type;
 138  typedef typename node_impl_type::pointer           node_impl_pointer;
 139
 140public:
 141  /* types */
 142
 143  typedef typename KeyFromValue::result_type         key_type;
 144  typedef typename node_type::value_type             value_type;
 145  typedef KeyFromValue                               key_from_value;
 146  typedef Compare                                    key_compare;
 147  typedef value_comparison<
 148    value_type,KeyFromValue,Compare>                 value_compare;
 149  typedef tuple<key_from_value,key_compare>          ctor_args;
 150  typedef typename super::final_allocator_type       allocator_type;
 151  typedef typename allocator_type::reference         reference;
 152  typedef typename allocator_type::const_reference   const_reference;
 153
 154#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 155#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
 156  typedef safe_mode::safe_iterator<
 157    bidir_node_iterator<node_type>,
 158    safe_ctr_proxy<
 159      bidir_node_iterator<node_type> > >             iterator;
 160#else
 161  typedef safe_mode::safe_iterator<
 162    bidir_node_iterator<node_type>,
 163    ordered_index>                                   iterator;
 164#endif
 165#else
 166  typedef bidir_node_iterator<node_type>             iterator;
 167#endif
 168
 169  typedef iterator                                   const_iterator;
 170
 171  typedef std::size_t                                size_type;      
 172  typedef std::ptrdiff_t                             difference_type;
 173  typedef typename allocator_type::pointer           pointer;
 174  typedef typename allocator_type::const_pointer     const_pointer;
 175  typedef typename
 176    boost::reverse_iterator<iterator>                reverse_iterator;
 177  typedef typename
 178    boost::reverse_iterator<const_iterator>          const_reverse_iterator;
 179  typedef TagList                                    tag_list;
 180
 181protected:
 182  typedef typename super::final_node_type            final_node_type;
 183  typedef tuples::cons<
 184    ctor_args, 
 185    typename super::ctor_args_list>                  ctor_args_list;
 186  typedef typename mpl::push_front<
 187    typename super::index_type_list,
 188    ordered_index>::type                             index_type_list;
 189  typedef typename mpl::push_front<
 190    typename super::iterator_type_list,
 191    iterator>::type    iterator_type_list;
 192  typedef typename mpl::push_front<
 193    typename super::const_iterator_type_list,
 194    const_iterator>::type                            const_iterator_type_list;
 195  typedef typename super::copy_map_type              copy_map_type;
 196
 197#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
 198  typedef typename super::index_saver_type           index_saver_type;
 199  typedef typename super::index_loader_type          index_loader_type;
 200#endif
 201
 202private:
 203#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 204#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
 205  typedef safe_ctr_proxy_impl<
 206    bidir_node_iterator<node_type>,
 207    ordered_index>                                   safe_super;
 208#else
 209  typedef safe_mode::safe_container<ordered_index>   safe_super;
 210#endif
 211#endif
 212
 213  typedef typename call_traits<
 214    value_type>::param_type                          value_param_type;
 215  typedef typename call_traits<
 216    key_type>::param_type                            key_param_type;
 217
 218public:
 219
 220  /* construct/copy/destroy
 221   * Default and copy ctors are in the protected section as indices are
 222   * not supposed to be created on their own. No range ctor either.
 223   */
 224
 225  ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& operator=(
 226    const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
 227  {
 228    this->final()=x.final();
 229    return *this;
 230  }
 231
 232  allocator_type get_allocator()const
 233  {
 234    return this->final().get_allocator();
 235  }
 236
 237  /* iterators */
 238
 239  iterator               begin(){return make_iterator(leftmost());}
 240  const_iterator         begin()const{return make_iterator(leftmost());}
 241  iterator               end(){return make_iterator(header());}
 242  const_iterator         end()const{return make_iterator(header());}
 243  reverse_iterator       rbegin(){return make_reverse_iterator(end());}
 244  const_reverse_iterator rbegin()const{return make_reverse_iterator(end());}
 245  reverse_iterator       rend(){return make_reverse_iterator(begin());}
 246  const_reverse_iterator rend()const{return make_reverse_iterator(begin());}
 247  const_iterator         cbegin()const{return begin();}
 248  const_iterator         cend()const{return end();}
 249  const_reverse_iterator crbegin()const{return rbegin();}
 250  const_reverse_iterator crend()const{return rend();}
 251 
 252  iterator iterator_to(const value_type& x)
 253  {
 254    return make_iterator(node_from_value<node_type>(&x));
 255  }
 256
 257  const_iterator iterator_to(const value_type& x)const
 258  {
 259    return make_iterator(node_from_value<node_type>(&x));
 260  }
 261
 262  /* capacity */
 263
 264  bool      empty()const{return this->final_empty_();}
 265  size_type size()const{return this->final_size_();}
 266  size_type max_size()const{return this->final_max_size_();}
 267
 268  /* modifiers */
 269
 270  std::pair<iterator,bool> insert(value_param_type x)
 271  {
 272    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 273    std::pair<final_node_type*,bool> p=this->final_insert_(x);
 274    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
 275  }
 276
 277  iterator insert(iterator position,value_param_type x)
 278  {
 279    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 280    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 281    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 282    std::pair<final_node_type*,bool> p=this->final_insert_(
 283      x,static_cast<final_node_type*>(position.get_node()));
 284    return make_iterator(p.first);
 285  }
 286    
 287  template<typename InputIterator>
 288  void insert(InputIterator first,InputIterator last)
 289  {
 290    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 291    iterator hint=end();
 292    for(;first!=last;++first)hint=insert(hint,*first);
 293  }
 294
 295  iterator erase(iterator position)
 296  {
 297    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 298    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 299    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 300    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 301    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
 302    return position;
 303  }
 304  
 305  size_type erase(key_param_type x)
 306  {
 307    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 308    std::pair<iterator,iterator> p=equal_range(x);
 309    size_type s=0;
 310    while(p.first!=p.second){
 311      p.first=erase(p.first);
 312      ++s;
 313    }
 314    return s;
 315  }
 316
 317  iterator erase(iterator first,iterator last)
 318  {
 319    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(first);
 320    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(last);
 321    BOOST_MULTI_INDEX_CHECK_IS_OWNER(first,*this);
 322    BOOST_MULTI_INDEX_CHECK_IS_OWNER(last,*this);
 323    BOOST_MULTI_INDEX_CHECK_VALID_RANGE(first,last);
 324    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 325    while(first!=last){
 326      first=erase(first);
 327    }
 328    return first;
 329  }
 330
 331  bool replace(iterator position,value_param_type x)
 332  {
 333    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 334    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 335    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 336    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 337    return this->final_replace_(
 338      x,static_cast<final_node_type*>(position.get_node()));
 339  }
 340
 341  template<typename Modifier>
 342  bool modify(iterator position,Modifier mod)
 343  {
 344    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 345    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 346    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 347    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 348
 349#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 350    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
 351     * this is not added. Left it for all compilers as it does no
 352     * harm.
 353     */
 354
 355    position.detach();
 356#endif
 357
 358    return this->final_modify_(
 359      mod,static_cast<final_node_type*>(position.get_node()));
 360  }
 361
 362  template<typename Modifier,typename Rollback>
 363  bool modify(iterator position,Modifier mod,Rollback back)
 364  {
 365    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 366    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 367    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 368    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 369
 370#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 371    /* MSVC++ 6.0 optimizer on safe mode code chokes if this
 372     * this is not added. Left it for all compilers as it does no
 373     * harm.
 374     */
 375
 376    position.detach();
 377#endif
 378
 379    return this->final_modify_(
 380      mod,back,static_cast<final_node_type*>(position.get_node()));
 381  }
 382  
 383  template<typename Modifier>
 384  bool modify_key(iterator position,Modifier mod)
 385  {
 386    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 387    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 388    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 389    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 390    return modify(
 391      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
 392  }
 393
 394  template<typename Modifier,typename Rollback>
 395  bool modify_key(iterator position,Modifier mod,Rollback back)
 396  {
 397    BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 398    BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 399    BOOST_MULTI_INDEX_CHECK_IS_OWNER(position,*this);
 400    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 401    return modify(
 402      position,
 403      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
 404      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back,key));
 405  }
 406
 407  void swap(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
 408  {
 409    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 410    this->final_swap_(x.final());
 411  }
 412
 413  void clear()
 414  {
 415    BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT;
 416    this->final_clear_();
 417  }
 418
 419  /* observers */
 420
 421  key_from_value key_extractor()const{return key;}
 422  key_compare    key_comp()const{return comp;}
 423  value_compare  value_comp()const{return value_compare(key,comp);}
 424
 425  /* set operations */
 426
 427  /* Internally, these ops rely on const_iterator being the same
 428   * type as iterator.
 429   */
 430
 431  template<typename CompatibleKey>
 432  iterator find(const CompatibleKey& x)const
 433  {
 434    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
 435  }
 436
 437  template<typename CompatibleKey,typename CompatibleCompare>
 438  iterator find(
 439    const CompatibleKey& x,const CompatibleCompare& comp)const
 440  {
 441    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
 442  }
 443
 444  template<typename CompatibleKey>
 445  size_type count(const CompatibleKey& x)const
 446  {
 447    return count(x,comp);
 448  }
 449
 450  template<typename CompatibleKey,typename CompatibleCompare>
 451  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
 452  {
 453    std::pair<iterator,iterator> p=equal_range(x,comp);
 454    size_type n=std::distance(p.first,p.second);
 455    return n;
 456  }
 457
 458  template<typename CompatibleKey>
 459  iterator lower_bound(const CompatibleKey& x)const
 460  {
 461    return make_iterator(
 462      ordered_index_lower_bound(root(),header(),key,x,comp));
 463  }
 464
 465  template<typename CompatibleKey,typename CompatibleCompare>
 466  iterator lower_bound(
 467    const CompatibleKey& x,const CompatibleCompare& comp)const
 468  {
 469    return make_iterator(
 470      ordered_index_lower_bound(root(),header(),key,x,comp));
 471  }
 472
 473  template<typename CompatibleKey>
 474  iterator upper_bound(const CompatibleKey& x)const
 475  {
 476    return make_iterator(
 477      ordered_index_upper_bound(root(),header(),key,x,comp));
 478  }
 479
 480  template<typename CompatibleKey,typename CompatibleCompare>
 481  iterator upper_bound(
 482    const CompatibleKey& x,const CompatibleCompare& comp)const
 483  {
 484    return make_iterator(
 485      ordered_index_upper_bound(root(),header(),key,x,comp));
 486  }
 487
 488  template<typename CompatibleKey>
 489  std::pair<iterator,iterator> equal_range(
 490    const CompatibleKey& x)const
 491  {
 492    std::pair<node_type*,node_type*> p=
 493      ordered_index_equal_range(root(),header(),key,x,comp);
 494    return std::pair<iterator,iterator>(
 495      make_iterator(p.first),make_iterator(p.second));
 496  }
 497
 498  template<typename CompatibleKey,typename CompatibleCompare>
 499  std::pair<iterator,iterator> equal_range(
 500    const CompatibleKey& x,const CompatibleCompare& comp)const
 501  {
 502    std::pair<node_type*,node_type*> p=
 503      ordered_index_equal_range(root(),header(),key,x,comp);
 504    return std::pair<iterator,iterator>(
 505      make_iterator(p.first),make_iterator(p.second));
 506  }
 507
 508  /* range */
 509
 510  template<typename LowerBounder,typename UpperBounder>
 511  std::pair<iterator,iterator>
 512  range(LowerBounder lower,UpperBounder upper)const
 513  {
 514    typedef typename mpl::if_<
 515      is_same<LowerBounder,unbounded_type>,
 516      BOOST_DEDUCED_TYPENAME mpl::if_<
 517        is_same<UpperBounder,unbounded_type>,
 518        both_unbounded_tag,
 519        lower_unbounded_tag
 520      >::type,
 521      BOOST_DEDUCED_TYPENAME mpl::if_<
 522        is_same<UpperBounder,unbounded_type>,
 523        upper_unbounded_tag,
 524        none_unbounded_tag
 525      >::type
 526    >::type dispatch;
 527
 528    return range(lower,upper,dispatch());
 529  }
 530
 531BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS:
 532  ordered_index(const ctor_args_list& args_list,const allocator_type& al):
 533    super(args_list.get_tail(),al),
 534    key(tuples::get<0>(args_list.get_head())),
 535    comp(tuples::get<1>(args_list.get_head()))
 536  {
 537    empty_initialize();
 538  }
 539
 540  ordered_index(
 541    const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x):
 542    super(x),
 543
 544#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 545    safe_super(),
 546#endif
 547
 548    key(x.key),
 549    comp(x.comp)
 550  {
 551    /* Copy ctor just takes the key and compare objects from x. The rest is
 552     * done in subsequent call to copy_().
 553     */
 554  }
 555
 556  ~ordered_index()
 557  {
 558    /* the container is guaranteed to be empty by now */
 559  }
 560
 561#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 562  iterator       make_iterator(node_type* node){return iterator(node,this);}
 563  const_iterator make_iterator(node_type* node)const
 564    {return const_iterator(node,const_cast<ordered_index*>(this));}
 565#else
 566  iterator       make_iterator(node_type* node){return iterator(node);}
 567  const_iterator make_iterator(node_type* node)const
 568                   {return const_iterator(node);}
 569#endif
 570
 571  void copy_(
 572    const ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
 573    const copy_map_type& map)
 574  {
 575    if(!x.root()){
 576      empty_initialize();
 577    }
 578    else{
 579      header()->color()=x.header()->color();
 580
 581      node_type* root_cpy=map.find(static_cast<final_node_type*>(x.root()));
 582      header()->parent()=root_cpy->impl();
 583
 584      node_type* leftmost_cpy=map.find(
 585        static_cast<final_node_type*>(x.leftmost()));
 586      header()->left()=leftmost_cpy->impl();
 587
 588      node_type* rightmost_cpy=map.find(
 589        static_cast<final_node_type*>(x.rightmost()));
 590      header()->right()=rightmost_cpy->impl();
 591
 592      typedef typename copy_map_type::const_iterator copy_map_iterator;
 593      for(copy_map_iterator it=map.begin(),it_end=map.end();it!=it_end;++it){
 594        node_type* org=it->first;
 595        node_type* cpy=it->second;
 596
 597        cpy->color()=org->color();
 598
 599        node_impl_pointer parent_org=org->parent();
 600        if(parent_org==node_impl_pointer(0))cpy->parent()=node_impl_pointer(0);
 601        else{
 602          node_type* parent_cpy=map.find(
 603            static_cast<final_node_type*>(node_type::from_impl(parent_org)));
 604          cpy->parent()=parent_cpy->impl();
 605          if(parent_org->left()==org->impl()){
 606            parent_cpy->left()=cpy->impl();
 607          }
 608          else if(parent_org->right()==org->impl()){
 609            /* header() does not satisfy this nor the previous check */
 610            parent_cpy->right()=cpy->impl();
 611          }
 612        }
 613
 614        if(org->left()==node_impl_pointer(0))
 615          cpy->left()=node_impl_pointer(0);
 616        if(org->right()==node_impl_pointer(0))
 617          cpy->right()=node_impl_pointer(0);
 618      }
 619    }
 620    
 621    super::copy_(x,map);
 622  }
 623
 624  node_type* insert_(value_param_type v,node_type* x)
 625  {
 626    link_info inf;
 627    if(!link_point(key(v),inf,Category())){
 628      return node_type::from_impl(inf.pos);
 629    }
 630
 631    node_type* res=static_cast<node_type*>(super::insert_(v,x));
 632    if(res==x){
 633      node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
 634    }
 635    return res;
 636  }
 637
 638  node_type* insert_(value_param_type v,node_type* position,node_type* x)
 639  {
 640    link_info inf;
 641    if(!hinted_link_point(key(v),position,inf,Category())){
 642      return node_type::from_impl(inf.pos);
 643    }
 644
 645    node_type* res=static_cast<node_type*>(super::insert_(v,position,x));
 646    if(res==x){
 647      node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
 648    }
 649    return res;
 650  }
 651
 652  void erase_(node_type* x)
 653  {
 654    node_impl_type::rebalance_for_erase(
 655      x->impl(),header()->parent(),header()->left(),header()->right());
 656    super::erase_(x);
 657
 658#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 659    detach_iterators(x);
 660#endif
 661  }
 662
 663  void delete_all_nodes_()
 664  {
 665    delete_all_nodes(root());
 666  }
 667
 668  void clear_()
 669  {
 670    super::clear_();
 671    empty_initialize();
 672
 673#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 674    safe_super::detach_dereferenceable_iterators();
 675#endif
 676  }
 677
 678  void swap_(ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x)
 679  {
 680    std::swap(key,x.key);
 681    std::swap(comp,x.comp);
 682
 683#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 684    safe_super::swap(x);
 685#endif
 686
 687    super::swap_(x);
 688  }
 689
 690  bool replace_(value_param_type v,node_type* x)
 691  {
 692    if(in_place(v,x,Category())){
 693      return super::replace_(v,x);
 694    }
 695
 696    node_type* next=x;
 697    node_type::increment(next);
 698
 699    node_impl_type::rebalance_for_erase(
 700      x->impl(),header()->parent(),header()->left(),header()->right());
 701
 702    BOOST_TRY{
 703      link_info inf;
 704      if(link_point(key(v),inf,Category())&&super::replace_(v,x)){
 705        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
 706        return true;
 707      }
 708      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
 709      return false;
 710    }
 711    BOOST_CATCH(...){
 712      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
 713      BOOST_RETHROW;
 714    }
 715    BOOST_CATCH_END
 716  }
 717
 718  bool modify_(node_type* x)
 719  {
 720    bool b;
 721    BOOST_TRY{
 722      b=in_place(x->value(),x,Category());
 723    }
 724    BOOST_CATCH(...){
 725      erase_(x);
 726      BOOST_RETHROW;
 727    }
 728    BOOST_CATCH_END
 729    if(!b){
 730      node_impl_type::rebalance_for_erase(
 731        x->impl(),header()->parent(),header()->left(),header()->right());
 732      BOOST_TRY{
 733        link_info inf;
 734        if(!link_point(key(x->value()),inf,Category())){
 735          super::erase_(x);
 736
 737#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 738          detach_iterators(x);
 739#endif
 740          return false;
 741        }
 742        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
 743      }
 744      BOOST_CATCH(...){
 745        super::erase_(x);
 746
 747#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 748        detach_iterators(x);
 749#endif
 750
 751        BOOST_RETHROW;
 752      }
 753      BOOST_CATCH_END
 754    }
 755
 756    BOOST_TRY{
 757      if(!super::modify_(x)){
 758        node_impl_type::rebalance_for_erase(
 759          x->impl(),header()->parent(),header()->left(),header()->right());
 760
 761#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 762        detach_iterators(x);
 763#endif
 764
 765        return false;
 766      }
 767      else return true;
 768    }
 769    BOOST_CATCH(...){
 770      node_impl_type::rebalance_for_erase(
 771        x->impl(),header()->parent(),header()->left(),header()->right());
 772
 773#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
 774      detach_iterators(x);
 775#endif
 776
 777      BOOST_RETHROW;
 778    }
 779    BOOST_CATCH_END
 780  }
 781
 782  bool modify_rollback_(node_type* x)
 783  {
 784    if(in_place(x->value(),x,Category())){
 785      return super::modify_rollback_(x);
 786    }
 787
 788    node_type* next=x;
 789    node_type::increment(next);
 790
 791    node_impl_type::rebalance_for_erase(
 792      x->impl(),header()->parent(),header()->left(),header()->right());
 793
 794    BOOST_TRY{
 795      link_info inf;
 796      if(link_point(key(x->value()),inf,Category())&&
 797         super::modify_rollback_(x)){
 798        node_impl_type::link(x->impl(),inf.side,inf.pos,header()->impl());
 799        return true;
 800      }
 801      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
 802      return false;
 803    }
 804    BOOST_CATCH(...){
 805      node_impl_type::restore(x->impl(),next->impl(),header()->impl());
 806      BOOST_RETHROW;
 807    }
 808    BOOST_CATCH_END
 809  }
 810
 811#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
 812  /* serialization */
 813
 814  template<typename Archive>
 815  void save_(
 816    Archive& ar,const unsigned int version,const index_saver_type& sm)const
 817  {
 818    save_(ar,version,sm,Category());
 819  }
 820
 821  template<typename Archive>
 822  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
 823  {
 824    load_(ar,version,lm,Category());
 825  }
 826#endif
 827
 828#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)
 829  /* invariant stuff */
 830
 831  bool invariant_()const
 832  {
 833    if(size()==0||begin()==end()){
 834      if(size()!=0||begin()!=end()||
 835         header()->left()!=header()->impl()||
 836         header()->right()!=header()->impl())return false;
 837    }
 838    else{
 839      if((size_type)std::distance(begin(),end())!=size())return false;
 840
 841      std::size_t len=node_impl_type::black_count(
 842        leftmost()->impl(),root()->impl());
 843      for(const_iterator it=begin(),it_end=end();it!=it_end;++it){
 844        node_type* x=it.get_node();
 845        node_type* left_x=node_type::from_impl(x->left());
 846        node_type* right_x=node_type::from_impl(x->right());
 847
 848        if(x->color()==red){
 849          if((left_x&&left_x->color()==red)||
 850             (right_x&&right_x->color()==red))return false;
 851        }
 852        if(left_x&&comp(key(x->value()),key(left_x->value())))return false;
 853        if(right_x&&comp(key(right_x->value()),key(x->value())))return false;
 854        if(!left_x&&!right_x&&
 855           node_impl_type::black_count(x->impl(),root()->impl())!=len)
 856          return false;
 857      }
 858    
 859      if(leftmost()->impl()!=node_impl_type::minimum(root()->impl()))
 860        return false;
 861      if(rightmost()->impl()!=node_impl_type::maximum(root()->impl()))
 862        return false;
 863    }
 864
 865    return super::invariant_();
 866  }
 867
 868  
 869  /* This forwarding function eases things for the boost::mem_fn construct
 870   * in BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT. Actually,
 871   * final_check_invariant is already an inherited member function of
 872   * ordered_index.
 873   */
 874  void check_invariant_()const{this->final_check_invariant_();}
 875#endif
 876
 877private:
 878  node_type* header()const{return this->final_header();}
 879  node_type* root()const{return node_type::from_impl(header()->parent());}
 880  node_type* leftmost()const{return node_type::from_impl(header()->left());}
 881  node_type* rightmost()const{return node_type::from_impl(header()->right());}
 882
 883  void empty_initialize()
 884  {
 885    header()->color()=red;
 886    /* used to distinguish header() from root, in iterator.operator++ */
 887    
 888    header()->parent()=node_impl_pointer(0);
 889    header()->left()=header()->impl();
 890    header()->right()=header()->impl();
 891  }
 892
 893  struct link_info
 894  {
 895    link_info():side(to_left){}
 896
 897    ordered_index_side side;
 898    node_impl_pointer  pos;
 899  };
 900
 901  bool link_point(key_param_type k,link_info& inf,ordered_unique_tag)
 902  {
 903    node_type* y=header();
 904    node_type* x=root();
 905    bool c=true;
 906    while(x){
 907      y=x;
 908      c=comp(k,key(x->value()));
 909      x=node_type::from_impl(c?x->left():x->right());
 910    }
 911    node_type* yy=y;
 912    if(c){
 913      if(yy==leftmost()){
 914        inf.side=to_left;
 915        inf.pos=y->impl();
 916        return true;
 917      }
 918      else node_type::decrement(yy);
 919    }
 920
 921    if(comp(key(yy->value()),k)){
 922      inf.side=c?to_left:to_right;
 923      inf.pos=y->impl();
 924      return true;
 925    }
 926    else{
 927      inf.pos=yy->impl();
 928      return false;
 929    }
 930  }
 931
 932  bool link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
 933  {
 934    node_type* y=header();
 935    node_type* x=root();
 936    bool c=true;
 937    while (x){
 938     y=x;
 939     c=comp(k,key(x->value()));
 940     x=node_type::from_impl(c?x->left():x->right());
 941    }
 942    inf.side=c?to_left:to_right;
 943    inf.pos=y->impl();
 944    return true;
 945  }
 946
 947  bool lower_link_point(key_param_type k,link_info& inf,ordered_non_unique_tag)
 948  {
 949    node_type* y=header();
 950    node_type* x=root();
 951    bool c=false;
 952    while (x){
 953     y=x;
 954     c=comp(key(x->value()),k);
 955     x=node_type::from_impl(c?x->right():x->left());
 956    }
 957    inf.side=c?to_right:to_left;
 958    inf.pos=y->impl();
 959    return true;
 960  }
 961
 962  bool hinted_link_point(
 963    key_param_type k,node_type* position,link_info& inf,ordered_unique_tag)
 964  {
 965    if(position->impl()==header()->left()){ 
 966      if(size()>0&&comp(k,key(position->value()))){
 967        inf.side=to_left;
 968        inf.pos=position->impl();
 969        return true;
 970      }
 971      else return link_point(k,inf,ordered_unique_tag());
 972    } 
 973    else if(position==header()){ 
 974      if(comp(key(rightmost()->value()),k)){
 975        inf.side=to_right;
 976        inf.pos=rightmost()->impl();
 977        return true;
 978      }
 979      else return link_point(k,inf,ordered_unique_tag());
 980    } 
 981    else{
 982      node_type* before=position;
 983      node_type::decrement(before);
 984      if(comp(key(before->value()),k)&&comp(k,key(position->value()))){
 985        if(before->right()==node_impl_pointer(0)){
 986          inf.side=to_right;
 987          inf.pos=before->impl();
 988          return true;
 989        }
 990        else{
 991          inf.side=to_left;
 992          inf.pos=position->impl();
 993          return true;
 994        }
 995      } 
 996      else return link_point(k,inf,ordered_unique_tag());
 997    }
 998  }
 999
1000  bool hinted_link_point(
1001    key_param_type k,node_type* position,link_info& inf,ordered_non_unique_tag)
1002  {
1003    if(position->impl()==header()->left()){ 
1004      if(size()>0&&!comp(key(position->value()),k)){
1005        inf.side=to_left;
1006        inf.pos=position->impl();
1007        return true;
1008      }
1009      else return lower_link_point(k,inf,ordered_non_unique_tag());
1010    } 
1011    else if(position==header()){
1012      if(!comp(k,key(rightmost()->value()))){
1013        inf.side=to_right;
1014        inf.pos=rightmost()->impl();
1015        return true;
1016      }
1017      else return link_point(k,inf,ordered_non_unique_tag());
1018    } 
1019    else{
1020      node_type* before=position;
1021      node_type::decrement(before);
1022      if(!comp(k,key(before->value()))){
1023        if(!comp(key(position->value()),k)){
1024          if(before->right()==node_impl_pointer(0)){
1025            inf.side=to_right;
1026            inf.pos=before->impl();
1027            return true;
1028          }
1029          else{
1030            inf.side=to_left;
1031            inf.pos=position->impl();
1032            return true;
1033          }
1034        }
1035        else return lower_link_point(k,inf,ordered_non_unique_tag());
1036      } 
1037      else return link_point(k,inf,ordered_non_unique_tag());
1038    }
1039  }
1040
1041  void delete_all_nodes(node_type* x)
1042  {
1043    if(!x)return;
1044
1045    delete_all_nodes(node_type::from_impl(x->left()));
1046    delete_all_nodes(node_type::from_impl(x->right()));
1047    this->final_delete_node_(static_cast<final_node_type*>(x));
1048  }
1049
1050  bool in_place(value_param_type v,node_type* x,ordered_unique_tag)
1051  {
1052    node_type* y;
1053    if(x!=leftmost()){
1054      y=x;
1055      node_type::decrement(y);
1056      if(!comp(key(y->value()),key(v)))return false;
1057    }
1058
1059    y=x;
1060    node_type::increment(y);
1061    return y==header()||comp(key(v),key(y->value()));
1062  }
1063
1064  bool in_place(value_param_type v,node_type* x,ordered_non_unique_tag)
1065  {
1066    node_type* y;
1067    if(x!=leftmost()){
1068      y=x;
1069      node_type::decrement(y);
1070      if(comp(key(v),key(y->value())))return false;
1071    }
1072
1073    y=x;
1074    node_type::increment(y);
1075    return y==header()||!comp(key(y->value()),key(v));
1076  }
1077
1078#if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE)
1079  void detach_iterators(node_type* x)
1080  {
1081    iterator it=make_iterator(x);
1082    safe_mode::detach_equivalent_iterators(it);
1083  }
1084#endif
1085
1086  template<typename LowerBounder,typename UpperBounder>
1087  std::pair<iterator,iterator>
1088  range(LowerBounder lower,UpperBounder upper,none_unbounded_tag)const
1089  {
1090    node_type* y=header();
1091    node_type* z=root();
1092
1093    while(z){
1094      if(!lower(key(z->value()))){
1095        z=node_type::from_impl(z->right());
1096      }
1097      else if(!upper(key(z->value()))){
1098        y=z;
1099        z=node_type::from_impl(z->left());
1100      }
1101      else{
1102        return std::pair<iterator,iterator>(
1103          make_iterator(
1104            lower_range(node_type::from_impl(z->left()),z,lower)),
1105          make_iterator(
1106            upper_range(node_type::from_impl(z->right()),y,upper)));
1107      }
1108    }
1109
1110    return std::pair<iterator,iterator>(make_iterator(y),make_iterator(y));
1111  }
1112
1113  template<typename LowerBounder,typename UpperBounder>
1114  std::pair<iterator,iterator>
1115  range(LowerBounder,UpperBounder upper,lower_unbounded_tag)const
1116  {
1117    return std::pair<iterator,iterator>(
1118      begin(),
1119      make_iterator(upper_range(root(),header(),upper)));
1120  }
1121
1122  template<typename LowerBounder,typename UpperBounder>
1123  std::pair<iterator,iterator>
1124  range(LowerBounder lower,UpperBounder,upper_unbounded_tag)const
1125  {
1126    return std::pair<iterator,iterator>(
1127      make_iterator(lower_range(root(),header(),lower)),
1128      end());
1129  }
1130
1131  template<typename LowerBounder,typename UpperBounder>
1132  std::pair<iterator,iterator>
1133  range(LowerBounder,UpperBounder,both_unbounded_tag)const
1134  {
1135    return std::pair<iterator,iterator>(begin(),end());
1136  }
1137
1138  template<typename LowerBounder>
1139  node_type * lower_range(node_type* top,node_type* y,LowerBounder lower)const
1140  {
1141    while(top){
1142      if(lower(key(top->value()))){
1143        y=top;
1144        top=node_type::from_impl(top->left());
1145      }
1146      else top=node_type::from_impl(top->right());
1147    }
1148
1149    return y;
1150  }
1151
1152  template<typename UpperBounder>
1153  node_type * upper_range(node_type* top,node_type* y,UpperBounder upper)const
1154  {
1155    while(top){
1156      if(!upper(key(top->value()))){
1157        y=top;
1158        top=node_type::from_impl(top->left());
1159      }
1160      else top=node_type::from_impl(top->right());
1161    }
1162
1163    return y;
1164  }
1165
1166#if !defined(BOOST_MULTI_INDEX_DISABLE_SERIALIZATION)
1167  template<typename Archive>
1168  void save_(
1169    Archive& ar,const unsigned int version,const index_saver_type& sm,
1170    ordered_unique_tag)const
1171  {
1172    super::save_(ar,version,sm);
1173  }
1174
1175  template<typename Archive>
1176  void load_(
1177    Archive& ar,const unsigned int version,const index_loader_type& lm,
1178    ordered_unique_tag)
1179  {
1180    super::load_(ar,version,lm);
1181  }
1182
1183  template<typename Archive>
1184  void save_(
1185    Archive& ar,const unsigned int version,const index_saver_type& sm,
1186    ordered_non_unique_tag)const
1187  {
1188    typedef duplicates_iterator<node_type,value_compare> dup_iterator;
1189
1190    sm.save(
1191      dup_iterator(begin().get_node(),end().get_node(),value_comp()),
1192      dup_iterator(end().get_node(),value_comp()),
1193      ar,version);
1194    super::save_(ar,version,sm);
1195  }
1196
1197  template<typename Archive>
1198  void load_(
1199    Archive& ar,const unsigned int version,const index_loader_type& lm,
1200    ordered_non_unique_tag)
1201  {
1202    lm.load(
1203      ::boost::bind(&ordered_index::rearranger,this,_1,_2),
1204      ar,version);
1205    super::load_(ar,version,lm);
1206  }
1207
1208  void rearranger(node_type* position,node_type *x)
1209  {
1210    if(!position||comp(key(position->value()),key(x->value()))){
1211      position=lower_bound(key(x->value())).get_node();
1212    }
1213    else if(comp(key(x->value()),key(position->value()))){
1214      /* inconsistent rearrangement */
1215      throw_exception(
1216        archive::archive_exception(
1217          archive::archive_exception::other_exception));
1218    }
1219    else node_type::increment(position);
1220
1221    if(position!=x){
1222      node_impl_type::rebalance_for_erase(
1223        x->impl(),header()->parent(),header()->left(),header()->right());
1224      node_impl_type::restore(
1225        x->impl(),position->impl(),header()->impl());
1226    }
1227  }
1228#endif /* serialization */
1229
1230  key_from_value key;
1231  key_compare    comp;
1232
1233#if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\
1234    BOOST_WORKAROUND(__MWERKS__,<=0x3003)
1235#pragma parse_mfunc_templ reset
1236#endif
1237};
1238
1239/* comparison */
1240
1241template<
1242  typename KeyFromValue1,typename Compare1,
1243  typename SuperMeta1,typename TagList1,typename Category1,
1244  typename KeyFromValue2,typename Compare2,
1245  typename SuperMeta2,typename TagList2,typename Category2
1246>
1247bool operator==(
1248  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1249  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1250{
1251  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
1252}
1253
1254template<
1255  typename KeyFromValue1,typename Compare1,
1256  typename SuperMeta1,typename TagList1,typename Category1,
1257  typename KeyFromValue2,typename Compare2,
1258  typename SuperMeta2,typename TagList2,typename Category2
1259>
1260bool operator<(
1261  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1262  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1263{
1264  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
1265}
1266
1267template<
1268  typename KeyFromValue1,typename Compare1,
1269  typename SuperMeta1,typename TagList1,typename Category1,
1270  typename KeyFromValue2,typename Compare2,
1271  typename SuperMeta2,typename TagList2,typename Category2
1272>
1273bool operator!=(
1274  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1275  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1276{
1277  return !(x==y);
1278}
1279
1280template<
1281  typename KeyFromValue1,typename Compare1,
1282  typename SuperMeta1,typename TagList1,typename Category1,
1283  typename KeyFromValue2,typename Compare2,
1284  typename SuperMeta2,typename TagList2,typename Category2
1285>
1286bool operator>(
1287  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1288  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1289{
1290  return y<x;
1291}
1292
1293template<
1294  typename KeyFromValue1,typename Compare1,
1295  typename SuperMeta1,typename TagList1,typename Category1,
1296  typename KeyFromValue2,typename Compare2,
1297  typename SuperMeta2,typename TagList2,typename Category2
1298>
1299bool operator>=(
1300  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1301  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1302{
1303  return !(x<y);
1304}
1305
1306template<
1307  typename KeyFromValue1,typename Compare1,
1308  typename SuperMeta1,typename TagList1,typename Category1,
1309  typename KeyFromValue2,typename Compare2,
1310  typename SuperMeta2,typename TagList2,typename Category2
1311>
1312bool operator<=(
1313  const ordered_index<KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
1314  const ordered_index<KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y)
1315{
1316  return !(x>y);
1317}
1318
1319/*  specialized algorithms */
1320
1321template<
1322  typename KeyFromValue,typename Compare,
1323  typename SuperMeta,typename TagList,typename Category
1324>
1325void swap(
1326  ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
1327  ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& y)
1328{
1329  x.swap(y);
1330}
1331
1332} /* namespace multi_index::detail */
1333
1334/* ordered_index specifiers */
1335
1336template<typename Arg1,typename Arg2,typename Arg3>
1337struct ordered_unique
1338{
1339  typedef typename detail::ordered_index_args<
1340    Arg1,Arg2,Arg3>                                index_args;
1341  typedef typename index_args::tag_list_type::type tag_list_type;
1342  typedef typename index_args::key_from_value_type key_from_value_type;
1343  typedef typename index_args::compare_type        compare_type;
1344
1345  template<typename Super>
1346  struct node_class
1347  {
1348    typedef detail::ordered_index_node<Super> type;
1349  };
1350
1351  template<typename SuperMeta>
1352  struct index_class
1353  {
1354    typedef detail::ordered_index<
1355      key_from_value_type,compare_type,
1356      SuperMeta,tag_list_type,detail::ordered_unique_tag> type;
1357  };
1358};
1359
1360template<typename Arg1,typename Arg2,typename Arg3>
1361struct ordered_non_unique
1362{
1363  typedef detail::ordered_index_args<
1364    Arg1,Arg2,Arg3>                                index_args;
1365  typedef typename index_args::tag_list_type::type tag_list_type;
1366  typedef typename index_args::key_from_value_type key_from_value_type;
1367  typedef typename index_args::compare_type        compare_type;
1368
1369  template<typename Super>
1370  struct node_class
1371  {
1372    typedef detail::ordered_index_node<Super> type;
1373  };
1374
1375  template<typename SuperMeta>
1376  struct index_class
1377  {
1378    typedef detail::ordered_index<
1379      key_from_value_type,compare_type,
1380      SuperMeta,tag_list_type,detail::ordered_non_unique_tag> type;
1381  };
1382};
1383
1384} /* namespace multi_index */
1385
1386} /* namespace boost */
1387
1388#undef BOOST_MULTI_INDEX_ORD_INDEX_CHECK_INVARIANT
1389
1390#endif