PageRenderTime 18ms CodeModel.GetById 2ms app.highlight 13ms RepoModel.GetById 0ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/multi_index/detail/seq_index_ops.hpp

http://hadesmem.googlecode.com/
C++ Header | 200 lines | 148 code | 27 blank | 25 comment | 15 complexity | f6857280d112aa63d6bfba470a250dce MD5 | raw file
  1/* Copyright 2003-2008 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
  9#ifndef BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
 10#define BOOST_MULTI_INDEX_DETAIL_SEQ_INDEX_OPS_HPP
 11
 12#if defined(_MSC_VER)&&(_MSC_VER>=1200)
 13#pragma once
 14#endif
 15
 16#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
 17#include <boost/detail/no_exceptions_support.hpp>
 18#include <boost/multi_index/detail/seq_index_node.hpp>
 19#include <boost/limits.hpp>
 20#include <boost/type_traits/aligned_storage.hpp>
 21#include <boost/type_traits/alignment_of.hpp> 
 22#include <cstddef>
 23
 24namespace boost{
 25
 26namespace multi_index{
 27
 28namespace detail{
 29
 30/* Common code for sequenced_index memfuns having templatized and
 31 * non-templatized versions.
 32 */
 33
 34template <typename SequencedIndex,typename Predicate>
 35void sequenced_index_remove(SequencedIndex& x,Predicate pred)
 36{
 37  typedef typename SequencedIndex::iterator iterator;
 38  iterator first=x.begin(),last=x.end();
 39  while(first!=last){
 40    if(pred(*first))x.erase(first++);
 41    else ++first;
 42  }
 43}
 44
 45template <typename SequencedIndex,class BinaryPredicate>
 46void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
 47{
 48  typedef typename SequencedIndex::iterator iterator;
 49  iterator first=x.begin();
 50  iterator last=x.end();
 51  if(first!=last){
 52    for(iterator middle=first;++middle!=last;middle=first){
 53      if(binary_pred(*middle,*first))x.erase(middle);
 54      else first=middle;
 55    }
 56  }
 57}
 58
 59template <typename SequencedIndex,typename Compare>
 60void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
 61{
 62  typedef typename SequencedIndex::iterator iterator;
 63  if(&x!=&y){
 64    iterator first0=x.begin(),last0=x.end();
 65    iterator first1=y.begin(),last1=y.end();
 66    while(first0!=last0&&first1!=last1){
 67      if(comp(*first1,*first0))x.splice(first0,y,first1++);
 68      else ++first0;
 69    }
 70    x.splice(last0,y,first1,last1);
 71  }
 72}
 73
 74/* sorting  */
 75
 76/* auxiliary stuff */
 77
 78template<typename Node,typename Compare>
 79void sequenced_index_collate(
 80  BOOST_DEDUCED_TYPENAME Node::impl_type* x,
 81  BOOST_DEDUCED_TYPENAME Node::impl_type* y,
 82  Compare comp
 83  BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Node))
 84{
 85  typedef typename Node::impl_type    impl_type;
 86  typedef typename Node::impl_pointer impl_pointer;
 87
 88  impl_pointer first0=x->next();
 89  impl_pointer last0=x;
 90  impl_pointer first1=y->next();
 91  impl_pointer last1=y;
 92  while(first0!=last0&&first1!=last1){
 93    if(comp(
 94        Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
 95      impl_pointer tmp=first1->next();
 96      impl_type::relink(first0,first1);
 97      first1=tmp;
 98    }
 99    else first0=first0->next();
100  }
101  impl_type::relink(last0,first1,last1);
102}
103
104/* Some versions of CGG require a bogus typename in counter_spc
105 * inside sequenced_index_sort if the following is defined
106 * also inside sequenced_index_sort.
107 */
108
109BOOST_STATIC_CONSTANT(
110  std::size_t,
111  sequenced_index_sort_max_fill=
112    (std::size_t)std::numeric_limits<std::size_t>::digits+1);
113
114template<typename Node,typename Compare>
115void sequenced_index_sort(Node* header,Compare comp)
116{
117  /* Musser's mergesort, see http://www.cs.rpi.edu/~musser/gp/List/lists1.html.
118   * The implementation is a little convoluted: in the original code
119   * counter elements and carry are std::lists: here we do not want
120   * to use multi_index instead, so we do things at a lower level, managing
121   * directly the internal node representation.
122   * Incidentally, the implementations I've seen of this algorithm (SGI,
123   * Dinkumware, STLPort) are not exception-safe: this is. Moreover, we do not
124   * use any dynamic storage.
125   */
126
127  if(header->next()==header->impl()||
128     header->next()->next()==header->impl())return;
129
130  typedef typename Node::impl_type      impl_type;
131  typedef typename Node::impl_pointer   impl_pointer;
132
133  typedef typename aligned_storage<
134    sizeof(impl_type),
135    alignment_of<impl_type>::value
136  >::type                               carry_spc_type;
137  carry_spc_type                        carry_spc;
138  impl_type&                            carry=
139    *static_cast<impl_type*>(static_cast<void*>(&carry_spc));
140  typedef typename aligned_storage<
141    sizeof(
142      impl_type
143        [sequenced_index_sort_max_fill]),
144    alignment_of<
145      impl_type
146        [sequenced_index_sort_max_fill]
147    >::value
148  >::type                               counter_spc_type;
149  counter_spc_type                      counter_spc;
150  impl_type*                            counter=
151    static_cast<impl_type*>(static_cast<void*>(&counter_spc));
152  std::size_t                           fill=0;
153
154  carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
155  counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);
156
157  BOOST_TRY{
158    while(header->next()!=header->impl()){
159      impl_type::relink(carry.next(),header->next());
160      std::size_t i=0;
161      while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
162        sequenced_index_collate<Node>(&carry,&counter[i++],comp);
163      }
164      impl_type::swap(
165        static_cast<impl_pointer>(&carry),
166        static_cast<impl_pointer>(&counter[i]));
167      if(i==fill){
168        ++fill;
169        counter[fill].prior()=counter[fill].next()=
170          static_cast<impl_pointer>(&counter[fill]);
171      }
172    }
173
174    for(std::size_t i=1;i<fill;++i){
175      sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
176    }
177    impl_type::swap(
178      header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
179  }
180  BOOST_CATCH(...)
181  {
182    impl_type::relink(
183      header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
184    for(std::size_t i=0;i<=fill;++i){
185      impl_type::relink(
186        header->impl(),counter[i].next(),
187        static_cast<impl_pointer>(&counter[i]));
188    }
189    BOOST_RETHROW;
190  }
191  BOOST_CATCH_END
192}
193
194} /* namespace multi_index::detail */
195
196} /* namespace multi_index */
197
198} /* namespace boost */
199
200#endif