epoc32/include/stdapis/boost/ptr_container/ptr_set_adapter.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
williamr@2
     1
//
williamr@2
     2
// Boost.Pointer Container
williamr@2
     3
//
williamr@2
     4
//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
williamr@2
     5
//  distribution is subject to the Boost Software License, Version
williamr@2
     6
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
williamr@2
     7
//  http://www.boost.org/LICENSE_1_0.txt)
williamr@2
     8
//
williamr@2
     9
// For more information, see http://www.boost.org/libs/ptr_container/
williamr@2
    10
//
williamr@2
    11
williamr@2
    12
#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
williamr@2
    13
#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
williamr@2
    14
williamr@2
    15
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
williamr@2
    16
# pragma once
williamr@2
    17
#endif
williamr@2
    18
williamr@2
    19
#include <boost/ptr_container/detail/associative_ptr_container.hpp>
williamr@2
    20
#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
williamr@2
    21
#include <boost/range/iterator_range.hpp>
williamr@2
    22
williamr@2
    23
namespace boost
williamr@2
    24
{
williamr@2
    25
namespace ptr_container_detail
williamr@2
    26
{
williamr@2
    27
    template
williamr@2
    28
    < 
williamr@2
    29
        class Key,
williamr@2
    30
        class VoidPtrSet
williamr@2
    31
    >
williamr@2
    32
    struct set_config
williamr@2
    33
    {
williamr@2
    34
       typedef VoidPtrSet 
williamr@2
    35
                    void_container_type;
williamr@2
    36
williamr@2
    37
       typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type 
williamr@2
    38
                    allocator_type;
williamr@2
    39
williamr@2
    40
       typedef Key  value_type;
williamr@2
    41
williamr@2
    42
       typedef value_type 
williamr@2
    43
                    key_type;
williamr@2
    44
williamr@2
    45
       typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::value_compare
williamr@2
    46
                    value_compare;
williamr@2
    47
williamr@2
    48
       typedef value_compare 
williamr@2
    49
                    key_compare;
williamr@2
    50
williamr@2
    51
       typedef void_ptr_iterator<
williamr@2
    52
                       BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > 
williamr@2
    53
                    iterator;
williamr@2
    54
williamr@2
    55
       typedef void_ptr_iterator<
williamr@2
    56
                        BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
williamr@2
    57
                    const_iterator;
williamr@2
    58
williamr@2
    59
       template< class Iter >
williamr@2
    60
       static Key* get_pointer( Iter i )
williamr@2
    61
       {
williamr@2
    62
           return static_cast<Key*>( *i.base() );
williamr@2
    63
       }
williamr@2
    64
williamr@2
    65
       template< class Iter >
williamr@2
    66
       static const Key* get_const_pointer( Iter i )
williamr@2
    67
       {
williamr@2
    68
           return static_cast<const Key*>( *i.base() );
williamr@2
    69
       }
williamr@2
    70
williamr@2
    71
       BOOST_STATIC_CONSTANT(bool, allow_null = false );
williamr@2
    72
    };
williamr@2
    73
williamr@2
    74
 
williamr@2
    75
    
williamr@2
    76
    template
williamr@2
    77
    < 
williamr@2
    78
        class Key,
williamr@2
    79
        class VoidPtrSet, 
williamr@2
    80
        class CloneAllocator = heap_clone_allocator
williamr@2
    81
    >
williamr@2
    82
    class ptr_set_adapter_base 
williamr@2
    83
        : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet>,
williamr@2
    84
                                                      CloneAllocator >
williamr@2
    85
    {
williamr@2
    86
        typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet>,
williamr@2
    87
                                                     CloneAllocator >
williamr@2
    88
              base_type;
williamr@2
    89
    public:  
williamr@2
    90
        typedef BOOST_DEDUCED_TYPENAME base_type::iterator 
williamr@2
    91
                      iterator;
williamr@2
    92
        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator 
williamr@2
    93
                      const_iterator;
williamr@2
    94
        typedef Key   key_type;
williamr@2
    95
        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
williamr@2
    96
                      size_type;
williamr@2
    97
williamr@2
    98
    private:
williamr@2
    99
        ptr_set_adapter_base() 
williamr@2
   100
          : base_type( BOOST_DEDUCED_TYPENAME VoidPtrSet::key_compare(),
williamr@2
   101
                       BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type() )
williamr@2
   102
        { }
williamr@2
   103
williamr@2
   104
    public:
williamr@2
   105
        
williamr@2
   106
       template< class Compare, class Allocator >
williamr@2
   107
       ptr_set_adapter_base( const Compare& comp,
williamr@2
   108
                             const Allocator& a ) 
williamr@2
   109
         : base_type( comp, a ) 
williamr@2
   110
       { }
williamr@2
   111
williamr@2
   112
       template< class InputIterator, class Compare, class Allocator >
williamr@2
   113
       ptr_set_adapter_base( InputIterator first, InputIterator last,
williamr@2
   114
                             const Compare& comp,
williamr@2
   115
                             const Allocator& a ) 
williamr@2
   116
         : base_type( first, last, comp, a ) 
williamr@2
   117
       { }
williamr@2
   118
williamr@2
   119
        template< class PtrContainer >
williamr@2
   120
        ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
williamr@2
   121
         : base_type( clone )
williamr@2
   122
        { }
williamr@2
   123
        
williamr@2
   124
        template< typename PtrContainer >
williamr@2
   125
        void operator=( std::auto_ptr<PtrContainer> clone )    
williamr@2
   126
        {
williamr@2
   127
            base_type::operator=( clone );
williamr@2
   128
        }
williamr@2
   129
                 
williamr@2
   130
        iterator find( const key_type& x )                                                
williamr@2
   131
        {                                                                            
williamr@2
   132
            return iterator( this->c_private().
williamr@2
   133
                             find( const_cast<key_type*>(&x) ) );            
williamr@2
   134
        }                                                                            
williamr@2
   135
williamr@2
   136
        const_iterator find( const key_type& x ) const                                    
williamr@2
   137
        {                                                                            
williamr@2
   138
            return const_iterator( this->c_private().
williamr@2
   139
                                   find( const_cast<key_type*>(&x) ) );                  
williamr@2
   140
        }                                                                            
williamr@2
   141
williamr@2
   142
        size_type count( const key_type& x ) const                                        
williamr@2
   143
        {                                                                            
williamr@2
   144
            return this->c_private().count( const_cast<key_type*>(&x) );                      
williamr@2
   145
        }                                                                            
williamr@2
   146
                                                                                     
williamr@2
   147
        iterator lower_bound( const key_type& x )                                         
williamr@2
   148
        {                                                                            
williamr@2
   149
            return iterator( this->c_private().
williamr@2
   150
                             lower_bound( const_cast<key_type*>(&x) ) );                   
williamr@2
   151
        }                                                                            
williamr@2
   152
                                                                                     
williamr@2
   153
        const_iterator lower_bound( const key_type& x ) const                             
williamr@2
   154
        {                                                                            
williamr@2
   155
            return const_iterator( this->c_private().
williamr@2
   156
                                   lower_bound( const_cast<key_type*>(&x) ) );       
williamr@2
   157
        }                                                                            
williamr@2
   158
                                                                                     
williamr@2
   159
        iterator upper_bound( const key_type& x )                                         
williamr@2
   160
        {                                                                            
williamr@2
   161
            return iterator( this->c_private().
williamr@2
   162
                             upper_bound( const_cast<key_type*>(&x) ) );           
williamr@2
   163
        }                                                                            
williamr@2
   164
                                                                                     
williamr@2
   165
        const_iterator upper_bound( const key_type& x ) const                             
williamr@2
   166
        {                                                                            
williamr@2
   167
            return const_iterator( this->c_private().
williamr@2
   168
                                   upper_bound( const_cast<key_type*>(&x) ) );             
williamr@2
   169
        }                                                                            
williamr@2
   170
                                                                                     
williamr@2
   171
        iterator_range<iterator> equal_range( const key_type& x )                    
williamr@2
   172
        {                                                                            
williamr@2
   173
            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
williamr@2
   174
                      BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> 
williamr@2
   175
                p = this->c_private().
williamr@2
   176
                equal_range( const_cast<key_type*>(&x) );   
williamr@2
   177
            return make_iterator_range( iterator( p.first ), 
williamr@2
   178
                                        iterator( p.second ) );      
williamr@2
   179
        }                                                                            
williamr@2
   180
                                                                                     
williamr@2
   181
        iterator_range<const_iterator> equal_range( const key_type& x ) const  
williamr@2
   182
        {                                                                            
williamr@2
   183
            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
williamr@2
   184
                      BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 
williamr@2
   185
                p = this->c_private().
williamr@2
   186
                equal_range( const_cast<key_type*>(&x) ); 
williamr@2
   187
            return make_iterator_range( const_iterator( p.first ), 
williamr@2
   188
                                        const_iterator( p.second ) );    
williamr@2
   189
        }                                                                            
williamr@2
   190
williamr@2
   191
    };
williamr@2
   192
williamr@2
   193
} // ptr_container_detail
williamr@2
   194
williamr@2
   195
    /////////////////////////////////////////////////////////////////////////
williamr@2
   196
    // ptr_set_adapter
williamr@2
   197
    /////////////////////////////////////////////////////////////////////////
williamr@2
   198
  
williamr@2
   199
    template
williamr@2
   200
    <
williamr@2
   201
        class Key,
williamr@2
   202
        class VoidPtrSet, 
williamr@2
   203
        class CloneAllocator = heap_clone_allocator
williamr@2
   204
    >
williamr@2
   205
    class ptr_set_adapter : 
williamr@2
   206
        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator>
williamr@2
   207
    {
williamr@2
   208
        typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator> 
williamr@2
   209
            base_type;
williamr@2
   210
    
williamr@2
   211
    public: // typedefs
williamr@2
   212
       
williamr@2
   213
        typedef BOOST_DEDUCED_TYPENAME base_type::iterator
williamr@2
   214
                     iterator;                 
williamr@2
   215
        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
williamr@2
   216
                     const_iterator;                 
williamr@2
   217
        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
williamr@2
   218
                     size_type;    
williamr@2
   219
        typedef Key  key_type;
williamr@2
   220
        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
williamr@2
   221
                     auto_type;
williamr@2
   222
        typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::key_compare
williamr@2
   223
                      key_compare;
williamr@2
   224
        typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
williamr@2
   225
                      allocator_type;        
williamr@2
   226
    private:
williamr@2
   227
        
williamr@2
   228
        template< typename II >                                               
williamr@2
   229
        void set_basic_clone_and_insert( II first, II last ) // basic                 
williamr@2
   230
        {                                                                     
williamr@2
   231
            while( first != last )                                            
williamr@2
   232
            {           
williamr@2
   233
                if( this->find( *first ) == this->end() )
williamr@2
   234
                    insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit
williamr@2
   235
                ++first;                                                      
williamr@2
   236
            }                                                                 
williamr@2
   237
        }                         
williamr@2
   238
williamr@2
   239
    public:
williamr@2
   240
        
williamr@2
   241
        explicit ptr_set_adapter( const key_compare& comp = key_compare(),
williamr@2
   242
                                  const allocator_type& a = allocator_type() ) 
williamr@2
   243
          : base_type( comp, a ) 
williamr@2
   244
        {
williamr@2
   245
            BOOST_ASSERT( this->empty() ); 
williamr@2
   246
        }
williamr@2
   247
        
williamr@2
   248
        template< class InputIterator, class Compare, class Allocator >
williamr@2
   249
        ptr_set_adapter( InputIterator first, InputIterator last, 
williamr@2
   250
                         const Compare& comp = Compare(),
williamr@2
   251
                         const Allocator a = Allocator() )
williamr@2
   252
          : base_type( comp, a )
williamr@2
   253
        {
williamr@2
   254
            BOOST_ASSERT( this->empty() );
williamr@2
   255
            set_basic_clone_and_insert( first, last );
williamr@2
   256
        }
williamr@2
   257
williamr@2
   258
        template< class T >
williamr@2
   259
        ptr_set_adapter( std::auto_ptr<T> r ) : base_type( r )
williamr@2
   260
        { }
williamr@2
   261
williamr@2
   262
        template< class T >
williamr@2
   263
        void operator=( std::auto_ptr<T> r ) 
williamr@2
   264
        {
williamr@2
   265
            base_type::operator=( r );
williamr@2
   266
        }
williamr@2
   267
williamr@2
   268
        std::pair<iterator,bool> insert( key_type* x ) // strong                      
williamr@2
   269
        {       
williamr@2
   270
            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
williamr@2
   271
            
williamr@2
   272
            auto_type ptr( x );                                
williamr@2
   273
            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
williamr@2
   274
                 res = this->c_private().insert( x );       
williamr@2
   275
            if( res.second )                                                 
williamr@2
   276
                ptr.release();                                                  
williamr@2
   277
            return std::make_pair( iterator( res.first ), res.second );     
williamr@2
   278
        }
williamr@2
   279
williamr@2
   280
        template< class U >
williamr@2
   281
        std::pair<iterator,bool> insert( std::auto_ptr<U> x )
williamr@2
   282
        {
williamr@2
   283
            return insert( x.release() );
williamr@2
   284
        }
williamr@2
   285
williamr@2
   286
        
williamr@2
   287
        iterator insert( iterator where, key_type* x ) // strong
williamr@2
   288
        {
williamr@2
   289
            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
williamr@2
   290
williamr@2
   291
            auto_type ptr( x );                                
williamr@2
   292
            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator 
williamr@2
   293
                res = this->c_private().insert( where.base(), x );
williamr@2
   294
            if( *res == x )                                                 
williamr@2
   295
                ptr.release();                                                  
williamr@2
   296
            return iterator( res);
williamr@2
   297
        }
williamr@2
   298
williamr@2
   299
        template< class U >
williamr@2
   300
        iterator insert( iterator where, std::auto_ptr<U> x )
williamr@2
   301
        {
williamr@2
   302
            return insert( where, x.release() );
williamr@2
   303
        }
williamr@2
   304
        
williamr@2
   305
        template< typename InputIterator >
williamr@2
   306
        void insert( InputIterator first, InputIterator last ) // basic
williamr@2
   307
        {
williamr@2
   308
            set_basic_clone_and_insert( first, last );
williamr@2
   309
        }
williamr@2
   310
williamr@2
   311
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
williamr@2
   312
#else    
williamr@2
   313
        
williamr@2
   314
        template< class Range >
williamr@2
   315
        BOOST_DEDUCED_TYPENAME
williamr@2
   316
        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
williamr@2
   317
        insert( const Range& r )
williamr@2
   318
        {
williamr@2
   319
            insert( boost::begin(r), boost::end(r) );
williamr@2
   320
        }
williamr@2
   321
williamr@2
   322
#endif        
williamr@2
   323
williamr@2
   324
        template< class PtrSetAdapter >
williamr@2
   325
        bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
williamr@2
   326
                       PtrSetAdapter& from ) // strong
williamr@2
   327
        {
williamr@2
   328
            return this->single_transfer( object, from );
williamr@2
   329
        }
williamr@2
   330
williamr@2
   331
        template< class PtrSetAdapter >
williamr@2
   332
        size_type 
williamr@2
   333
        transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
williamr@2
   334
                  BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
williamr@2
   335
                  PtrSetAdapter& from ) // basic
williamr@2
   336
        {
williamr@2
   337
            return this->single_transfer( first, last, from );
williamr@2
   338
        }
williamr@2
   339
williamr@2
   340
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
williamr@2
   341
#else    
williamr@2
   342
williamr@2
   343
        template< class PtrSetAdapter, class Range >
williamr@2
   344
        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
williamr@2
   345
                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >,
williamr@2
   346
                                                            size_type >::type
williamr@2
   347
        transfer( const Range& r, PtrSetAdapter& from ) // basic
williamr@2
   348
        {
williamr@2
   349
            return transfer( boost::begin(r), boost::end(r), from );
williamr@2
   350
        }
williamr@2
   351
williamr@2
   352
#endif
williamr@2
   353
williamr@2
   354
        template< class PtrSetAdapter >
williamr@2
   355
        size_type transfer( PtrSetAdapter& from ) // basic
williamr@2
   356
        {
williamr@2
   357
            return transfer( from.begin(), from.end(), from );
williamr@2
   358
        }
williamr@2
   359
williamr@2
   360
    };
williamr@2
   361
    
williamr@2
   362
    /////////////////////////////////////////////////////////////////////////
williamr@2
   363
    // ptr_multiset_adapter
williamr@2
   364
    /////////////////////////////////////////////////////////////////////////
williamr@2
   365
williamr@2
   366
    template
williamr@2
   367
    < 
williamr@2
   368
        class Key,
williamr@2
   369
        class VoidPtrMultiSet, 
williamr@2
   370
        class CloneAllocator = heap_clone_allocator 
williamr@2
   371
    >
williamr@2
   372
    class ptr_multiset_adapter : 
williamr@2
   373
        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator>
williamr@2
   374
    {
williamr@2
   375
         typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator> base_type;
williamr@2
   376
    
williamr@2
   377
    public: // typedefs
williamr@2
   378
    
williamr@2
   379
        typedef BOOST_DEDUCED_TYPENAME base_type::iterator   
williamr@2
   380
                       iterator;          
williamr@2
   381
        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
williamr@2
   382
                       size_type;
williamr@2
   383
        typedef Key    key_type;
williamr@2
   384
        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
williamr@2
   385
                       auto_type;
williamr@2
   386
        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::key_compare
williamr@2
   387
                       key_compare;
williamr@2
   388
        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type
williamr@2
   389
                       allocator_type;        
williamr@2
   390
    private:
williamr@2
   391
        template< typename II >                                               
williamr@2
   392
        void set_basic_clone_and_insert( II first, II last ) // basic                 
williamr@2
   393
        {               
williamr@2
   394
            while( first != last )                                            
williamr@2
   395
            {           
williamr@2
   396
                insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit                              
williamr@2
   397
                ++first;                                                     
williamr@2
   398
            }                                                                 
williamr@2
   399
        }                         
williamr@2
   400
    
williamr@2
   401
    public:
williamr@2
   402
williamr@2
   403
        explicit ptr_multiset_adapter( const key_compare& comp = key_compare(),
williamr@2
   404
                                       const allocator_type& a = allocator_type() )
williamr@2
   405
        : base_type( comp, a ) 
williamr@2
   406
        { }
williamr@2
   407
    
williamr@2
   408
        template< class InputIterator >
williamr@2
   409
        ptr_multiset_adapter( InputIterator first, InputIterator last,
williamr@2
   410
                              const key_compare& comp = key_compare(),
williamr@2
   411
                              const allocator_type& a = allocator_type() )
williamr@2
   412
        : base_type( comp, a ) 
williamr@2
   413
        {
williamr@2
   414
            set_basic_clone_and_insert( first, last );
williamr@2
   415
        }
williamr@2
   416
williamr@2
   417
        template< class T >
williamr@2
   418
        ptr_multiset_adapter( std::auto_ptr<T> r ) : base_type( r )
williamr@2
   419
        { }
williamr@2
   420
williamr@2
   421
        template< class T >
williamr@2
   422
        void operator=( std::auto_ptr<T> r ) 
williamr@2
   423
        {
williamr@2
   424
            base_type::operator=( r ); 
williamr@2
   425
        }
williamr@2
   426
williamr@2
   427
        iterator insert( iterator before, key_type* x ) // strong  
williamr@2
   428
        {
williamr@2
   429
            return base_type::insert( before, x ); 
williamr@2
   430
        } 
williamr@2
   431
williamr@2
   432
        template< class U >
williamr@2
   433
        iterator insert( iterator before, std::auto_ptr<U> x )
williamr@2
   434
        {
williamr@2
   435
            return insert( before, x.release() );
williamr@2
   436
        }
williamr@2
   437
    
williamr@2
   438
        iterator insert( key_type* x ) // strong                                      
williamr@2
   439
        {   
williamr@2
   440
            this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
williamr@2
   441
    
williamr@2
   442
            auto_type ptr( x );                                
williamr@2
   443
            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
williamr@2
   444
                 res = this->c_private().insert( x );                         
williamr@2
   445
            ptr.release();                                                      
williamr@2
   446
            return iterator( res );                                             
williamr@2
   447
        }
williamr@2
   448
williamr@2
   449
        template< class U >
williamr@2
   450
        iterator insert( std::auto_ptr<U> x )
williamr@2
   451
        {
williamr@2
   452
            return insert( x.release() );
williamr@2
   453
        }
williamr@2
   454
    
williamr@2
   455
        template< typename InputIterator >
williamr@2
   456
        void insert( InputIterator first, InputIterator last ) // basic
williamr@2
   457
        {
williamr@2
   458
            set_basic_clone_and_insert( first, last );
williamr@2
   459
        }
williamr@2
   460
williamr@2
   461
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
williamr@2
   462
#else    
williamr@2
   463
        
williamr@2
   464
        template< class Range >
williamr@2
   465
        BOOST_DEDUCED_TYPENAME
williamr@2
   466
        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
williamr@2
   467
        insert( const Range& r )
williamr@2
   468
        {
williamr@2
   469
            insert( boost::begin(r), boost::end(r) );
williamr@2
   470
        }
williamr@2
   471
williamr@2
   472
#endif
williamr@2
   473
williamr@2
   474
        template< class PtrSetAdapter >
williamr@2
   475
        void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
williamr@2
   476
                       PtrSetAdapter& from ) // strong
williamr@2
   477
        {
williamr@2
   478
            this->multi_transfer( object, from );
williamr@2
   479
        }
williamr@2
   480
williamr@2
   481
        template< class PtrSetAdapter >
williamr@2
   482
        size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
williamr@2
   483
                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
williamr@2
   484
                            PtrSetAdapter& from ) // basic
williamr@2
   485
        {
williamr@2
   486
            return this->multi_transfer( first, last, from );
williamr@2
   487
        }
williamr@2
   488
williamr@2
   489
#if defined(BOOST_NO_SFINAE) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
williamr@2
   490
#else    
williamr@2
   491
        
williamr@2
   492
        template< class PtrSetAdapter, class Range >
williamr@2
   493
        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
williamr@2
   494
                       BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type
williamr@2
   495
        transfer(  const Range& r, PtrSetAdapter& from ) // basic
williamr@2
   496
        {
williamr@2
   497
            return transfer( boost::begin(r), boost::end(r), from );
williamr@2
   498
        }
williamr@2
   499
williamr@2
   500
#endif        
williamr@2
   501
williamr@2
   502
        template< class PtrSetAdapter >
williamr@2
   503
        void transfer( PtrSetAdapter& from ) // basic
williamr@2
   504
        {
williamr@2
   505
            transfer( from.begin(), from.end(), from );
williamr@2
   506
            BOOST_ASSERT( from.empty() );
williamr@2
   507
        }
williamr@2
   508
        
williamr@2
   509
    };
williamr@2
   510
williamr@2
   511
} // namespace 'boost'  
williamr@2
   512
williamr@2
   513
#endif