1 // 2 // Boost.Pointer Container 3 // 4 // Copyright Thorsten Ottosen 2003-2005. Use, modification and 5 // distribution is subject to the Boost Software License, Version 6 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 // http://www.boost.org/LICENSE_1_0.txt) 8 // 9 // For more information, see http://www.boost.org/libs/ptr_container/ 10 // 11 12 #ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP 13 #define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP 14 15 #if defined(_MSC_VER) && (_MSC_VER >= 1200) 16 # pragma once 17 #endif 18 19 #include <boost/ptr_container/detail/associative_ptr_container.hpp> 20 #include <boost/ptr_container/detail/meta_functions.hpp> 21 #include <boost/ptr_container/detail/void_ptr_iterator.hpp> 22 #include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp> 23 #include <boost/range/iterator_range.hpp> 24 25 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED) 26 #pragma GCC diagnostic push 27 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 28 #endif 29 30 namespace boost 31 { 32 namespace ptr_container_detail 33 { 34 template 35 < 36 class Key, 37 class VoidPtrSet, 38 bool Ordered 39 > 40 struct set_config 41 { 42 typedef VoidPtrSet 43 void_container_type; 44 45 typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type 46 allocator_type; 47 48 typedef Key value_type; 49 50 typedef value_type 51 key_type; 52 53 typedef BOOST_DEDUCED_TYPENAME 54 mpl::eval_if_c<Ordered, 55 select_value_compare<VoidPtrSet>, 56 mpl::identity<void> >::type 57 value_compare; 58 59 typedef value_compare 60 key_compare; 61 62 typedef BOOST_DEDUCED_TYPENAME 63 mpl::eval_if_c<Ordered, 64 mpl::identity<void>, 65 select_hasher<VoidPtrSet> >::type 66 hasher; 67 68 typedef BOOST_DEDUCED_TYPENAME 69 mpl::eval_if_c<Ordered, 70 mpl::identity<void>, 71 select_key_equal<VoidPtrSet> >::type 72 key_equal; 73 74 typedef BOOST_DEDUCED_TYPENAME 75 mpl::if_c<Ordered, 76 ordered_associative_container_tag, 77 unordered_associative_container_tag>::type 78 container_type; 79 80 typedef void_ptr_iterator< 81 BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > 82 iterator; 83 84 typedef void_ptr_iterator< 85 BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key > 86 const_iterator; 87 88 typedef void_ptr_iterator< 89 BOOST_DEDUCED_TYPENAME 90 mpl::eval_if_c<Ordered, 91 select_iterator<VoidPtrSet>, 92 select_local_iterator<VoidPtrSet> >::type, 93 Key > 94 local_iterator; 95 96 typedef void_ptr_iterator< 97 BOOST_DEDUCED_TYPENAME 98 mpl::eval_if_c<Ordered, 99 select_iterator<VoidPtrSet>, 100 select_const_local_iterator<VoidPtrSet> >::type, 101 const Key > 102 const_local_iterator; 103 104 template< class Iter > get_pointerboost::ptr_container_detail::set_config105 static Key* get_pointer( Iter i ) 106 { 107 return static_cast<Key*>( *i.base() ); 108 } 109 110 template< class Iter > get_const_pointerboost::ptr_container_detail::set_config111 static const Key* get_const_pointer( Iter i ) 112 { 113 return static_cast<const Key*>( *i.base() ); 114 } 115 116 BOOST_STATIC_CONSTANT(bool, allow_null = false ); 117 }; 118 119 120 121 template 122 < 123 class Key, 124 class VoidPtrSet, 125 class CloneAllocator = heap_clone_allocator, 126 bool Ordered = true 127 > 128 class ptr_set_adapter_base 129 : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>, 130 CloneAllocator > 131 { 132 typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>, 133 CloneAllocator > 134 base_type; 135 public: 136 typedef BOOST_DEDUCED_TYPENAME base_type::iterator 137 iterator; 138 typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator 139 const_iterator; 140 typedef Key key_type; 141 typedef BOOST_DEDUCED_TYPENAME base_type::size_type 142 size_type; 143 144 public: ptr_set_adapter_base()145 ptr_set_adapter_base() 146 { } 147 148 template< class SizeType > ptr_set_adapter_base(SizeType n,ptr_container_detail::unordered_associative_container_tag tag)149 ptr_set_adapter_base( SizeType n, 150 ptr_container_detail::unordered_associative_container_tag tag ) 151 : base_type( n, tag ) 152 { } 153 154 template< class Compare, class Allocator > ptr_set_adapter_base(const Compare & comp,const Allocator & a)155 ptr_set_adapter_base( const Compare& comp, 156 const Allocator& a ) 157 : base_type( comp, a ) 158 { } 159 160 template< class Hash, class Pred, class Allocator > ptr_set_adapter_base(const Hash & hash,const Pred & pred,const Allocator & a)161 ptr_set_adapter_base( const Hash& hash, 162 const Pred& pred, 163 const Allocator& a ) 164 : base_type( hash, pred, a ) 165 { } 166 167 template< class InputIterator, class Compare, class Allocator > ptr_set_adapter_base(InputIterator first,InputIterator last,const Compare & comp,const Allocator & a)168 ptr_set_adapter_base( InputIterator first, InputIterator last, 169 const Compare& comp, 170 const Allocator& a ) 171 : base_type( first, last, comp, a ) 172 { } 173 174 template< class InputIterator, class Hash, class Pred, class Allocator > ptr_set_adapter_base(InputIterator first,InputIterator last,const Hash & hash,const Pred & pred,const Allocator & a)175 ptr_set_adapter_base( InputIterator first, InputIterator last, 176 const Hash& hash, 177 const Pred& pred, 178 const Allocator& a ) 179 : base_type( first, last, hash, pred, a ) 180 { } 181 182 template< class U, class Set, class CA, bool b > ptr_set_adapter_base(const ptr_set_adapter_base<U,Set,CA,b> & r)183 ptr_set_adapter_base( const ptr_set_adapter_base<U,Set,CA,b>& r ) 184 : base_type( r ) 185 { } 186 ptr_set_adapter_base(const ptr_set_adapter_base & r)187 ptr_set_adapter_base( const ptr_set_adapter_base& r ) 188 : base_type( r ) 189 { } 190 191 #ifndef BOOST_NO_AUTO_PTR 192 template< class PtrContainer > ptr_set_adapter_base(std::auto_ptr<PtrContainer> clone)193 explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone ) 194 : base_type( clone ) 195 { } 196 #endif 197 #ifndef BOOST_NO_CXX11_SMART_PTR 198 template< class PtrContainer > ptr_set_adapter_base(std::unique_ptr<PtrContainer> clone)199 explicit ptr_set_adapter_base( std::unique_ptr<PtrContainer> clone ) 200 : base_type( std::move( clone ) ) 201 { } 202 #endif 203 operator =(ptr_set_adapter_base r)204 ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) 205 { 206 this->swap( r ); 207 return *this; 208 } 209 210 #ifndef BOOST_NO_AUTO_PTR 211 template< typename PtrContainer > operator =(std::auto_ptr<PtrContainer> clone)212 ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone ) 213 { 214 base_type::operator=( clone ); 215 return *this; 216 } 217 #endif 218 #ifndef BOOST_NO_CXX11_SMART_PTR 219 template< typename PtrContainer > operator =(std::unique_ptr<PtrContainer> clone)220 ptr_set_adapter_base& operator=( std::unique_ptr<PtrContainer> clone ) 221 { 222 base_type::operator=( std::move( clone ) ); 223 return *this; 224 } 225 #endif 226 227 using base_type::erase; 228 erase(const key_type & x)229 size_type erase( const key_type& x ) // nothrow 230 { 231 key_type* key = const_cast<key_type*>(&x); 232 iterator i( this->base().find( key ) ); 233 if( i == this->end() ) // nothrow 234 return 0u; // nothrow 235 key = static_cast<key_type*>(*i.base()); // nothrow 236 size_type res = this->base().erase( key ); // nothrow 237 this->remove( key ); // nothrow 238 return res; 239 } 240 241 find(const key_type & x)242 iterator find( const key_type& x ) 243 { 244 return iterator( this->base(). 245 find( const_cast<key_type*>(&x) ) ); 246 } 247 find(const key_type & x) const248 const_iterator find( const key_type& x ) const 249 { 250 return const_iterator( this->base(). 251 find( const_cast<key_type*>(&x) ) ); 252 } 253 count(const key_type & x) const254 size_type count( const key_type& x ) const 255 { 256 return this->base().count( const_cast<key_type*>(&x) ); 257 } 258 lower_bound(const key_type & x)259 iterator lower_bound( const key_type& x ) 260 { 261 return iterator( this->base(). 262 lower_bound( const_cast<key_type*>(&x) ) ); 263 } 264 lower_bound(const key_type & x) const265 const_iterator lower_bound( const key_type& x ) const 266 { 267 return const_iterator( this->base(). 268 lower_bound( const_cast<key_type*>(&x) ) ); 269 } 270 upper_bound(const key_type & x)271 iterator upper_bound( const key_type& x ) 272 { 273 return iterator( this->base(). 274 upper_bound( const_cast<key_type*>(&x) ) ); 275 } 276 upper_bound(const key_type & x) const277 const_iterator upper_bound( const key_type& x ) const 278 { 279 return const_iterator( this->base(). 280 upper_bound( const_cast<key_type*>(&x) ) ); 281 } 282 equal_range(const key_type & x)283 iterator_range<iterator> equal_range( const key_type& x ) 284 { 285 std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator, 286 BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> 287 p = this->base(). 288 equal_range( const_cast<key_type*>(&x) ); 289 return make_iterator_range( iterator( p.first ), 290 iterator( p.second ) ); 291 } 292 equal_range(const key_type & x) const293 iterator_range<const_iterator> equal_range( const key_type& x ) const 294 { 295 std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator, 296 BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 297 p = this->base(). 298 equal_range( const_cast<key_type*>(&x) ); 299 return make_iterator_range( const_iterator( p.first ), 300 const_iterator( p.second ) ); 301 } 302 303 protected: bucket(const key_type & key) const304 size_type bucket( const key_type& key ) const 305 { 306 return this->base().bucket( const_cast<key_type*>(&key) ); 307 } 308 }; 309 310 } // ptr_container_detail 311 312 ///////////////////////////////////////////////////////////////////////// 313 // ptr_set_adapter 314 ///////////////////////////////////////////////////////////////////////// 315 316 template 317 < 318 class Key, 319 class VoidPtrSet, 320 class CloneAllocator = heap_clone_allocator, 321 bool Ordered = true 322 > 323 class ptr_set_adapter : 324 public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered> 325 { 326 typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered> 327 base_type; 328 329 public: // typedefs 330 331 typedef BOOST_DEDUCED_TYPENAME base_type::iterator 332 iterator; 333 typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator 334 const_iterator; 335 typedef BOOST_DEDUCED_TYPENAME base_type::size_type 336 size_type; 337 typedef Key key_type; 338 typedef BOOST_DEDUCED_TYPENAME base_type::auto_type 339 auto_type; 340 typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type 341 allocator_type; 342 private: 343 344 template< typename II > set_basic_clone_and_insert(II first,II last)345 void set_basic_clone_and_insert( II first, II last ) // basic 346 { 347 while( first != last ) 348 { 349 if( this->find( *first ) == this->end() ) 350 insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit 351 ++first; 352 } 353 } 354 355 public: ptr_set_adapter()356 ptr_set_adapter() 357 { } 358 359 template< class SizeType > ptr_set_adapter(SizeType n,ptr_container_detail::unordered_associative_container_tag tag)360 ptr_set_adapter( SizeType n, 361 ptr_container_detail::unordered_associative_container_tag tag ) 362 : base_type( n, tag ) 363 { } 364 365 template< class Comp > ptr_set_adapter(const Comp & comp,const allocator_type & a)366 explicit ptr_set_adapter( const Comp& comp, 367 const allocator_type& a ) 368 : base_type( comp, a ) 369 { 370 BOOST_ASSERT( this->empty() ); 371 } 372 373 template< class SizeType, class Hash, class Pred, class Allocator > ptr_set_adapter(SizeType n,const Hash & hash,const Pred & pred,const Allocator & a)374 ptr_set_adapter( SizeType n, 375 const Hash& hash, 376 const Pred& pred, 377 const Allocator& a ) 378 : base_type( n, hash, pred, a ) 379 { } 380 381 template< class Hash, class Pred, class Allocator > ptr_set_adapter(const Hash & hash,const Pred & pred,const Allocator & a)382 ptr_set_adapter( const Hash& hash, 383 const Pred& pred, 384 const Allocator& a ) 385 : base_type( hash, pred, a ) 386 { } 387 388 template< class InputIterator > ptr_set_adapter(InputIterator first,InputIterator last)389 ptr_set_adapter( InputIterator first, InputIterator last ) 390 : base_type( first, last ) 391 { } 392 393 template< class InputIterator, class Compare, class Allocator > ptr_set_adapter(InputIterator first,InputIterator last,const Compare & comp,const Allocator a=Allocator ())394 ptr_set_adapter( InputIterator first, InputIterator last, 395 const Compare& comp, 396 const Allocator a = Allocator() ) 397 : base_type( comp, a ) 398 { 399 BOOST_ASSERT( this->empty() ); 400 set_basic_clone_and_insert( first, last ); 401 } 402 403 template< class InputIterator, class Hash, class Pred, class Allocator > ptr_set_adapter(InputIterator first,InputIterator last,const Hash & hash,const Pred & pred,const Allocator & a)404 ptr_set_adapter( InputIterator first, InputIterator last, 405 const Hash& hash, 406 const Pred& pred, 407 const Allocator& a ) 408 : base_type( first, last, hash, pred, a ) 409 { } 410 ptr_set_adapter(const ptr_set_adapter & r)411 explicit ptr_set_adapter( const ptr_set_adapter& r ) 412 : base_type( r ) 413 { } 414 415 template< class U, class Set, class CA, bool b > ptr_set_adapter(const ptr_set_adapter<U,Set,CA,b> & r)416 explicit ptr_set_adapter( const ptr_set_adapter<U,Set,CA,b>& r ) 417 : base_type( r ) 418 { } 419 420 #ifndef BOOST_NO_AUTO_PTR 421 template< class PtrContainer > ptr_set_adapter(std::auto_ptr<PtrContainer> clone)422 explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone ) 423 : base_type( clone ) 424 { } 425 #endif 426 #ifndef BOOST_NO_CXX11_SMART_PTR 427 template< class PtrContainer > ptr_set_adapter(std::unique_ptr<PtrContainer> clone)428 explicit ptr_set_adapter( std::unique_ptr<PtrContainer> clone ) 429 : base_type( std::move( clone ) ) 430 { } 431 #endif 432 433 template< class U, class Set, class CA, bool b > operator =(const ptr_set_adapter<U,Set,CA,b> & r)434 ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r ) 435 { 436 base_type::operator=( r ); 437 return *this; 438 } 439 440 #ifndef BOOST_NO_AUTO_PTR 441 template< class T > operator =(std::auto_ptr<T> r)442 void operator=( std::auto_ptr<T> r ) 443 { 444 base_type::operator=( r ); 445 } 446 #endif 447 #ifndef BOOST_NO_CXX11_SMART_PTR 448 template< class T > operator =(std::unique_ptr<T> r)449 void operator=( std::unique_ptr<T> r ) 450 { 451 base_type::operator=( std::move( r ) ); 452 } 453 #endif 454 insert(key_type * x)455 std::pair<iterator,bool> insert( key_type* x ) // strong 456 { 457 this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); 458 459 auto_type ptr( x, *this ); 460 std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> 461 res = this->base().insert( x ); 462 if( res.second ) 463 ptr.release(); 464 return std::make_pair( iterator( res.first ), res.second ); 465 } 466 467 #ifndef BOOST_NO_AUTO_PTR 468 template< class U > insert(std::auto_ptr<U> x)469 std::pair<iterator,bool> insert( std::auto_ptr<U> x ) 470 { 471 return insert( x.release() ); 472 } 473 #endif 474 #ifndef BOOST_NO_CXX11_SMART_PTR 475 template< class U > insert(std::unique_ptr<U> x)476 std::pair<iterator,bool> insert( std::unique_ptr<U> x ) 477 { 478 return insert( x.release() ); 479 } 480 #endif 481 482 insert(iterator where,key_type * x)483 iterator insert( iterator where, key_type* x ) // strong 484 { 485 this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" ); 486 487 auto_type ptr( x, *this ); 488 BOOST_DEDUCED_TYPENAME base_type::ptr_iterator 489 res = this->base().insert( where.base(), x ); 490 if( *res == x ) 491 ptr.release(); 492 return iterator( res); 493 } 494 495 #ifndef BOOST_NO_AUTO_PTR 496 template< class U > insert(iterator where,std::auto_ptr<U> x)497 iterator insert( iterator where, std::auto_ptr<U> x ) 498 { 499 return insert( where, x.release() ); 500 } 501 #endif 502 #ifndef BOOST_NO_CXX11_SMART_PTR 503 template< class U > insert(iterator where,std::unique_ptr<U> x)504 iterator insert( iterator where, std::unique_ptr<U> x ) 505 { 506 return insert( where, x.release() ); 507 } 508 #endif 509 510 template< typename InputIterator > insert(InputIterator first,InputIterator last)511 void insert( InputIterator first, InputIterator last ) // basic 512 { 513 set_basic_clone_and_insert( first, last ); 514 } 515 516 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 517 #else 518 519 template< class Range > 520 BOOST_DEDUCED_TYPENAME 521 boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type insert(const Range & r)522 insert( const Range& r ) 523 { 524 insert( boost::begin(r), boost::end(r) ); 525 } 526 527 #endif 528 529 template< class PtrSetAdapter > transfer(BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,PtrSetAdapter & from)530 bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 531 PtrSetAdapter& from ) // strong 532 { 533 return this->single_transfer( object, from ); 534 } 535 536 template< class PtrSetAdapter > 537 size_type transfer(BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,PtrSetAdapter & from)538 transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 539 BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 540 PtrSetAdapter& from ) // basic 541 { 542 return this->single_transfer( first, last, from ); 543 } 544 545 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 546 #else 547 548 template< class PtrSetAdapter, class Range > 549 BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, 550 BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, 551 size_type >::type transfer(const Range & r,PtrSetAdapter & from)552 transfer( const Range& r, PtrSetAdapter& from ) // basic 553 { 554 return transfer( boost::begin(r), boost::end(r), from ); 555 } 556 557 #endif 558 559 template< class PtrSetAdapter > transfer(PtrSetAdapter & from)560 size_type transfer( PtrSetAdapter& from ) // basic 561 { 562 return transfer( from.begin(), from.end(), from ); 563 } 564 565 }; 566 567 ///////////////////////////////////////////////////////////////////////// 568 // ptr_multiset_adapter 569 ///////////////////////////////////////////////////////////////////////// 570 571 template 572 < 573 class Key, 574 class VoidPtrMultiSet, 575 class CloneAllocator = heap_clone_allocator, 576 bool Ordered = true 577 > 578 class ptr_multiset_adapter : 579 public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> 580 { 581 typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type; 582 583 public: // typedefs 584 585 typedef BOOST_DEDUCED_TYPENAME base_type::iterator 586 iterator; 587 typedef BOOST_DEDUCED_TYPENAME base_type::size_type 588 size_type; 589 typedef Key key_type; 590 typedef BOOST_DEDUCED_TYPENAME base_type::auto_type 591 auto_type; 592 typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type 593 allocator_type; 594 private: 595 template< typename II > set_basic_clone_and_insert(II first,II last)596 void set_basic_clone_and_insert( II first, II last ) // basic 597 { 598 while( first != last ) 599 { 600 insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit 601 ++first; 602 } 603 } 604 605 public: ptr_multiset_adapter()606 ptr_multiset_adapter() 607 { } 608 609 template< class SizeType > ptr_multiset_adapter(SizeType n,ptr_container_detail::unordered_associative_container_tag tag)610 ptr_multiset_adapter( SizeType n, 611 ptr_container_detail::unordered_associative_container_tag tag ) 612 : base_type( n, tag ) 613 { } 614 615 template< class Comp > ptr_multiset_adapter(const Comp & comp,const allocator_type & a)616 explicit ptr_multiset_adapter( const Comp& comp, 617 const allocator_type& a ) 618 : base_type( comp, a ) 619 { } 620 621 template< class Hash, class Pred, class Allocator > ptr_multiset_adapter(const Hash & hash,const Pred & pred,const Allocator & a)622 ptr_multiset_adapter( const Hash& hash, 623 const Pred& pred, 624 const Allocator& a ) 625 : base_type( hash, pred, a ) 626 { } 627 628 template< class InputIterator > ptr_multiset_adapter(InputIterator first,InputIterator last)629 ptr_multiset_adapter( InputIterator first, InputIterator last ) 630 : base_type( first, last ) 631 { } 632 633 template< class InputIterator, class Comp > ptr_multiset_adapter(InputIterator first,InputIterator last,const Comp & comp,const allocator_type & a=allocator_type ())634 ptr_multiset_adapter( InputIterator first, InputIterator last, 635 const Comp& comp, 636 const allocator_type& a = allocator_type() ) 637 : base_type( comp, a ) 638 { 639 set_basic_clone_and_insert( first, last ); 640 } 641 642 template< class InputIterator, class Hash, class Pred, class Allocator > ptr_multiset_adapter(InputIterator first,InputIterator last,const Hash & hash,const Pred & pred,const Allocator & a)643 ptr_multiset_adapter( InputIterator first, InputIterator last, 644 const Hash& hash, 645 const Pred& pred, 646 const Allocator& a ) 647 : base_type( first, last, hash, pred, a ) 648 { } 649 650 template< class U, class Set, class CA, bool b > ptr_multiset_adapter(const ptr_multiset_adapter<U,Set,CA,b> & r)651 explicit ptr_multiset_adapter( const ptr_multiset_adapter<U,Set,CA,b>& r ) 652 : base_type( r ) 653 { } 654 655 #ifndef BOOST_NO_AUTO_PTR 656 template< class PtrContainer > ptr_multiset_adapter(std::auto_ptr<PtrContainer> clone)657 explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone ) 658 : base_type( clone ) 659 { } 660 #endif 661 #ifndef BOOST_NO_CXX11_SMART_PTR 662 template< class PtrContainer > ptr_multiset_adapter(std::unique_ptr<PtrContainer> clone)663 explicit ptr_multiset_adapter( std::unique_ptr<PtrContainer> clone ) 664 : base_type( std::move( clone ) ) 665 { } 666 #endif 667 668 template< class U, class Set, class CA, bool b > operator =(const ptr_multiset_adapter<U,Set,CA,b> & r)669 ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r ) 670 { 671 base_type::operator=( r ); 672 return *this; 673 } 674 675 #ifndef BOOST_NO_AUTO_PTR 676 template< class T > operator =(std::auto_ptr<T> r)677 void operator=( std::auto_ptr<T> r ) 678 { 679 base_type::operator=( r ); 680 } 681 #endif 682 #ifndef BOOST_NO_CXX11_SMART_PTR 683 template< class T > operator =(std::unique_ptr<T> r)684 void operator=( std::unique_ptr<T> r ) 685 { 686 base_type::operator=( std::move( r ) ); 687 } 688 #endif 689 insert(iterator before,key_type * x)690 iterator insert( iterator before, key_type* x ) // strong 691 { 692 return base_type::insert( before, x ); 693 } 694 695 #ifndef BOOST_NO_AUTO_PTR 696 template< class U > insert(iterator before,std::auto_ptr<U> x)697 iterator insert( iterator before, std::auto_ptr<U> x ) 698 { 699 return insert( before, x.release() ); 700 } 701 #endif 702 #ifndef BOOST_NO_CXX11_SMART_PTR 703 template< class U > insert(iterator before,std::unique_ptr<U> x)704 iterator insert( iterator before, std::unique_ptr<U> x ) 705 { 706 return insert( before, x.release() ); 707 } 708 #endif 709 insert(key_type * x)710 iterator insert( key_type* x ) // strong 711 { 712 this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" ); 713 714 auto_type ptr( x, *this ); 715 BOOST_DEDUCED_TYPENAME base_type::ptr_iterator 716 res = this->base().insert( x ); 717 ptr.release(); 718 return iterator( res ); 719 } 720 721 #ifndef BOOST_NO_AUTO_PTR 722 template< class U > insert(std::auto_ptr<U> x)723 iterator insert( std::auto_ptr<U> x ) 724 { 725 return insert( x.release() ); 726 } 727 #endif 728 #ifndef BOOST_NO_CXX11_SMART_PTR 729 template< class U > insert(std::unique_ptr<U> x)730 iterator insert( std::unique_ptr<U> x ) 731 { 732 return insert( x.release() ); 733 } 734 #endif 735 736 template< typename InputIterator > insert(InputIterator first,InputIterator last)737 void insert( InputIterator first, InputIterator last ) // basic 738 { 739 set_basic_clone_and_insert( first, last ); 740 } 741 742 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 743 #else 744 745 template< class Range > 746 BOOST_DEDUCED_TYPENAME 747 boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type insert(const Range & r)748 insert( const Range& r ) 749 { 750 insert( boost::begin(r), boost::end(r) ); 751 } 752 753 #endif 754 755 template< class PtrSetAdapter > transfer(BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,PtrSetAdapter & from)756 void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 757 PtrSetAdapter& from ) // strong 758 { 759 this->multi_transfer( object, from ); 760 } 761 762 template< class PtrSetAdapter > transfer(BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,PtrSetAdapter & from)763 size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 764 BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 765 PtrSetAdapter& from ) // basic 766 { 767 return this->multi_transfer( first, last, from ); 768 } 769 770 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) 771 #else 772 773 template< class PtrSetAdapter, class Range > 774 BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, 775 BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type transfer(const Range & r,PtrSetAdapter & from)776 transfer( const Range& r, PtrSetAdapter& from ) // basic 777 { 778 return transfer( boost::begin(r), boost::end(r), from ); 779 } 780 781 #endif 782 783 template< class PtrSetAdapter > transfer(PtrSetAdapter & from)784 void transfer( PtrSetAdapter& from ) // basic 785 { 786 transfer( from.begin(), from.end(), from ); 787 BOOST_ASSERT( from.empty() ); 788 } 789 790 }; 791 792 } // namespace 'boost' 793 794 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED) 795 #pragma GCC diagnostic pop 796 #endif 797 798 #endif 799