| // |
| // Boost.Pointer Container |
| // |
| // Copyright Thorsten Ottosen 2003-2005. Use, modification and |
| // distribution is subject to the Boost Software License, Version |
| // 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // For more information, see http://www.boost.org/libs/ptr_container/ |
| // |
| |
| #ifndef BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP |
| #define BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1200) |
| # pragma once |
| #endif |
| |
| #include <boost/ptr_container/detail/map_iterator.hpp> |
| #include <boost/ptr_container/detail/associative_ptr_container.hpp> |
| #include <boost/ptr_container/detail/meta_functions.hpp> |
| #include <boost/static_assert.hpp> |
| #include <boost/range/iterator_range.hpp> |
| |
| namespace boost |
| { |
| namespace ptr_container_detail |
| { |
| |
| template |
| < |
| class T, |
| class VoidPtrMap, |
| bool Ordered |
| > |
| struct map_config |
| { |
| typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type |
| U; |
| typedef VoidPtrMap |
| void_container_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type |
| allocator_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| select_value_compare<VoidPtrMap>, |
| mpl::identity<void> >::type |
| value_compare; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| select_key_compare<VoidPtrMap>, |
| mpl::identity<void> >::type |
| key_compare; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| mpl::identity<void>, |
| select_hasher<VoidPtrMap> >::type |
| hasher; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| mpl::identity<void>, |
| select_key_equal<VoidPtrMap> >::type |
| key_equal; |
| |
| typedef BOOST_DEDUCED_TYPENAME |
| mpl::if_c<Ordered, |
| ptr_container_detail::ordered_associative_container_tag, |
| ptr_container_detail::unordered_associative_container_tag>::type |
| container_type; |
| |
| typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::key_type |
| key_type; |
| |
| typedef U value_type; |
| |
| typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::iterator, key_type, U* const > |
| iterator; |
| |
| typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::const_iterator, key_type, const U* const> |
| const_iterator; |
| |
| typedef ptr_map_iterator< |
| BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| select_iterator<VoidPtrMap>, |
| select_local_iterator<VoidPtrMap> >::type, |
| key_type, U* const > |
| local_iterator; |
| |
| typedef ptr_map_iterator< |
| BOOST_DEDUCED_TYPENAME |
| mpl::eval_if_c<Ordered, |
| select_iterator<VoidPtrMap>, |
| select_const_local_iterator<VoidPtrMap> >::type, |
| key_type, const U* const > |
| const_local_iterator; |
| |
| template< class Iter > |
| static U* get_pointer( Iter i ) |
| { |
| return i->second; |
| } |
| |
| template< class Iter > |
| static const U* get_const_pointer( Iter i ) |
| { |
| return i->second; |
| } |
| |
| BOOST_STATIC_CONSTANT( bool, allow_null = boost::is_nullable<T>::value ); |
| }; |
| |
| |
| |
| template |
| < |
| class T, |
| class VoidPtrMap, |
| class CloneAllocator, |
| bool Ordered |
| > |
| class ptr_map_adapter_base : |
| public ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>, |
| CloneAllocator > |
| { |
| typedef ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>, |
| CloneAllocator > |
| base_type; |
| |
| typedef map_config<T,VoidPtrMap,Ordered> config; |
| typedef ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered> this_type; |
| |
| public: |
| |
| typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type |
| allocator_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::iterator |
| iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator |
| const_iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::size_type |
| size_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::key_type |
| key_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::auto_type |
| auto_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::value_type |
| mapped_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::reference |
| mapped_reference; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_reference |
| const_mapped_reference; |
| typedef BOOST_DEDUCED_TYPENAME iterator_value<iterator>::type |
| value_type; |
| typedef value_type |
| reference; |
| typedef BOOST_DEDUCED_TYPENAME iterator_value<const_iterator>::type |
| const_reference; |
| typedef value_type |
| pointer; |
| typedef const_reference |
| const_pointer; |
| |
| private: |
| const_mapped_reference lookup( const key_type& key ) const |
| { |
| const_iterator i = this->find( key ); |
| if( i != this->end() ) |
| return *i->second; |
| else |
| BOOST_PTR_CONTAINER_THROW_EXCEPTION( true, bad_ptr_container_operation, |
| "'ptr_map/multimap::at()' could" |
| " not find key" ); |
| } |
| |
| struct eraser // scope guard |
| { |
| bool released_; |
| VoidPtrMap* m_; |
| const key_type& key_; |
| |
| eraser( VoidPtrMap* m, const key_type& key ) |
| : released_(false), m_(m), key_(key) |
| {} |
| |
| ~eraser() |
| { |
| if( !released_ ) |
| m_->erase(key_); |
| } |
| |
| void release() { released_ = true; } |
| |
| private: |
| eraser& operator=(const eraser&); |
| }; |
| |
| mapped_reference insert_lookup( const key_type& key ) |
| { |
| void*& ref = this->base()[key]; |
| if( ref ) |
| { |
| return *static_cast<mapped_type>(ref); |
| } |
| else |
| { |
| eraser e(&this->base(),key); // nothrow |
| mapped_type res = new T(); // strong |
| ref = res; // nothrow |
| e.release(); // nothrow |
| return *res; |
| } |
| } |
| |
| public: |
| |
| ptr_map_adapter_base() |
| { } |
| |
| template< class SizeType > |
| explicit ptr_map_adapter_base( SizeType n, |
| ptr_container_detail::unordered_associative_container_tag tag ) |
| : base_type( n, tag ) |
| { } |
| |
| template< class Compare, class Allocator > |
| ptr_map_adapter_base( const Compare& comp, |
| const Allocator& a ) |
| : base_type( comp, a ) |
| { } |
| |
| template< class Hash, class Pred, class Allocator > |
| ptr_map_adapter_base( const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( hash, pred, a ) |
| { } |
| |
| template< class InputIterator > |
| ptr_map_adapter_base( InputIterator first, InputIterator last ) |
| : base_type( first, last ) |
| { } |
| |
| template< class InputIterator, class Comp > |
| ptr_map_adapter_base( InputIterator first, InputIterator last, |
| const Comp& comp, |
| const allocator_type& a = allocator_type() ) |
| : base_type( first, last, comp, a ) |
| { } |
| |
| template< class InputIterator, class Hash, class Pred, class Allocator > |
| ptr_map_adapter_base( InputIterator first, InputIterator last, |
| const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( first, last, hash, pred, a ) |
| { } |
| |
| template< class PtrContainer > |
| explicit ptr_map_adapter_base( std::auto_ptr<PtrContainer> clone ) |
| : base_type( clone ) |
| { } |
| |
| template< typename PtrContainer > |
| ptr_map_adapter_base& operator=( std::auto_ptr<PtrContainer> clone ) |
| { |
| base_type::operator=( clone ); |
| return *this; |
| } |
| |
| iterator find( const key_type& x ) |
| { |
| return iterator( this->base().find( x ) ); |
| } |
| |
| const_iterator find( const key_type& x ) const |
| { |
| return const_iterator( this->base().find( x ) ); |
| } |
| |
| size_type count( const key_type& x ) const |
| { |
| return this->base().count( x ); |
| } |
| |
| iterator lower_bound( const key_type& x ) |
| { |
| return iterator( this->base().lower_bound( x ) ); |
| } |
| |
| const_iterator lower_bound( const key_type& x ) const |
| { |
| return const_iterator( this->base().lower_bound( x ) ); |
| } |
| |
| iterator upper_bound( const key_type& x ) |
| { |
| return iterator( this->base().upper_bound( x ) ); |
| } |
| |
| const_iterator upper_bound( const key_type& x ) const |
| { |
| return const_iterator( this->base().upper_bound( x ) ); |
| } |
| |
| iterator_range<iterator> equal_range( const key_type& x ) |
| { |
| std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator, |
| BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> |
| p = this->base().equal_range( x ); |
| return make_iterator_range( iterator( p.first ), iterator( p.second ) ); |
| } |
| |
| iterator_range<const_iterator> equal_range( const key_type& x ) const |
| { |
| std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator, |
| BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> |
| p = this->base().equal_range( x ); |
| return make_iterator_range( const_iterator( p.first ), |
| const_iterator( p.second ) ); |
| } |
| |
| mapped_reference at( const key_type& key ) |
| { |
| return const_cast<mapped_reference>( lookup( key ) ); |
| } |
| |
| const_mapped_reference at( const key_type& key ) const |
| { |
| return lookup( key ); |
| } |
| |
| mapped_reference operator[]( const key_type& key ) |
| { |
| return insert_lookup( key ); |
| } |
| |
| auto_type replace( iterator where, mapped_type x ) // strong |
| { |
| BOOST_ASSERT( where != this->end() ); |
| |
| this->enforce_null_policy( x, "Null pointer in 'replace()'" ); |
| |
| auto_type ptr( x ); |
| |
| BOOST_PTR_CONTAINER_THROW_EXCEPTION( this->empty(), |
| bad_ptr_container_operation, |
| "'replace()' on empty container" ); |
| |
| auto_type old( where->second ); // nothrow |
| where.base()->second = ptr.release(); // nothrow, commit |
| return boost::ptr_container::move( old ); |
| } |
| |
| template< class U > |
| auto_type replace( iterator where, std::auto_ptr<U> x ) |
| { |
| return replace( where, x.release() ); |
| } |
| |
| protected: |
| size_type bucket( const key_type& key ) const |
| { |
| return this->base().bucket( key ); |
| } |
| }; |
| |
| } // ptr_container_detail |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // ptr_map_adapter |
| ///////////////////////////////////////////////////////////////////////// |
| |
| template |
| < |
| class T, |
| class VoidPtrMap, |
| class CloneAllocator = heap_clone_allocator, |
| bool Ordered = true |
| > |
| class ptr_map_adapter : |
| public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered> |
| { |
| typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered> |
| base_type; |
| |
| public: |
| typedef BOOST_DEDUCED_TYPENAME base_type::iterator |
| iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator |
| const_iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::size_type |
| size_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::key_type |
| key_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_reference |
| const_reference; |
| typedef BOOST_DEDUCED_TYPENAME base_type::auto_type |
| auto_type; |
| typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type |
| allocator_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type |
| mapped_type; |
| private: |
| |
| void safe_insert( const key_type& key, auto_type ptr ) // strong |
| { |
| std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> |
| res = |
| this->base().insert( std::make_pair( key, ptr.get() ) ); // strong, commit |
| if( res.second ) // nothrow |
| ptr.release(); // nothrow |
| } |
| |
| template< class II > |
| void map_basic_clone_and_insert( II first, II last ) |
| { |
| while( first != last ) |
| { |
| if( this->find( first->first ) == this->end() ) |
| { |
| const_reference p = *first.base(); // nothrow |
| auto_type ptr( this->null_policy_allocate_clone( p.second ) ); |
| // strong |
| this->safe_insert( p.first, |
| boost::ptr_container::move( ptr ) ); |
| // strong, commit |
| } |
| ++first; |
| } |
| } |
| |
| public: |
| ptr_map_adapter( ) |
| { } |
| |
| template< class Comp > |
| explicit ptr_map_adapter( const Comp& comp, |
| const allocator_type& a ) |
| : base_type( comp, a ) { } |
| |
| template< class Hash, class Pred, class Allocator > |
| ptr_map_adapter( const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( hash, pred, a ) |
| { } |
| |
| template< class InputIterator > |
| ptr_map_adapter( InputIterator first, InputIterator last ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class InputIterator, class Comp > |
| ptr_map_adapter( InputIterator first, InputIterator last, |
| const Comp& comp, |
| const allocator_type& a = allocator_type() ) |
| : base_type( comp, a ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class InputIterator, class Hash, class Pred, class Allocator > |
| ptr_map_adapter( InputIterator first, InputIterator last, |
| const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( hash, pred, a ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| ptr_map_adapter( const ptr_map_adapter& r ) |
| { |
| map_basic_clone_and_insert( r.begin(), r.end() ); |
| } |
| |
| template< class Key, class U, class CA, bool b > |
| ptr_map_adapter( const ptr_map_adapter<Key,U,CA,b>& r ) |
| { |
| map_basic_clone_and_insert( r.begin(), r.end() ); |
| } |
| |
| template< class U > |
| ptr_map_adapter( std::auto_ptr<U> r ) : base_type( r ) |
| { } |
| |
| ptr_map_adapter& operator=( ptr_map_adapter r ) |
| { |
| this->swap( r ); |
| return *this; |
| } |
| |
| template< class U > |
| ptr_map_adapter& operator=( std::auto_ptr<U> r ) |
| { |
| base_type::operator=( r ); |
| return *this; |
| } |
| |
| using base_type::release; |
| |
| template< typename InputIterator > |
| void insert( InputIterator first, InputIterator last ) // basic |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class Range > |
| void insert( const Range& r ) |
| { |
| insert( boost::begin(r), boost::end(r) ); |
| } |
| |
| private: |
| std::pair<iterator,bool> insert_impl( const key_type& key, mapped_type x ) // strong |
| { |
| this->enforce_null_policy( x, "Null pointer in ptr_map_adapter::insert()" ); |
| auto_type ptr( x ); // nothrow |
| |
| std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> |
| res = this->base().insert( std::make_pair( key, x ) ); // strong, commit |
| if( res.second ) // nothrow |
| ptr.release(); // nothrow |
| return std::make_pair( iterator( res.first ), res.second ); // nothrow |
| } |
| |
| iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong |
| { |
| this->enforce_null_policy( x, |
| "Null pointer in 'ptr_map_adapter::insert()'" ); |
| auto_type ptr( x ); // nothrow |
| BOOST_DEDUCED_TYPENAME base_type::ptr_iterator |
| res = this->base().insert( before.base(), std::make_pair( key, x ) ); |
| // strong, commit |
| ptr.release(); // notrow |
| return iterator( res ); |
| } |
| |
| public: |
| |
| std::pair<iterator,bool> insert( key_type& key, mapped_type x ) |
| { |
| return insert_impl( key, x ); |
| } |
| |
| template< class U > |
| std::pair<iterator,bool> insert( const key_type& key, std::auto_ptr<U> x ) |
| { |
| return insert_impl( key, x.release() ); |
| } |
| |
| template< class F, class S > |
| iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong |
| { |
| this->enforce_null_policy( p.second, |
| "Null pointer in 'ptr_map_adapter::insert()'" ); |
| |
| auto_type ptr( this->null_policy_allocate_clone( p.second ) ); |
| BOOST_DEDUCED_TYPENAME base_type::ptr_iterator |
| result = this->base().insert( before.base(), |
| std::make_pair(p.first,ptr.get()) ); // strong |
| if( ptr.get() == result->second ) |
| ptr.release(); |
| |
| return iterator( result ); |
| } |
| |
| iterator insert( iterator before, key_type& key, mapped_type x ) // strong |
| { |
| return insert_impl( before, key, x ); |
| } |
| |
| template< class U > |
| iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong |
| { |
| return insert_impl( before, key, x.release() ); |
| } |
| |
| template< class PtrMapAdapter > |
| bool transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, |
| PtrMapAdapter& from ) // strong |
| { |
| return this->single_transfer( object, from ); |
| } |
| |
| template< class PtrMapAdapter > |
| size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, |
| BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, |
| PtrMapAdapter& from ) // basic |
| { |
| return this->single_transfer( first, last, from ); |
| } |
| |
| #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) |
| #else |
| |
| template< class PtrMapAdapter, class Range > |
| BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, |
| BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >, |
| size_type >::type |
| transfer( const Range& r, PtrMapAdapter& from ) // basic |
| { |
| return transfer( boost::begin(r), boost::end(r), from ); |
| } |
| |
| #endif |
| |
| template< class PtrMapAdapter > |
| size_type transfer( PtrMapAdapter& from ) // basic |
| { |
| return transfer( from.begin(), from.end(), from ); |
| } |
| }; |
| |
| ///////////////////////////////////////////////////////////////////////// |
| // ptr_multimap_adapter |
| ///////////////////////////////////////////////////////////////////////// |
| |
| template |
| < |
| class T, |
| class VoidPtrMultiMap, |
| class CloneAllocator = heap_clone_allocator, |
| bool Ordered = true |
| > |
| class ptr_multimap_adapter : |
| public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered> |
| { |
| typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered> |
| base_type; |
| |
| public: // typedefs |
| typedef BOOST_DEDUCED_TYPENAME base_type::iterator |
| iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator |
| const_iterator; |
| typedef BOOST_DEDUCED_TYPENAME base_type::size_type |
| size_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::key_type |
| key_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::const_reference |
| const_reference; |
| typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type |
| mapped_type; |
| typedef BOOST_DEDUCED_TYPENAME base_type::auto_type |
| auto_type; |
| typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiMap::allocator_type |
| allocator_type; |
| private: |
| |
| void safe_insert( const key_type& key, auto_type ptr ) // strong |
| { |
| this->base().insert( |
| std::make_pair( key, ptr.get() ) ); // strong, commit |
| ptr.release(); // nothrow |
| } |
| |
| template< typename II > |
| void map_basic_clone_and_insert( II first, II last ) |
| { |
| while( first != last ) |
| { |
| const_reference pair = *first.base(); // nothrow |
| auto_type ptr( this->null_policy_allocate_clone( pair.second ) ); |
| // strong |
| safe_insert( pair.first, |
| boost::ptr_container::move( ptr ) ); |
| // strong, commit |
| ++first; |
| } |
| } |
| |
| public: |
| |
| ptr_multimap_adapter() |
| { } |
| |
| template< class SizeType > |
| ptr_multimap_adapter( SizeType n, |
| ptr_container_detail::unordered_associative_container_tag tag ) |
| : base_type( n, tag ) |
| { } |
| |
| template< class Comp > |
| explicit ptr_multimap_adapter( const Comp& comp, |
| const allocator_type& a ) |
| : base_type( comp, a ) { } |
| |
| template< class Hash, class Pred, class Allocator > |
| ptr_multimap_adapter( const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( hash, pred, a ) |
| { } |
| |
| template< class InputIterator > |
| ptr_multimap_adapter( InputIterator first, InputIterator last ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class InputIterator, class Comp > |
| ptr_multimap_adapter( InputIterator first, InputIterator last, |
| const Comp& comp, |
| const allocator_type& a ) |
| : base_type( comp, a ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class InputIterator, class Hash, class Pred, class Allocator > |
| ptr_multimap_adapter( InputIterator first, InputIterator last, |
| const Hash& hash, |
| const Pred& pred, |
| const Allocator& a ) |
| : base_type( hash, pred, a ) |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| ptr_multimap_adapter( const ptr_multimap_adapter& r ) |
| { |
| map_basic_clone_and_insert( r.begin(), r.end() ); |
| } |
| |
| template< class Key, class U, class CA, bool b > |
| ptr_multimap_adapter( const ptr_multimap_adapter<Key,U,CA,b>& r ) |
| { |
| map_basic_clone_and_insert( r.begin(), r.end() ); |
| } |
| |
| template< class U > |
| explicit ptr_multimap_adapter( std::auto_ptr<U> r ) : base_type( r ) |
| { } |
| |
| ptr_multimap_adapter& operator=( ptr_multimap_adapter r ) |
| { |
| this->swap( r ); |
| return *this; |
| } |
| |
| template< class U > |
| ptr_multimap_adapter& operator=( std::auto_ptr<U> r ) |
| { |
| base_type::operator=( r ); |
| return *this; |
| } |
| |
| using base_type::release; |
| |
| private: |
| iterator insert_impl( const key_type& key, mapped_type x ) // strong |
| { |
| this->enforce_null_policy( x, |
| "Null pointer in 'ptr_multimap_adapter::insert()'" ); |
| auto_type ptr( x ); // nothrow |
| BOOST_DEDUCED_TYPENAME base_type::ptr_iterator |
| res = this->base().insert( std::make_pair( key, x ) ); |
| // strong, commit |
| ptr.release(); // notrow |
| return iterator( res ); |
| } |
| |
| iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong |
| { |
| this->enforce_null_policy( x, |
| "Null pointer in 'ptr_multimap_adapter::insert()'" ); |
| auto_type ptr( x ); // nothrow |
| BOOST_DEDUCED_TYPENAME base_type::ptr_iterator |
| res = this->base().insert( before.base(), |
| std::make_pair( key, x ) ); |
| // strong, commit |
| ptr.release(); // notrow |
| return iterator( res ); |
| } |
| |
| public: |
| template< typename InputIterator > |
| void insert( InputIterator first, InputIterator last ) // basic |
| { |
| map_basic_clone_and_insert( first, last ); |
| } |
| |
| template< class Range > |
| void insert( const Range& r ) |
| { |
| insert( boost::begin(r), boost::end(r) ); |
| } |
| |
| iterator insert( key_type& key, mapped_type x ) // strong |
| { |
| return insert_impl( key, x ); |
| } |
| |
| template< class U > |
| iterator insert( const key_type& key, std::auto_ptr<U> x ) |
| { |
| return insert_impl( key, x.release() ); |
| } |
| |
| template< class F, class S > |
| iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong |
| { |
| this->enforce_null_policy( p.second, |
| "Null pointer in 'ptr_multimap_adapter::insert()'" ); |
| iterator res = insert_impl( before, p.first, |
| this->null_policy_allocate_clone( p.second ) ); |
| return res; |
| } |
| |
| iterator insert( iterator before, key_type& key, mapped_type x ) // strong |
| { |
| return insert_impl( before, key, x ); |
| } |
| |
| template< class U > |
| iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong |
| { |
| return insert_impl( before, key, x.release() ); |
| } |
| |
| template< class PtrMapAdapter > |
| void transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, |
| PtrMapAdapter& from ) // strong |
| { |
| this->multi_transfer( object, from ); |
| } |
| |
| template< class PtrMapAdapter > |
| size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, |
| BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, |
| PtrMapAdapter& from ) // basic |
| { |
| return this->multi_transfer( first, last, from ); |
| } |
| |
| #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) |
| #else |
| |
| template< class PtrMapAdapter, class Range > |
| BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, |
| BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >, |
| size_type >::type |
| transfer( const Range& r, PtrMapAdapter& from ) // basic |
| { |
| return transfer( boost::begin(r), boost::end(r), from ); |
| } |
| |
| #endif |
| template< class PtrMapAdapter > |
| void transfer( PtrMapAdapter& from ) // basic |
| { |
| transfer( from.begin(), from.end(), from ); |
| BOOST_ASSERT( from.empty() ); |
| } |
| |
| }; |
| |
| template< class I, class F, class S > |
| inline bool is_null( const ptr_map_iterator<I,F,S>& i ) |
| { |
| return i->second == 0; |
| } |
| |
| } // namespace 'boost' |
| |
| #endif |