[ceph.git] / ceph / src / boost / boost / ptr_container / detail / associative_ptr_container.hpp

//
// 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_ASSOCIATIVE_PTR_CONTAINER_HPP
#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif

#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>

#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif

namespace boost
{

namespace ptr_container_detail
{
    template
    <
        class Config,
        class CloneAllocator
    >
    class associative_ptr_container :
        public reversible_ptr_container<Config,CloneAllocator>
    {
        typedef reversible_ptr_container<Config,CloneAllocator>
                                base_type;

        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
                                scoped_deleter;

        typedef BOOST_DEDUCED_TYPENAME Config::container_type
                                container_type;
    public: // typedefs
        typedef BOOST_DEDUCED_TYPENAME Config::key_type
                                key_type;
        typedef BOOST_DEDUCED_TYPENAME Config::key_compare
                                key_compare;
        typedef BOOST_DEDUCED_TYPENAME Config::value_compare
                                value_compare;
        typedef BOOST_DEDUCED_TYPENAME Config::hasher
                                hasher;
        typedef BOOST_DEDUCED_TYPENAME Config::key_equal
                                key_equal;
        typedef BOOST_DEDUCED_TYPENAME Config::iterator
                                iterator;
        typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
                                const_iterator;
        typedef BOOST_DEDUCED_TYPENAME Config::local_iterator
                                local_iterator;
        typedef BOOST_DEDUCED_TYPENAME Config::const_local_iterator
                                const_local_iterator;
        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
                                size_type;
        typedef BOOST_DEDUCED_TYPENAME base_type::reference
                                reference;
        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
                    const_reference;

    public: // foundation
        associative_ptr_container()
        { }

        template< class SizeType >
        associative_ptr_container( SizeType n, unordered_associative_container_tag tag )
          : base_type( n, tag )
        { }

        template< class Compare, class Allocator >
        associative_ptr_container( const Compare& comp,
                                   const Allocator& a )
         : base_type( comp, a, container_type() )
        { }
        
        template< class Hash, class Pred, class Allocator >
        associative_ptr_container( const Hash& hash,
                                   const Pred& pred,
                                   const Allocator& a )
         : base_type( hash, pred, a )
        { }

        template< class InputIterator, class Compare, class Allocator >
        associative_ptr_container( InputIterator first, InputIterator last,
                                   const Compare& comp,
                                   const Allocator& a )
         : base_type( first, last, comp, a, container_type() )
        { }
        
        template< class InputIterator, class Hash, class Pred, class Allocator >
        associative_ptr_container( InputIterator first, InputIterator last,
                                   const Hash& hash,
                                   const Pred& pred,
                                   const Allocator& a )
         : base_type( first, last, hash, pred, a )
        { }
        
#ifndef BOOST_NO_AUTO_PTR
        template< class PtrContainer >
        explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
         : base_type( r )
        { }
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
        template< class PtrContainer >
        explicit associative_ptr_container( std::unique_ptr<PtrContainer> r )
         : base_type( std::move( r ) )
        { }
#endif

        associative_ptr_container( const associative_ptr_container& r )
         : base_type( r.begin(), r.end(), container_type() )
        { }
        
        template< class C, class V >
        associative_ptr_container( const associative_ptr_container<C,V>& r )
         : base_type( r.begin(), r.end(), container_type() )
        { }
        
#ifndef BOOST_NO_AUTO_PTR
        template< class PtrContainer >
        associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
        {
           base_type::operator=( r );
           return *this;
        }
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
        template< class PtrContainer >
        associative_ptr_container& operator=( std::unique_ptr<PtrContainer> r ) // nothrow
        {
           base_type::operator=( std::move( r ) );
           return *this;
        }
#endif
        
        associative_ptr_container& operator=( associative_ptr_container r ) // strong
        {
           this->swap( r );
           return *this;   
        }

    public: // associative container interface
        key_compare key_comp() const
        {
            return this->base().key_comp();
        }

        value_compare value_comp() const
        {
            return this->base().value_comp();
        }

        iterator erase( iterator before ) // nothrow
        {
            BOOST_ASSERT( !this->empty() );
            BOOST_ASSERT( before != this->end() );

            this->remove( before );                      // nothrow
            iterator res( before );                      // nothrow
            ++res;                                       // nothrow
            this->base().erase( before.base() );         // nothrow
            return res;                                  // nothrow
        }

        size_type erase( const key_type& x ) // nothrow
        {
            iterator i( this->base().find( x ) );       
                                                        // nothrow
            if( i == this->end() )                      // nothrow
                return 0u;                              // nothrow
            this->remove( i );                          // nothrow
            return this->base().erase( x );             // nothrow 
        }

        iterator erase( iterator first,
                        iterator last ) // nothrow
        {
            iterator res( last );                                // nothrow
            if( res != this->end() )
                ++res;                                           // nothrow

            this->remove( first, last );                         // nothrow
            this->base().erase( first.base(), last.base() );     // nothrow
            return res;                                          // nothrow
        }

#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#else    
        template< class Range >
        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_convertible<Range&,key_type&>, 
                                                  iterator >::type
        erase( const Range& r )
        {
            return erase( boost::begin(r), boost::end(r) );
        }

#endif

    protected:

        template< class AssociatePtrCont >
        void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
                             AssociatePtrCont& from ) // strong
        {
            BOOST_ASSERT( (void*)&from != (void*)this );
            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );

            this->base().insert( *object.base() );     // strong
            from.base().erase( object.base() );        // nothrow
        }

        template< class AssociatePtrCont >
        size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
                                  BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
                                  AssociatePtrCont& from ) // basic
        {
            BOOST_ASSERT( (void*)&from != (void*)this );
 
            size_type res = 0;
            for( ; first != last; )
            {
                BOOST_ASSERT( first != from.end() );
                this->base().insert( *first.base() );     // strong
                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
                    to_delete( first );
                ++first;
                from.base().erase( to_delete.base() );    // nothrow
                ++res;
            }

            return res;
        }

        template< class AssociatePtrCont >
        bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
                              AssociatePtrCont& from ) // strong
        {
            BOOST_ASSERT( (void*)&from != (void*)this );
            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );

            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
                this->base().insert( *object.base() );     // strong
            if( p.second )
                from.base().erase( object.base() );        // nothrow

            return p.second;
        }

        template< class AssociatePtrCont >
        size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
                                   BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
                                   AssociatePtrCont& from ) // basic
        {
            BOOST_ASSERT( (void*)&from != (void*)this );

            size_type res = 0;
            for( ; first != last; )
            {
                BOOST_ASSERT( first != from.end() );
                std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
                    this->base().insert( *first.base() );     // strong
                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
                    to_delete( first );
                ++first;
                if( p.second )
                {
                    from.base().erase( to_delete.base() );   // nothrow
                    ++res;
                }
            }
            return res;
        }
        
        reference front()
        {
            BOOST_ASSERT( !this->empty() );
            BOOST_ASSERT( *this->begin().base() != 0 );
            return *this->begin(); 
        }

        const_reference front() const
        {
            return const_cast<associative_ptr_container*>(this)->front();
        }

        reference back()
        {
            BOOST_ASSERT( !this->empty() );
            BOOST_ASSERT( *(--this->end()).base() != 0 );
            return *--this->end(); 
        }

        const_reference back() const
        {
            return const_cast<associative_ptr_container*>(this)->back();
        }

    protected: // unordered interface
        hasher hash_function() const
        {
            return this->base().hash_function();
        }

        key_equal key_eq() const
        {
            return this->base().key_eq();
        }
        
        size_type bucket_count() const
        {
            return this->base().bucket_count();
        }
        
        size_type max_bucket_count() const
        {
            return this->base().max_bucket_count();
        }
        
        size_type bucket_size( size_type n ) const
        {
            return this->base().bucket_size( n );
        }
        
        float load_factor() const
        {
            return this->base().load_factor();
        }
        
        float max_load_factor() const
        {
            return this->base().max_load_factor();
        }
        
        void max_load_factor( float factor )
        {
            return this->base().max_load_factor( factor );
        }
        
        void rehash( size_type n )
        {
            this->base().rehash( n );
        }

    public:
#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(70190006))
        iterator begin()
        {
            return base_type::begin();
        }

        const_iterator begin() const
        {
            return base_type::begin();
        }

        iterator end()
        {
            return base_type::end();
        }

        const_iterator end() const
        {
            return base_type::end();
        }

        const_iterator cbegin() const
        {
            return base_type::cbegin();
        }

        const_iterator cend() const
        {
            return base_type::cend();
        }
#else
         using base_type::begin;
         using base_type::end;
         using base_type::cbegin;
         using base_type::cend;
#endif

    protected:
        local_iterator begin( size_type n )
        {
            return local_iterator( this->base().begin( n ) );
        }
        
        const_local_iterator begin( size_type n ) const
        {
            return const_local_iterator( this->base().begin( n ) );
        }
        
        local_iterator end( size_type n )
        {
            return local_iterator( this->base().end( n ) );
        }
        
        const_local_iterator end( size_type n ) const
        {
            return const_local_iterator( this->base().end( n ) );
        }
        
        const_local_iterator cbegin( size_type n ) const
        {
            return const_local_iterator( this->base().cbegin( n ) );
        }
        
        const_local_iterator cend( size_type n )
        {
            return const_local_iterator( this->base().cend( n ) );
        }

     }; // class 'associative_ptr_container'
    
} // namespace 'ptr_container_detail'
    
} // namespace 'boost'

#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
#pragma GCC diagnostic pop
#endif

#endif
Commit	Line	Data
7c673cae FG	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
	13	#ifndef BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
	14	#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
	15
	16	#if defined(_MSC_VER) && (_MSC_VER >= 1200)
	17	# pragma once
	18	#endif
	19
	20	#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
11fdf7f2 TL	21	#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
	22
	23	#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
	24	#pragma GCC diagnostic push
	25	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
	26	#endif
7c673cae FG	27
	28	namespace boost
	29	{
	30
	31	namespace ptr_container_detail
	32	{
	33	template
	34	<
	35	class Config,
	36	class CloneAllocator
	37	>
	38	class associative_ptr_container :
	39	public reversible_ptr_container<Config,CloneAllocator>
	40	{
	41	typedef reversible_ptr_container<Config,CloneAllocator>
	42	base_type;
	43
	44	typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
	45	scoped_deleter;
	46
	47	typedef BOOST_DEDUCED_TYPENAME Config::container_type
	48	container_type;
	49	public: // typedefs
	50	typedef BOOST_DEDUCED_TYPENAME Config::key_type
	51	key_type;
	52	typedef BOOST_DEDUCED_TYPENAME Config::key_compare
	53	key_compare;
	54	typedef BOOST_DEDUCED_TYPENAME Config::value_compare
	55	value_compare;
	56	typedef BOOST_DEDUCED_TYPENAME Config::hasher
	57	hasher;
	58	typedef BOOST_DEDUCED_TYPENAME Config::key_equal
	59	key_equal;
	60	typedef BOOST_DEDUCED_TYPENAME Config::iterator
	61	iterator;
	62	typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
	63	const_iterator;
	64	typedef BOOST_DEDUCED_TYPENAME Config::local_iterator
	65	local_iterator;
	66	typedef BOOST_DEDUCED_TYPENAME Config::const_local_iterator
	67	const_local_iterator;
	68	typedef BOOST_DEDUCED_TYPENAME base_type::size_type
	69	size_type;
	70	typedef BOOST_DEDUCED_TYPENAME base_type::reference
	71	reference;
	72	typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
	73	const_reference;
	74
	75	public: // foundation
	76	associative_ptr_container()
	77	{ }
	78
	79	template< class SizeType >
	80	associative_ptr_container( SizeType n, unordered_associative_container_tag tag )
	81	: base_type( n, tag )
	82	{ }
	83
	84	template< class Compare, class Allocator >
	85	associative_ptr_container( const Compare& comp,
	86	const Allocator& a )
	87	: base_type( comp, a, container_type() )
	88	{ }
	89
	90	template< class Hash, class Pred, class Allocator >
91	associative_ptr_container( const Hash& hash,
92	const Pred& pred,
93	const Allocator& a )
94	: base_type( hash, pred, a )
95	{ }
96
97	template< class InputIterator, class Compare, class Allocator >
98	associative_ptr_container( InputIterator first, InputIterator last,
99	const Compare& comp,
100	const Allocator& a )
101	: base_type( first, last, comp, a, container_type() )
102	{ }
103
104	template< class InputIterator, class Hash, class Pred, class Allocator >
105	associative_ptr_container( InputIterator first, InputIterator last,
106	const Hash& hash,
107	const Pred& pred,
108	const Allocator& a )
109	: base_type( first, last, hash, pred, a )
110	{ }
111
11fdf7f2	112	#ifndef BOOST_NO_AUTO_PTR
7c673cae FG	113	template< class PtrContainer >
	114	explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
	115	: base_type( r )
	116	{ }
11fdf7f2 TL	117	#endif
	118	#ifndef BOOST_NO_CXX11_SMART_PTR
	119	template< class PtrContainer >
	120	explicit associative_ptr_container( std::unique_ptr<PtrContainer> r )
	121	: base_type( std::move( r ) )
	122	{ }
	123	#endif
7c673cae FG	124
	125	associative_ptr_container( const associative_ptr_container& r )
	126	: base_type( r.begin(), r.end(), container_type() )
	127	{ }
	128
	129	template< class C, class V >
	130	associative_ptr_container( const associative_ptr_container<C,V>& r )
	131	: base_type( r.begin(), r.end(), container_type() )
	132	{ }
	133
11fdf7f2	134	#ifndef BOOST_NO_AUTO_PTR
7c673cae FG	135	template< class PtrContainer >
	136	associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
	137	{
	138	base_type::operator=( r );
	139	return *this;
	140	}
11fdf7f2 TL	141	#endif
	142	#ifndef BOOST_NO_CXX11_SMART_PTR
	143	template< class PtrContainer >
	144	associative_ptr_container& operator=( std::unique_ptr<PtrContainer> r ) // nothrow
	145	{
	146	base_type::operator=( std::move( r ) );
	147	return *this;
	148	}
	149	#endif
7c673cae FG	150
	151	associative_ptr_container& operator=( associative_ptr_container r ) // strong
	152	{
	153	this->swap( r );
	154	return *this;
	155	}
	156
	157	public: // associative container interface
	158	key_compare key_comp() const
	159	{
	160	return this->base().key_comp();
	161	}
	162
	163	value_compare value_comp() const
	164	{
	165	return this->base().value_comp();
	166	}
	167
	168	iterator erase( iterator before ) // nothrow
	169	{
	170	BOOST_ASSERT( !this->empty() );
	171	BOOST_ASSERT( before != this->end() );
	172
	173	this->remove( before ); // nothrow
	174	iterator res( before ); // nothrow
	175	++res; // nothrow
	176	this->base().erase( before.base() ); // nothrow
	177	return res; // nothrow
	178	}
	179
	180	size_type erase( const key_type& x ) // nothrow
	181	{
	182	iterator i( this->base().find( x ) );
	183	// nothrow
	184	if( i == this->end() ) // nothrow
	185	return 0u; // nothrow
	186	this->remove( i ); // nothrow
	187	return this->base().erase( x ); // nothrow
	188	}
	189
	190	iterator erase( iterator first,
	191	iterator last ) // nothrow
	192	{
	193	iterator res( last ); // nothrow
	194	if( res != this->end() )
	195	++res; // nothrow
	196
	197	this->remove( first, last ); // nothrow
	198	this->base().erase( first.base(), last.base() ); // nothrow
	199	return res; // nothrow
	200	}
	201
	202	#if defined(BOOST_NO_SFINAE) \|\| defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
	203	#else
	204	template< class Range >
	205	BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_convertible<Range&,key_type&>,
	206	iterator >::type
	207	erase( const Range& r )
	208	{
	209	return erase( boost::begin(r), boost::end(r) );
	210	}
	211
	212	#endif
	213
214	protected:
215
216	template< class AssociatePtrCont >
217	void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
218	AssociatePtrCont& from ) // strong
219	{
220	BOOST_ASSERT( (void)&from != (void)this );
221	BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
222
223	this->base().insert( *object.base() ); // strong
224	from.base().erase( object.base() ); // nothrow
225	}
226
227	template< class AssociatePtrCont >
228	size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
229	BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
230	AssociatePtrCont& from ) // basic
231	{
232	BOOST_ASSERT( (void)&from != (void)this );
233
234	size_type res = 0;
235	for( ; first != last; )
236	{
237	BOOST_ASSERT( first != from.end() );
238	this->base().insert( *first.base() ); // strong
239	BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator
240	to_delete( first );
241	++first;
242	from.base().erase( to_delete.base() ); // nothrow
243	++res;
244	}
245
246	return res;
247	}
248
249	template< class AssociatePtrCont >
250	bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
251	AssociatePtrCont& from ) // strong
252	{
253	BOOST_ASSERT( (void)&from != (void)this );
254	BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
255
256	std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
257	this->base().insert( *object.base() ); // strong
258	if( p.second )
259	from.base().erase( object.base() ); // nothrow
260
261	return p.second;
262	}
263
264	template< class AssociatePtrCont >
265	size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
266	BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
267	AssociatePtrCont& from ) // basic
268	{
269	BOOST_ASSERT( (void)&from != (void)this );
270
271	size_type res = 0;
272	for( ; first != last; )
273	{
274	BOOST_ASSERT( first != from.end() );
275	std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
276	this->base().insert( *first.base() ); // strong
277	BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator
278	to_delete( first );
279	++first;
280	if( p.second )
281	{
282	from.base().erase( to_delete.base() ); // nothrow
283	++res;
284	}
285	}
286	return res;
287	}
288
289	reference front()
290	{
291	BOOST_ASSERT( !this->empty() );
292	BOOST_ASSERT( *this->begin().base() != 0 );
293	return *this->begin();
294	}
295
296	const_reference front() const
297	{
298	return const_cast<associative_ptr_container*>(this)->front();
299	}
300
301	reference back()
302	{
303	BOOST_ASSERT( !this->empty() );
304	BOOST_ASSERT( *(--this->end()).base() != 0 );
305	return *--this->end();
306	}
307
308	const_reference back() const
309	{
310	return const_cast<associative_ptr_container*>(this)->back();
311	}
312
313	protected: // unordered interface
314	hasher hash_function() const
315	{
316	return this->base().hash_function();
317	}
318
319	key_equal key_eq() const
320	{
321	return this->base().key_eq();
322	}
323
324	size_type bucket_count() const
325	{
326	return this->base().bucket_count();
327	}
328
329	size_type max_bucket_count() const
330	{
331	return this->base().max_bucket_count();
332	}
333
334	size_type bucket_size( size_type n ) const
335	{
336	return this->base().bucket_size( n );
337	}
338
339	float load_factor() const
340	{
341	return this->base().load_factor();
342	}
343
344	float max_load_factor() const
345	{
346	return this->base().max_load_factor();
347	}
348
349	void max_load_factor( float factor )
350	{
351	return this->base().max_load_factor( factor );
352	}
353
354	void rehash( size_type n )
355	{
356	this->base().rehash( n );
357	}
358
359	public:
360	#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(70190006))
361	iterator begin()
362	{
363	return base_type::begin();
364	}
365
366	const_iterator begin() const
367	{
368	return base_type::begin();
369	}
370
371	iterator end()
372	{
373	return base_type::end();
374	}
375
376	const_iterator end() const
377	{
378	return base_type::end();
379	}
380
381	const_iterator cbegin() const
382	{
383	return base_type::cbegin();
384	}
385
386	const_iterator cend() const
387	{
388	return base_type::cend();
389	}
390	#else
391	using base_type::begin;
392	using base_type::end;
393	using base_type::cbegin;
394	using base_type::cend;
395	#endif
396
397	protected:
398	local_iterator begin( size_type n )
399	{
400	return local_iterator( this->base().begin( n ) );
401	}
402
403	const_local_iterator begin( size_type n ) const
404	{
405	return const_local_iterator( this->base().begin( n ) );
406	}
407
408	local_iterator end( size_type n )
409	{
410	return local_iterator( this->base().end( n ) );
411	}
412
413	const_local_iterator end( size_type n ) const
414	{
415	return const_local_iterator( this->base().end( n ) );
416	}
417
418	const_local_iterator cbegin( size_type n ) const
419	{
420	return const_local_iterator( this->base().cbegin( n ) );
421	}
422
423	const_local_iterator cend( size_type n )
424	{
425	return const_local_iterator( this->base().cend( n ) );
426	}
427
428	}; // class 'associative_ptr_container'
429
430	} // namespace 'ptr_container_detail'
431
432	} // namespace 'boost'
433
11fdf7f2 TL	434	#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
	435	#pragma GCC diagnostic pop
	436	#endif
7c673cae FG	437
7c673cae FG	438	#endif