Ticket #5963: ptr_container.vp_iterator.comparators.patch

File ptr_container.vp_iterator.comparators.patch, 73.1 KB (added by Rob Desbois <rob.desbois@…>, 11 years ago)

Patch to ptr_container to fix #5961

Line 
1diff -Naur boost_1_47_0/boost/ptr_container/detail/void_ptr_iterator.hpp boost_1_47_0.patched/boost/ptr_container/detail/void_ptr_iterator.hpp
2--- boost_1_47_0/boost/ptr_container/detail/void_ptr_iterator.hpp 2008-03-22 21:45:55.000000000 +0000
3+++ boost_1_47_0.patched/boost/ptr_container/detail/void_ptr_iterator.hpp 2011-09-29 13:54:40.315982719 +0100
4@@ -24,6 +24,7 @@
5 {
6 template
7 <
8+ class C,
9 class VoidIter,
10 class T
11 >
12@@ -53,8 +54,8 @@
13 //
14 // Remark: passing by value breaks vc7.1
15 //
16- template< class MutableIterator, class MutableT >
17- void_ptr_iterator( const void_ptr_iterator<MutableIterator,MutableT>& r )
18+ template< class MutableContainer, class MutableIterator, class MutableT >
19+ void_ptr_iterator( const void_ptr_iterator<MutableContainer,MutableIterator,MutableT>& r )
20 #ifdef BOOST_NO_SFINAE
21 : iter_( VoidIter(const_cast<void**>(&*r.base())) )
22 #else
23@@ -123,48 +124,48 @@
24
25 }; // class 'void_ptr_iterator'
26
27- template< class VoidIter, class T >
28- inline void_ptr_iterator<VoidIter,T>
29- operator+( void_ptr_iterator<VoidIter,T> l,
30- BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
31+ template< class C, class VoidIter, class T >
32+ inline void_ptr_iterator<C,VoidIter,T>
33+ operator+( void_ptr_iterator<C,VoidIter,T> l,
34+ BOOST_DEDUCED_TYPENAME void_ptr_iterator<C,VoidIter,T>::difference_type n )
35 {
36 l += n;
37 return l;
38 }
39
40- template< class VoidIter, class T >
41- inline void_ptr_iterator<VoidIter,T>
42- operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n,
43- void_ptr_iterator<VoidIter,T> r )
44+ template< class C, class VoidIter, class T >
45+ inline void_ptr_iterator<C,VoidIter,T>
46+ operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator<C,VoidIter,T>::difference_type n,
47+ void_ptr_iterator<C,VoidIter,T> r )
48
49 {
50 r += n;
51 return r;
52 }
53
54- template< class VoidIter, class T >
55- inline void_ptr_iterator<VoidIter,T>
56- operator-( void_ptr_iterator<VoidIter,T> l,
57- BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
58+ template< class C, class VoidIter, class T >
59+ inline void_ptr_iterator<C,VoidIter,T>
60+ operator-( void_ptr_iterator<C,VoidIter,T> l,
61+ BOOST_DEDUCED_TYPENAME void_ptr_iterator<C,VoidIter,T>::difference_type n )
62 {
63 l -= n;
64 return l;
65 }
66
67- template< class VoidIter, class T >
68- inline void_ptr_iterator<VoidIter,T>
69- operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n,
70- void_ptr_iterator<VoidIter,T> r )
71+ template< class C, class VoidIter, class T >
72+ inline void_ptr_iterator<C,VoidIter,T>
73+ operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator<C,VoidIter,T>::difference_type n,
74+ void_ptr_iterator<C,VoidIter,T> r )
75
76 {
77 r -= n;
78 return r;
79 }
80
81- template< class VoidIter, class T, class VoidIterU, class U >
82- inline BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type
83- operator-( void_ptr_iterator<VoidIter,T> l,
84- void_ptr_iterator<VoidIterU,U> r )
85+ template< class C, class VoidIter, class T, class VoidIterU, class U >
86+ inline BOOST_DEDUCED_TYPENAME void_ptr_iterator<C,VoidIter,T>::difference_type
87+ operator-( void_ptr_iterator<C,VoidIter,T> l,
88+ void_ptr_iterator<C,VoidIterU,U> r )
89
90 {
91 return l.base() - r.base();
92@@ -172,54 +173,54 @@
93
94
95
96- template< class VoidIterT, class T, class VoidIterU, class U >
97- inline bool operator==( const void_ptr_iterator<VoidIterT,T>& l,
98- const void_ptr_iterator<VoidIterU,U>& r )
99+ template< class C, class VoidIterT, class T, class VoidIterU, class U>
100+ inline bool operator==( const void_ptr_iterator<C,VoidIterT,T>& l,
101+ const void_ptr_iterator<C,VoidIterU,U>& r )
102 {
103 return l.base() == r.base();
104 }
105
106
107
108- template< class VoidIterT, class T, class VoidIterU, class U >
109- inline bool operator!=( const void_ptr_iterator<VoidIterT,T>& l,
110- const void_ptr_iterator<VoidIterU,U>& r )
111+ template< class C, class VoidIterT, class T, class VoidIterU, class U >
112+ inline bool operator!=( const void_ptr_iterator<C,VoidIterT,T>& l,
113+ const void_ptr_iterator<C,VoidIterU,U>& r )
114 {
115 return l.base() != r.base();
116 }
117
118
119
120- template< class VoidIterT, class T, class VoidIterU, class U >
121- inline bool operator<( const void_ptr_iterator<VoidIterT,T>& l,
122- const void_ptr_iterator<VoidIterU,U>& r )
123+ template< class C, class VoidIterT, class T, class VoidIterU, class U >
124+ inline bool operator<( const void_ptr_iterator<C,VoidIterT,T>& l,
125+ const void_ptr_iterator<C,VoidIterU,U>& r )
126 {
127 return l.base() < r.base();
128 }
129
130
131
132- template< class VoidIterT, class T, class VoidIterU, class U >
133- inline bool operator<=( const void_ptr_iterator<VoidIterT,T>& l,
134- const void_ptr_iterator<VoidIterU,U>& r )
135+ template< class C, class VoidIterT, class T, class VoidIterU, class U >
136+ inline bool operator<=( const void_ptr_iterator<C,VoidIterT,T>& l,
137+ const void_ptr_iterator<C,VoidIterU,U>& r )
138 {
139 return l.base() <= r.base();
140 }
141
142
143
144- template< class VoidIterT, class T, class VoidIterU, class U >
145- inline bool operator>( const void_ptr_iterator<VoidIterT,T>& l,
146- const void_ptr_iterator<VoidIterU,U>& r )
147+ template< class C, class VoidIterT, class T, class VoidIterU, class U >
148+ inline bool operator>( const void_ptr_iterator<C,VoidIterT,T>& l,
149+ const void_ptr_iterator<C,VoidIterU,U>& r )
150 {
151 return l.base() > r.base();
152 }
153
154
155
156- template< class VoidIterT, class T, class VoidIterU, class U >
157- inline bool operator>=( const void_ptr_iterator<VoidIterT,T>& l,
158- const void_ptr_iterator<VoidIterU,U>& r )
159+ template< class C, class VoidIterT, class T, class VoidIterU, class U >
160+ inline bool operator>=( const void_ptr_iterator<C,VoidIterT,T>& l,
161+ const void_ptr_iterator<C,VoidIterU,U>& r )
162 {
163 return l.base() >= r.base();
164 }
165diff -Naur boost_1_47_0/boost/ptr_container/ptr_array.hpp boost_1_47_0.patched/boost/ptr_container/ptr_array.hpp
166--- boost_1_47_0/boost/ptr_container/ptr_array.hpp 2008-06-24 21:37:35.000000000 +0100
167+++ boost_1_47_0.patched/boost/ptr_container/ptr_array.hpp 2011-09-29 12:48:07.197086584 +0100
168@@ -55,12 +55,14 @@
169 class CloneAllocator = heap_clone_allocator
170 >
171 class ptr_array : public
172- ptr_sequence_adapter< T,
173+ ptr_sequence_adapter< ptr_array<T,N,CloneAllocator>,
174+ T,
175 ptr_container_detail::ptr_array_impl<void*,N>,
176 CloneAllocator >
177 {
178 private:
179- typedef ptr_sequence_adapter< T,
180+ typedef ptr_sequence_adapter< ptr_array<T,N,CloneAllocator>,
181+ T,
182 ptr_container_detail::ptr_array_impl<void*,N>,
183 CloneAllocator >
184 base_class;
185diff -Naur boost_1_47_0/boost/ptr_container/ptr_circular_buffer.hpp boost_1_47_0.patched/boost/ptr_container/ptr_circular_buffer.hpp
186--- boost_1_47_0/boost/ptr_container/ptr_circular_buffer.hpp 2009-11-01 11:07:12.000000000 +0000
187+++ boost_1_47_0.patched/boost/ptr_container/ptr_circular_buffer.hpp 2011-09-29 12:49:25.725084542 +0100
188@@ -29,11 +29,13 @@
189 class Allocator = std::allocator<void*>
190 >
191 class ptr_circular_buffer : public
192- ptr_sequence_adapter< T,
193+ ptr_sequence_adapter< ptr_circular_buffer<T,CloneAllocator,Allocator>,
194+ T,
195 boost::circular_buffer<void*,Allocator>,
196 CloneAllocator >
197 {
198- typedef ptr_sequence_adapter< T,
199+ typedef ptr_sequence_adapter< ptr_circular_buffer<T,CloneAllocator,Allocator>,
200+ T,
201 boost::circular_buffer<void*,Allocator>,
202 CloneAllocator >
203 base_type;
204diff -Naur boost_1_47_0/boost/ptr_container/ptr_deque.hpp boost_1_47_0.patched/boost/ptr_container/ptr_deque.hpp
205--- boost_1_47_0/boost/ptr_container/ptr_deque.hpp 2008-06-24 21:37:35.000000000 +0100
206+++ boost_1_47_0.patched/boost/ptr_container/ptr_deque.hpp 2011-09-29 12:49:56.900083730 +0100
207@@ -29,11 +29,13 @@
208 class Allocator = std::allocator<void*>
209 >
210 class ptr_deque : public
211- ptr_sequence_adapter< T,
212+ ptr_sequence_adapter< ptr_deque<T,CloneAllocator,Allocator>,
213+ T,
214 std::deque<void*,Allocator>,
215 CloneAllocator >
216 {
217- typedef ptr_sequence_adapter< T,
218+ typedef ptr_sequence_adapter< ptr_deque<T,CloneAllocator,Allocator>,
219+ T,
220 std::deque<void*,Allocator>,
221 CloneAllocator >
222 base_class;
223diff -Naur boost_1_47_0/boost/ptr_container/ptr_list.hpp boost_1_47_0.patched/boost/ptr_container/ptr_list.hpp
224--- boost_1_47_0/boost/ptr_container/ptr_list.hpp 2008-06-24 21:37:35.000000000 +0100
225+++ boost_1_47_0.patched/boost/ptr_container/ptr_list.hpp 2011-09-29 12:50:26.300082966 +0100
226@@ -29,11 +29,13 @@
227 class Allocator = std::allocator<void*>
228 >
229 class ptr_list : public
230- ptr_sequence_adapter< T,
231+ ptr_sequence_adapter< ptr_list<T,CloneAllocator,Allocator>,
232+ T,
233 std::list<void*,Allocator>,
234 CloneAllocator >
235 {
236- typedef ptr_sequence_adapter< T,
237+ typedef ptr_sequence_adapter< ptr_list<T,CloneAllocator,Allocator>,
238+ T,
239 std::list<void*,Allocator>,
240 CloneAllocator >
241 base_class;
242diff -Naur boost_1_47_0/boost/ptr_container/ptr_sequence_adapter.hpp boost_1_47_0.patched/boost/ptr_container/ptr_sequence_adapter.hpp
243--- boost_1_47_0/boost/ptr_container/ptr_sequence_adapter.hpp 2009-11-01 11:07:12.000000000 +0000
244+++ boost_1_47_0.patched/boost/ptr_container/ptr_sequence_adapter.hpp 2011-09-29 12:52:58.025079018 +0100
245@@ -30,6 +30,7 @@
246 {
247 template
248 <
249+ class C,
250 class T,
251 class VoidPtrSeq
252 >
253@@ -46,11 +47,11 @@
254 typedef U value_type;
255
256 typedef void_ptr_iterator<
257- BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U >
258+ C, BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U >
259 iterator;
260
261 typedef void_ptr_iterator<
262- BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U >
263+ C, BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U >
264 const_iterator;
265
266 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
267@@ -63,7 +64,7 @@
268
269 #else
270 template< class Iter >
271- static U* get_pointer( void_ptr_iterator<Iter,U> i )
272+ static U* get_pointer( void_ptr_iterator<C,Iter,U> i )
273 {
274 return static_cast<U*>( *i.base() );
275 }
276@@ -87,13 +88,13 @@
277
278 #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
279 template< class Iter >
280- static const U* get_const_pointer( void_ptr_iterator<Iter,U> i )
281+ static const U* get_const_pointer( void_ptr_iterator<C,Iter,U> i )
282 {
283 return static_cast<const U*>( *i.base() );
284 }
285 #else // BOOST_WORKAROUND
286 template< class Iter >
287- static const U* get_const_pointer( void_ptr_iterator<Iter,const U> i )
288+ static const U* get_const_pointer( void_ptr_iterator<C,Iter,const U> i )
289 {
290 return static_cast<const U*>( *i.base() );
291 }
292@@ -112,8 +113,8 @@
293 } // ptr_container_detail
294
295
296- template< class Iterator, class T >
297- inline bool is_null( void_ptr_iterator<Iterator,T> i )
298+ template< class C, class Iterator, class T >
299+ inline bool is_null( void_ptr_iterator<C,Iterator,T> i )
300 {
301 return *i.base() == 0;
302 }
303@@ -122,15 +123,16 @@
304
305 template
306 <
307+ class C,
308 class T,
309 class VoidPtrSeq,
310 class CloneAllocator = heap_clone_allocator
311 >
312 class ptr_sequence_adapter : public
313- ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>,
314+ ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<C,T,VoidPtrSeq>,
315 CloneAllocator >
316 {
317- typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>,
318+ typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<C,T,VoidPtrSeq>,
319 CloneAllocator >
320 base_type;
321
322diff -Naur boost_1_47_0/boost/ptr_container/ptr_set_adapter.hpp boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpp
323--- boost_1_47_0/boost/ptr_container/ptr_set_adapter.hpp 2009-04-05 20:55:59.000000000 +0100
324+++ boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpp 2011-09-29 13:42:37.367001525 +0100
325@@ -27,6 +27,7 @@
326 {
327 template
328 <
329+ class C,
330 class Key,
331 class VoidPtrSet,
332 bool Ordered
333@@ -72,14 +73,15 @@
334 container_type;
335
336 typedef void_ptr_iterator<
337- BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key >
338+ C, BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key >
339 iterator;
340
341 typedef void_ptr_iterator<
342- BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
343+ C, BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
344 const_iterator;
345
346 typedef void_ptr_iterator<
347+ C,
348 BOOST_DEDUCED_TYPENAME
349 mpl::eval_if_c<Ordered,
350 select_iterator<VoidPtrSet>,
351@@ -88,6 +90,7 @@
352 local_iterator;
353
354 typedef void_ptr_iterator<
355+ C,
356 BOOST_DEDUCED_TYPENAME
357 mpl::eval_if_c<Ordered,
358 select_iterator<VoidPtrSet>,
359@@ -114,16 +117,17 @@
360
361 template
362 <
363+ class C,
364 class Key,
365 class VoidPtrSet,
366 class CloneAllocator = heap_clone_allocator,
367 bool Ordered = true
368 >
369 class ptr_set_adapter_base
370- : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
371+ : public ptr_container_detail::associative_ptr_container< set_config<C,Key,VoidPtrSet,Ordered>,
372 CloneAllocator >
373 {
374- typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
375+ typedef ptr_container_detail::associative_ptr_container< set_config<C,Key,VoidPtrSet,Ordered>,
376 CloneAllocator >
377 base_type;
378 public:
379@@ -173,8 +177,8 @@
380 : base_type( first, last, hash, pred, a )
381 { }
382
383- template< class U, class Set, class CA, bool b >
384- ptr_set_adapter_base( const ptr_set_adapter_base<U,Set,CA,b>& r )
385+ template< class C2, class U, class Set, class CA, bool b >
386+ ptr_set_adapter_base( const ptr_set_adapter_base<C2,U,Set,CA,b>& r )
387 : base_type( r )
388 { }
389
390@@ -291,15 +295,16 @@
391
392 template
393 <
394+ class C,
395 class Key,
396 class VoidPtrSet,
397 class CloneAllocator = heap_clone_allocator,
398 bool Ordered = true
399 >
400 class ptr_set_adapter :
401- public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
402+ public ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrSet,CloneAllocator,Ordered>
403 {
404- typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
405+ typedef ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrSet,CloneAllocator,Ordered>
406 base_type;
407
408 public: // typedefs
409@@ -380,8 +385,8 @@
410 : base_type( r )
411 { }
412
413- template< class U, class Set, class CA, bool b >
414- explicit ptr_set_adapter( const ptr_set_adapter<U,Set,CA,b>& r )
415+ template< class C2, class U, class Set, class CA, bool b >
416+ explicit ptr_set_adapter( const ptr_set_adapter<C2,U,Set,CA,b>& r )
417 : base_type( r )
418 { }
419
420@@ -390,8 +395,8 @@
421 : base_type( clone )
422 { }
423
424- template< class U, class Set, class CA, bool b >
425- ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r )
426+ template< class C2, class U, class Set, class CA, bool b >
427+ ptr_set_adapter& operator=( const ptr_set_adapter<C2,U,Set,CA,b>& r )
428 {
429 base_type::operator=( r );
430 return *this;
431@@ -503,15 +508,16 @@
432
433 template
434 <
435+ class C,
436 class Key,
437 class VoidPtrMultiSet,
438 class CloneAllocator = heap_clone_allocator,
439 bool Ordered = true
440 >
441 class ptr_multiset_adapter :
442- public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered>
443+ public ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrMultiSet,CloneAllocator,Ordered>
444 {
445- typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type;
446+ typedef ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type;
447
448 public: // typedefs
449
450@@ -580,8 +586,8 @@
451 : base_type( first, last, hash, pred, a )
452 { }
453
454- template< class U, class Set, class CA, bool b >
455- explicit ptr_multiset_adapter( const ptr_multiset_adapter<U,Set,CA,b>& r )
456+ template< class C2, class U, class Set, class CA, bool b >
457+ explicit ptr_multiset_adapter( const ptr_multiset_adapter<C2,U,Set,CA,b>& r )
458 : base_type( r )
459 { }
460
461@@ -590,8 +596,8 @@
462 : base_type( clone )
463 { }
464
465- template< class U, class Set, class CA, bool b >
466- ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r )
467+ template< class C2, class U, class Set, class CA, bool b >
468+ ptr_multiset_adapter& operator=( const ptr_multiset_adapter<C2,U,Set,CA,b>& r )
469 {
470 base_type::operator=( r );
471 return *this;
472diff -Naur boost_1_47_0/boost/ptr_container/.ptr_set_adapter.hpp.swp boost_1_47_0.patched/boost/ptr_container/.ptr_set_adapter.hpp.swp
473--- boost_1_47_0/boost/ptr_container/.ptr_set_adapter.hpp.swp 1970-01-01 01:00:00.000000000 +0100
474+++ boost_1_47_0.patched/boost/ptr_container/.ptr_set_adapter.hpp.swp 2011-09-29 13:42:41.422001417 +0100
475@@ -0,0 +1,62 @@
476+b0VIM 7.3½g„NÓ4robdlocalhost.localdomain~robd/bits/boost_1_47_0.patched/boost/ptr_container/ptr_set_adapter.hpputf-8
4773210#"! Utp
478+{:|%· 5Û
479+^!n
480E`Ôh3›ad{ýâߟ\!÷ô®«ªzJI
481Ã
482Š 483N 484$ 485# 486 487 488ò489ð490ã491Ü492Ï493¼494¢495Œ496†497p498j499O500&501%502ã503¿504¾505ž506507‚508d509c510<511512Û 513+¥ 514+‚ 515+ 516+c 517+B 518+A 519+ 520+÷ È Œ p o H % ö·˜—pRÚ¶µ“E'&ª†…521cY6א}YX6, ãª]DéÀ·…522|{](çÞݤœš•ˆr_D class CloneAllocator = heap_clone_allocator, class VoidPtrSet, class Key, class C, < template }; BOOST_STATIC_CONSTANT(bool, allow_null = false ); } return static_cast<const Key*>( *i.base() ); { static const Key* get_const_pointer( Iter i ) template< class Iter > } return static_cast<Key*>( *i.base() ); { static Key* get_pointer( Iter i ) template< class Iter > const_local_iterator; const Key > select_const_local_iterator<VoidPtrSet> >::type, select_iterator<VoidPtrSet>, mpl::eval_if_c<Ordered, BOOST_DEDUCED_TYPENAME C, typedef void_ptr_iterator< local_iterator; Key > select_local_iterator<VoidPtrSet> >::type, select_iterator<VoidPtrSet>, mpl::eval_if_c<Ordered, BOOST_DEDUCED_TYPENAME C, typedef void_ptr_iterator< const_iterator; C, BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key > typedef void_ptr_iterator< iterator; C, BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > typedef void_ptr_iterator< container_type; unordered_associative_container_tag>::type ordered_associative_container_tag, mpl::if_c<Ordered, typedef BOOST_DEDUCED_TYPENAME key_equal; select_key_equal<VoidPtrSet> >::type mpl::identity<void>, mpl::eval_if_c<Ordered, typedef BOOST_DEDUCED_TYPENAME hasher; select_hasher<VoidPtrSet> >::type mpl::identity<void>, mpl::eval_if_c<Ordered, typedef BOOST_DEDUCED_TYPENAME key_compare; typedef value_compare value_compare; mpl::identity<void> >::type select_value_compare<VoidPtrSet>, mpl::eval_if_c<Ordered, typedef BOOST_DEDUCED_TYPENAME key_type; typedef value_type typedef Key value_type; allocator_type; typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type void_container_type; typedef VoidPtrSet { struct set_config > bool Ordered class VoidPtrSet, class Key, class C, < template{namespace ptr_container_detail{namespace boost#include <boost/range/iterator_range.hpp>#include <boost/ptr_container/detail/void_ptr_iterator.hpp>#include <boost/ptr_container/detail/meta_functions.hpp>#include <boost/ptr_container/detail/associative_ptr_container.hpp>#endif# pragma once#if defined(_MSC_VER) && (_MSC_VER >= 1200)#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP//// For more information, see http://www.boost.org/libs/ptr_container///// http://www.boost.org/LICENSE_1_0.txt)// 1.0. (See accompanying file LICENSE_1_0.txt or copy at// distribution is subject to the Boost Software License, Version// Copyright Thorsten Ottosen 2003-2005. Use, modification and//// Boost.Pointer Container//ad5235524®si+! ÓÉÀ‹Bç 525¥ 526› 527V 528L 529K 530< 531; 532 533Ý534Ó535›536q537g538^539W540V541=542<54355444545#endif} // namespace 'boost' }; } BOOST_ASSERT( from.empty() ); transfer( from.begin(), from.end(), from ); { void transfer( PtrSetAdapter& from ) // basic template< class PtrSetAdapter >#endif } return transfer( boost::begin(r), boost::end(r), from ); { transfer( const Range& r, PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, template< class PtrSetAdapter, class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } return this->multi_transfer( first, last, from ); { PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, adÀÄ:ÜÖ¶NšT;-ñ 546Ñ 547 548i 549I 550 551 552ì553ë554ß555¿556³557²558559d560561æ562Ú563É564–565c566/567568569570Å 571+• 572+e 573+2 574+575 576+ 577+ÿ · p = ÛÏÎ}6Ö£pdTÄ}¡ bG;*¸šŽ…578B8÷îÄsi>$ùð¸®w<ížOÿ°˜  return res; this->remove( key ); // nothrow size_type res = this->base().erase( key ); // nothrow key = static_cast<key_type*>(*i.base()); // nothrow return 0u; // nothrow if( i == this->end() ) // nothrow iterator i( this->base().find( key ) ); key_type* key = const_cast<key_type*>(&x); { size_type erase( const key_type& x ) // nothrow using base_type::erase; } return *this; base_type::operator=( clone ); { ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone ) template< typename PtrContainer > } return *this; this->swap( r ); { ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) { } : base_type( clone ) explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone ) template< class PtrContainer > { } : base_type( r ) ptr_set_adapter_bas ptr_set_adapter_base( const ptr_set_adapter_base<CU,Set,CA,b>& ptr_set_adapter_base( const ptr_set_adapter_base<C2,U,Set,CA,b>& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_set_adapter_base( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > { } : base_type( first, last, comp, a ) const Allocator& a ) const Compare& comp, ptr_set_adapter_base( InputIterator first, InputIterator last, template< class InputIterator, class Compare, class Allocator > { } : base_type( hash, pred, a ) const Allocator& a ) const Pred& pred, ptr_set_adapter_base( const Hash& hash, template< class Hash, class Pred, class Allocator > { } : base_type( comp, a ) const Allocator& a ) ptr_set_adapter_base( const Compare& comp, template< class Compare, class Allocator > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_set_adapter_base( SizeType n, template< class SizeType > { } ptr_set_adapter_base() public: size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type typedef Key key_type; const_iterator; typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: base_type; CloneAllocator > typedef ptr_container_detail::associative_ptr_container< set_config<C,Key,VoidPtrSet,Ordered>, { CloneAllocator > : public ptr_container_detail::associative_ptr_container< set_config<C,Key,VoidPtrSet,Ordered>, class ptr_set_adapter_base > bool Ordered = truead 579+Ð 580+%åÙؚsb;ðÒƽzpS9/&ü 581« 582¡ 583v 584\ 585R 586Q 5871 588( 589ð590æ591¯592t593%594Ö595‡5967597è 598+Ð 599+ return res; this->remove( key ); // nothrow size_type res = this->base().erase( key ); // nothrow key = static_cast<key_type*>(*i.base()); // nothrow return 0u; // nothrow if( i == this->end() ) // nothrow iterator i( this->base().find( key ) ); key_type* key = const_cast<key_type*>(&x); { size_type erase( const key_type& x ) // nothrow using base_type::erase; } return *this; base_type::operator=( clone ); { ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone ) template< typename PtrContainer > } return *this; this->swap( r ); { ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) { } : base_type( clone ) explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone ) template< class PtrContainer > { } : base_type( r ) ptr_set_adapter_base( const ptr_set_adapter_base& r ) { } : base_type( r )ad} 600+601602!¸uG603ëá¶ut#á 604605‹ 606] 607) 608609 610611 612ß613Ä614¸615·616t617(618 619620621ø622Ñ623‹624m625a626`627628629ë 630+Ð 631+© 632+ 633+…634 635+„ 636+h 637+: 638+0 639+ 640+ÿ þ § – C 6 ö«s%ԇ}|`"îäãڙ<;û¿4ãÀ¶µ™[Q 641⚐YON÷îίX7-÷íìÝÜ´Á template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( where, x.release() ); { iterator insert( iterator where, std::auto_ptr<U> x ) template< class U > } return iterator( res); ptr.release(); if( *res == x ) res = this->base().insert( where.base(), x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { iterator insert( iterator where, key_type* x ) // strong } return insert( x.release() ); { std::pair<iterator,bool> insert( std::auto_ptr<U> x ) template< class U > } return std::make_pair( iterator( res.first ), res.second ); ptr.release(); if( res.second ) res = this->base().insert( x ); std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { std::pair<iterator,bool> insert( key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr<T> r ) template< class T > } return *this; base_type::operator=( r ); { ptr_set_a template< clclass U, class Set, class CA, template< class C2, class U, class Set, class CA, bool b > { } : base_type( clone ) explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone ) template< class PtrContainer > { } : base_type( r ) explicit ptr_set_adapter( const ptr_set_adapter<C2,U,Set,CA,b>& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( r ) explicit ptr_set_adapter( const ptr_set_adapter& r ) { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_set_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > } set_basic_clone_and_insert( first, last ); BOOST_ASSERT( this->empty() ); { : base_type( comp, a ) const Allocator a = Allocator() ) const Compare& comp, ptr_set_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Compare, class Allocator >adŸ`±zp6,+ð§_.$å 642Û 643Ú 644 645ƒ 646‚ 647M 648 649650h651'652653654Ø655Î656Í657Æ658Å659660b661X662663664665666667´ 668+˜ 669+J 670+I 671+< 672+5 673+( 674+ 675+õ À › • s 676 ‹sn0ɧ†J(á²¥Vÿæ—~ 677+¼mJE9 678ê¿aA54ܛ{on2ҟ const Allocator& a ) const Pred& pred, ptr_multiset_adapter( const Hash& hash, template< class Hash, class Pred, class Allocator > { } : base_type( comp, a ) const allocator_type& a ) explicit ptr_multiset_adapter( const Comp& comp, template< class Comp > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_multiset_adapter( SizeType n, template< class SizeType > { } ptr_multiset_adapter() public: } } ++first; insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit { while( first != last ) { void set_basic_clone_and_insert( II first, II last ) // basic template< typename II > private: allocator_type; typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type auto_type; typedef BOOST_DEDUCED_TYPENAME base_type::auto_type typedef Key key_type; size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: // typedefs typedef ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type; { public ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrMultiSet,CloneAllocator,Ordered> class ptr_multiset_adapter : > bool Ordered = true class CloneAllocator = heap_clone_allocator, class VoidPtrMultiSet, class Key, class C, < template ///////////////////////////////////////////////////////////////////////// // ptr_multiset_adapter ///////////////////////////////////////////////////////////////////////// }; } return transfer( from.begin(), from.end(), from ); { size_type transfer( PtrSetAdapter& from ) // basic template< class PtrSetAdapter >#endif } return transfer( boost::begin(r), boost::end(r), from ); { transfer( const Range& r, PtrSetAdapter& from ) // basic size_type >::type BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, template< class PtrSetAdapter, class Range >#else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } return this->single_transfer( first, last, from ); { PtrSetAdapter& from ) // basic BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, size_type template< class PtrSetAdapter > } return this->single_transfer( object, from ); { PtrSetAdapter& from ) // strong bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, adÓhÚÎÍ¥]9-$ð©y.Í 679à 680 681q 682* 683ú684Ê685—686d687X688G689690®691“692‡693~694W695696697î 698+â 699+á 700+ž 701+E 702+; 703+ 704+ú ð ç Ë  “ k a ` 705 ÞÓÒ¶wm;1,ÕÈpk+ð¦Uúùݯ¥{qlAù︮­`VM-·–ŒVLKDC̕‹YON&Óì size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, template< class PtrSetAdapter > } this->multi_transfer( object, from ); { PtrSetAdapter& from ) // strong void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( x.release() ); { iterator insert( std::auto_ptr<U> x ) template< class U > } return iterator( res ); ptr.release(); res = this->base().insert( x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" ); { iterator insert( key_type* x ) // strong } return insert( before, x.release() ); { iterator insert( iterator before, std::auto_ptr<U> x ) template< class U > } return base_type::insert( before, x ); { iterator insert( iterator before, key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr<T> r ) template< class T > } return *this; base_type::operator=( r ); { ptr_multiset_adapter& operator=( const ptr_multiset_adapter<C2,U,Set,CA,b>& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( clone ) explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone ) template< class PtrContainer > { } : base_type( r ) explicit ptr_multiset_adapter( const ptr_multiset_adapter<C2,U,Set,CA,b>& r ) template< class C2, class U, class Set, class CA, bool b > { } : base_type( first, last, hash, pred, a ) const Allocator& a ) const Pred& pred, const Hash& hash, ptr_multiset_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Hash, class Pred, class Allocator > } set_basic_clone_and_insert( first, last ); { : base_type( comp, a ) const allocator_type& a = allocator_type() ) const Comp& comp, ptr_multiset_adapter( InputIterator first, InputIterator last, template< class InputIterator, class Comp > { } : base_type( first, last ) ptr_multiset_adapter( InputIterator first, InputIterator last ) template< class InputIterator > { } : base_type( hash, pred, a )ad9)5öõô™CÊts 706‘ 7077 708á709à710…711712/713Õ714715)716Î 717+x 718+M 719+ñ › E ê”c 720·a°…7211ۅ722*Ô£Gñ›Eï©b@Å)( } iterator( p.second ) ); return make_iterator_range( iterator( p.first ), equal_range( const_cast<key_type*>(&x) ); p = this->base(). BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator, { iterator_range<iterator> equal_range( const key_type& x ) } upper_bound( const_cast<key_type*>(&x) ) ); return const_iterator( this->base(). { const_iterator upper_bound( const key_type& x ) const } upper_bound( const_cast<key_type*>(&x) ) ); return iterator( this->base(). { iterator upper_bound( const key_type& x ) } lower_bound( const_cast<key_type*>(&x) ) ); return const_iterator( this->base(). { const_iterator lower_bound( const key_type& x ) const } lower_bound( const_cast<key_type*>(&x) ) ); return iterator( this->base(). { iterator lower_bound( const key_type& x ) } return this->base().count( const_cast<key_type*>(&x) ); { size_type count( const key_type& x ) const } find( const_cast<key_type*>(&x) ) ); return const_iterator( this->base(). { const_iterator find( const key_type& x ) const } find( const_cast<key_type*>(&x) ) ); return iterator( this->base(). { iterator find( const key_type& x ) }ad£^ªZ¸kIÊ 723€ 724r 725q 726b 727, 728" 729Û730Ñ731Ê732É733¯734®735`736I737û738ø739ë740å741Ø742Å743ª744u745Q746K747.748Ë 749+Å 750+` 751+I 752+D 753+, 754+$ 755+é ¹ x B âÇg%øëâ“<힅756Kñ¢S0/# ýüÙ³Z:.%ҕsi=32öË rL@?Ô°¤£¢ { } : base_type( first, last ) ptr_set_adapter( InputIterator first, InputIterator last ) template< class InputIterator > { } : base_type( hash, pred, a ) const Allocator& a ) const Pred& pred, ptr_set_adapter( const Hash& hash, template< class Hash, class Pred, class Allocator > } BOOST_ASSERT( this->empty() ); { : base_type( comp, a ) const allocator_type& a ) explicit ptr_set_adapter( const Comp& comp, template< class Comp > { } : base_type( n, tag ) ptr_container_detail::unordered_associative_container_tag tag ) ptr_set_adapter( SizeType n, template< class SizeType > { } ptr_set_adapter() public: } } ++first; insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit if( this->find( *first ) == this->end() ) { while( first != last ) { void set_basic_clone_and_insert( II first, II last ) // basic template< typename II > private: allocator_type; typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type auto_type; typedef BOOST_DEDUCED_TYPENAME base_type::auto_type typedef Key key_type; size_type; typedef BOOST_DEDUCED_TYPENAME base_type::size_type const_iterator; typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator iterator; typedef BOOST_DEDUCED_TYPENAME base_type::iterator public: // typedefs base_type; typedef ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrSet,CloneAllocator,Ordered> { public ptr_container_detail::ptr_set_adapter_base<C,Key,VoidPtrSet,CloneAllocator,Ordered> class ptr_set_adapter : > bool Ordered = true class CloneAllocator = heap_clone_allocator, class VoidPtrSet, class Key, class C, < template ///////////////////////////////////////////////////////////////////////// // ptr_set_adapter /////////////////////////////////////////////////////////////////////////} // ptr_container_detail }; } return this->base().bucket( const_cast<key_type*>(&key) ); { size_type bucket( const key_type& key ) const protected: } const_iterator( p.second ) ); return make_iterator_range( const_iterator( p.first ), equal_range( const_cast<key_type*>(&x) ); p = this->base(). BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator, { iterator_range<const_iterator> equal_range( const key_type& x ) const ad[‹E±§€f\[?àÖÕ~m 757Í 758‚ 759J 760ü761«762^763T764S7657766ù767ï768Å769»770º771±772p773f774775776Ò 777+– 778+X 779+780 781+º —  Œ p 2 ( ÷íä¹qg0&%ØÎÅ¥†/ÎÄô³‹ template< class PtrSetAdapter >#endif } insert( boost::begin(r), boost::end(r) ); { insert( const Range& r ) boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type BOOST_DEDUCED_TYPENAME template< class Range > #else #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) } set_basic_clone_and_insert( first, last ); { void insert( InputIterator first, InputIterator last ) // basic template< typename InputIterator > } return insert( where, x.release() ); { iterator insert( iterator where, std::auto_ptr<U> x ) template< class U > } return iterator( res); ptr.release(); if( *res == x ) res = this->base().insert( where.base(), x ); BOOST_DEDUCED_TYPENAME base_type::ptr_iterator auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { iterator insert( iterator where, key_type* x ) // strong } return insert( x.release() ); { std::pair<iterator,bool> insert( std::auto_ptr<U> x ) template< class U > } return std::make_pair( iterator( res.first ), res.second ); ptr.release(); if( res.second ) res = this->base().insert( x ); std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> auto_type ptr( x ); this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); { std::pair<iterator,bool> insert( key_type* x ) // strong } base_type::operator=( r ); { void operator=( std::auto_ptr<T> r ) template< class T > } return *this; base_type::operator=( r ); { ptr_set_adapter& operator=( const ptr_set_adapter<C2,U,Set,CA,b>& r ) 782\ No newline at end of file 783diff -Naur boost_1_47_0/boost/ptr_container/ptr_set.hpp boost_1_47_0.patched/boost/ptr_container/ptr_set.hpp 784--- boost_1_47_0/boost/ptr_container/ptr_set.hpp 2008-06-24 21:37:35.000000000 +0100 785+++ boost_1_47_0.patched/boost/ptr_container/ptr_set.hpp 2011-09-29 13:37:53.921008898 +0100 786@@ -31,11 +31,13 @@ 787 class Allocator = std::allocator<void*> 788 > 789 class ptr_set : 790- public ptr_set_adapter< Key, 791+ public ptr_set_adapter< ptr_set<Key,Compare,CloneAllocator,Allocator>, 792+ Key, 793 std::set<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>, 794 CloneAllocator, true > 795 { 796- typedef ptr_set_adapter< Key, std::set<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>, 797+ typedef ptr_set_adapter< ptr_set<Key,Compare,CloneAllocator,Allocator>, 798+ Key, std::set<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>, 799 CloneAllocator, true > 800 base_type; 801 802@@ -80,11 +82,13 @@ 803 class Allocator = std::allocator<void*> 804 > 805 class ptr_multiset : 806- public ptr_multiset_adapter< Key, 807+ public ptr_multiset_adapter< ptr_multiset<Key,Compare,CloneAllocator,Allocator>, 808+ Key, 809 std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>, 810 CloneAllocator, true > 811 { 812- typedef ptr_multiset_adapter< Key, 813+ typedef ptr_multiset_adapter< ptr_multiset<Key,Compare,CloneAllocator,Allocator>, 814+ Key, 815 std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>, 816 CloneAllocator, true > 817 base_type; 818diff -Naur boost_1_47_0/boost/ptr_container/ptr_unordered_set.hpp boost_1_47_0.patched/boost/ptr_container/ptr_unordered_set.hpp 819--- boost_1_47_0/boost/ptr_container/ptr_unordered_set.hpp 2008-06-24 21:37:35.000000000 +0100 820+++ boost_1_47_0.patched/boost/ptr_container/ptr_unordered_set.hpp 2011-09-29 13:39:19.542006672 +0100 821@@ -32,12 +32,14 @@ 822 class Allocator = std::allocator<void*> 823 > 824 class ptr_unordered_set : 825- public ptr_set_adapter< Key, 826+ public ptr_set_adapter< ptr_unordered_set<Key,Hash,Pred,CloneAllocator,Allocator>, 827+ Key, 828 boost::unordered_set<void*,void_ptr_indirect_fun<Hash,Key>, 829 void_ptr_indirect_fun<Pred,Key>,Allocator>, 830 CloneAllocator, false > 831 { 832- typedef ptr_set_adapter< Key, 833+ typedef ptr_set_adapter< ptr_unordered_set<Key,Hash,Pred,CloneAllocator,Allocator>, 834+ Key, 835 boost::unordered_set<void*,void_ptr_indirect_fun<Hash,Key>, 836 void_ptr_indirect_fun<Pred,Key>,Allocator>, 837 CloneAllocator, false > 838@@ -122,12 +124,14 @@ 839 class Allocator = std::allocator<void*> 840 > 841 class ptr_unordered_multiset : 842- public ptr_multiset_adapter< Key, 843+ public ptr_multiset_adapter< ptr_unordered_multiset<Key,Hash,Pred,CloneAllocator,Allocator>, 844+ Key, 845 boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>, 846 void_ptr_indirect_fun<Pred,Key>,Allocator>, 847 CloneAllocator, false > 848 { 849- typedef ptr_multiset_adapter< Key, 850+ typedef ptr_multiset_adapter< ptr_unordered_multiset<Key,Hash,Pred,CloneAllocator,Allocator>, 851+ Key, 852 boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>, 853 void_ptr_indirect_fun<Pred,Key>,Allocator>, 854 CloneAllocator, false > 855diff -Naur boost_1_47_0/boost/ptr_container/ptr_vector.hpp boost_1_47_0.patched/boost/ptr_container/ptr_vector.hpp 856--- boost_1_47_0/boost/ptr_container/ptr_vector.hpp 2008-06-24 21:37:35.000000000 +0100 857+++ boost_1_47_0.patched/boost/ptr_container/ptr_vector.hpp 2011-09-29 12:50:48.982082374 +0100 858@@ -29,11 +29,13 @@ 859 class Allocator = std::allocator<void*> 860 > 861 class ptr_vector : public 862- ptr_sequence_adapter< T, 863+ ptr_sequence_adapter< ptr_vector<T,CloneAllocator,Allocator>, 864+ T, 865 std::vector<void*,Allocator>, 866 CloneAllocator > 867 { 868- typedef ptr_sequence_adapter< T, 869+ typedef ptr_sequence_adapter< ptr_vector<T,CloneAllocator,Allocator>, 870+ T, 871 std::vector<void*,Allocator>, 872 CloneAllocator > 873 base_class;