|
|
Boost-Commit : |
From: nesotto_at_[hidden]
Date: 2007-10-25 16:48:00
Author: nesotto
Date: 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
New Revision: 40464
URL: http://svn.boost.org/trac/boost/changeset/40464
Log:
major update of copy-operations and various pending fixes
Text files modified:
trunk/boost/ptr_container/detail/associative_ptr_container.hpp | 33 ++++++++++++--
trunk/boost/ptr_container/detail/reversible_ptr_container.hpp | 44 +++++++++++++++----
trunk/boost/ptr_container/ptr_array.hpp | 42 ++++++++++++++++--
trunk/boost/ptr_container/ptr_deque.hpp | 6 +-
trunk/boost/ptr_container/ptr_list.hpp | 6 +-
trunk/boost/ptr_container/ptr_map.hpp | 24 ++++++++++
trunk/boost/ptr_container/ptr_map_adapter.hpp | 62 +++++++++++++++++++++++++--
trunk/boost/ptr_container/ptr_sequence_adapter.hpp | 49 +++++++++++++++++----
trunk/boost/ptr_container/ptr_set.hpp | 7 ++
trunk/boost/ptr_container/ptr_set_adapter.hpp | 88 +++++++++++++++++++++++++++++++--------
trunk/boost/ptr_container/ptr_vector.hpp | 6 +-
11 files changed, 300 insertions(+), 67 deletions(-)
Modified: trunk/boost/ptr_container/detail/associative_ptr_container.hpp
==============================================================================
--- trunk/boost/ptr_container/detail/associative_ptr_container.hpp (original)
+++ trunk/boost/ptr_container/detail/associative_ptr_container.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -59,7 +59,7 @@
const Allocator& a )
: base_type( comp, a )
{ }
-
+
template< class InputIterator, class Compare, class Allocator >
associative_ptr_container( InputIterator first, InputIterator last,
const Compare& comp,
@@ -77,6 +77,12 @@
BOOST_DEDUCED_TYPENAME Config::allocator_type() )
{ }
+ template< class C, class V >
+ associative_ptr_container( const associative_ptr_container<C,V>& r )
+ : base_type( r.begin(), r.end(), key_compare(),
+ BOOST_DEDUCED_TYPENAME Config::allocator_type() )
+ { }
+
template< class PtrContainer >
associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
{
@@ -84,6 +90,14 @@
return *this;
}
+ template< class C, class V >
+ associative_ptr_container& operator=( const associative_ptr_container<C,V>& r ) // strong
+ {
+ associative_ptr_container clone( r );
+ this->swap( clone );
+ return *this;
+ }
+
associative_ptr_container& operator=( const associative_ptr_container& r ) // strong
{
associative_ptr_container clone( r );
@@ -110,17 +124,18 @@
this->remove( before ); // nothrow
iterator res( before ); // nothrow
++res; // nothrow
- this->base().erase( before.base() ); // 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
+ 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
+ return this->base().erase( x ); // nothrow
}
iterator erase( iterator first,
@@ -131,16 +146,22 @@
++res; // nothrow
this->remove( first, last ); // nothrow
- this->base().erase( first.base(), last.base() );// nothrow
+ this->base().erase( first.base(), last.base() ); // nothrow
return res; // nothrow
}
+#ifdef BOOST_NO_SFINAE
+#else
template< class Range >
- iterator erase( const Range& r )
+ 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 >
Modified: trunk/boost/ptr_container/detail/reversible_ptr_container.hpp
==============================================================================
--- trunk/boost/ptr_container/detail/reversible_ptr_container.hpp (original)
+++ trunk/boost/ptr_container/detail/reversible_ptr_container.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -241,10 +241,6 @@
void remove( I i )
{
null_policy_deallocate_clone( Config::get_const_pointer(i) );
-//#ifndef NDEBUG
-// *i = 0xbadbad;
-//#endif
-
}
template< class I >
@@ -254,7 +250,7 @@
remove( first );
}
- static void enforce_null_policy( Ty_* x, const char* msg )
+ static void enforce_null_policy( const Ty_* x, const char* msg )
{
if( !allow_null )
{
@@ -317,6 +313,13 @@
constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() );
}
+ template< class C, class V >
+ explicit reversible_ptr_container( const reversible_ptr_container<C,V>& r )
+ {
+ constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() );
+ }
+
+
template< class PtrContainer >
reversible_ptr_container& operator=( std::auto_ptr<PtrContainer> clone ) // nothrow
{
@@ -331,6 +334,13 @@
return *this;
}
+ template< class C, class V >
+ reversible_ptr_container& operator=( const reversible_ptr_container<C,V>& r ) // strong
+ {
+ reversible_ptr_container clone( r );
+ swap( clone );
+ return *this;
+ }
// overhead: null-initilization of container pointer (very cheap compared to cloning)
// overhead: 1 heap allocation (very cheap compared to cloning)
template< class InputIterator >
@@ -647,7 +657,6 @@
// is buggy on most compilers, so we use a macro instead
//
#define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type ) \
- \
PC( std::auto_ptr<this_type> r ) \
: base_type ( r ) { } \
\
@@ -670,6 +679,19 @@
return std::auto_ptr<this_type>( new this_type( this->begin(), this->end() ) ); \
}
+#define BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type ) \
+ \
+ template< class U > \
+ PC( const PC<U>& r ) : base_type( r ) { } \
+ \
+ template< class U > \
+ PC& operator=( const PC<U>& r ) \
+ { \
+ base_type::operator=( r ); \
+ return *this; \
+ }
+
+
#define BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type ) \
typedef BOOST_DEDUCED_TYPENAME base_type::iterator iterator; \
typedef BOOST_DEDUCED_TYPENAME base_type::size_type size_type; \
@@ -679,14 +701,16 @@
template< class InputIterator > \
PC( InputIterator first, InputIterator last, \
const allocator_type& a = allocator_type() ) : base_type( first, last, a ) {}
-
-
#define BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type ) \
BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type ) \
BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )
-
- } // namespace 'ptr_container_detail'
+
+#define BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( PC, base_type, this_type ) \
+ BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type ) \
+ BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type )
+
+} // namespace 'ptr_container_detail'
//
// @remark: expose movability of internal move-pointer
Modified: trunk/boost/ptr_container/ptr_array.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_array.hpp (original)
+++ trunk/boost/ptr_container/ptr_array.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -70,9 +70,6 @@
typedef ptr_array<T,N,CloneAllocator>
this_type;
- ptr_array( const this_type& );
- void operator=( const this_type& );
-
public:
typedef std::size_t size_type;
typedef U* value_type;
@@ -86,12 +83,47 @@
ptr_array() : base_class()
{ }
+ ptr_array( const ptr_array& r )
+ {
+ size_t i = 0;
+ for( ; i != N; ++i )
+ this->base()[i] = this->null_policy_allocate_clone(
+ static_cast<T*>( r.base()[i] ) );
+ }
+
+ template< class U >
+ ptr_array( const ptr_array<U,N>& r )
+ {
+ size_t i = 0;
+ for( ; i != N; ++i )
+ this->base()[i] = this->null_policy_allocate_clone(
+ static_cast<U*>( r.base()[i] ) );
+ }
+
ptr_array( std::auto_ptr<this_type> r )
: base_class( r ) { }
- void operator=( std::auto_ptr<this_type> r )
+ ptr_array& operator=( const ptr_array& r )
+ {
+ ptr_array clone( r );
+ this->swap( clone );
+ return *this;
+
+ }
+
+ template< class U >
+ ptr_array& operator=( const ptr_array<U,N>& r )
+ {
+ ptr_array clone( r );
+ this->swap( clone );
+ return *this;
+
+ }
+
+ ptr_array& operator=( std::auto_ptr<this_type> r )
{
base_class::operator=(r);
+ return *this;
}
std::auto_ptr<this_type> release()
@@ -107,7 +139,7 @@
for( size_t i = 0; i != N; ++i )
{
if( ! is_null(i) )
- pa->replace( i, CloneAllocator::allocate_clone( (*this)[i] ) );
+ pa->replace( i, this->null_policy_allocate_clone( &(*this)[i] ) );
}
return pa;
}
Modified: trunk/boost/ptr_container/ptr_deque.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_deque.hpp (original)
+++ trunk/boost/ptr_container/ptr_deque.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -42,9 +42,9 @@
public:
- BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( ptr_deque,
- base_class,
- this_type );
+ BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_deque,
+ base_class,
+ this_type );
};
//////////////////////////////////////////////////////////////////////////////
Modified: trunk/boost/ptr_container/ptr_list.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_list.hpp (original)
+++ trunk/boost/ptr_container/ptr_list.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -41,9 +41,9 @@
typedef ptr_list<T,CloneAllocator,Allocator> this_type;
public:
- BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( ptr_list,
- base_class,
- this_type );
+ BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_list,
+ base_class,
+ this_type );
public:
using base_class::merge;
Modified: trunk/boost/ptr_container/ptr_map.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_map.hpp (original)
+++ trunk/boost/ptr_container/ptr_map.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -41,8 +41,8 @@
typedef ptr_map<Key,T,Compare,CloneAllocator,Allocator> this_type;
public:
- explicit ptr_map( const Compare& comp = Compare(),
- const Allocator& a = Allocator() )
+ ptr_map( const Compare& comp = Compare(),
+ const Allocator& a = Allocator() )
: base_type( comp, a ) { }
template< class InputIterator >
@@ -55,6 +55,16 @@
BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_map, base_type,
this_type );
+ template< class U >
+ ptr_map( const ptr_map<Key,U>& r ) : base_type( r )
+ { }
+
+ template< class U >
+ ptr_map& operator=( const ptr_map<Key,U>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
};
@@ -93,6 +103,16 @@
base_type,
this_type );
+ template< class U >
+ ptr_multimap( const ptr_multimap<Key,U>& r ) : base_type( r )
+ { }
+
+ template< class U >
+ ptr_multimap& operator=( const ptr_multimap<Key,U>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
};
//////////////////////////////////////////////////////////////////////////////
Modified: trunk/boost/ptr_container/ptr_map_adapter.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_map_adapter.hpp (original)
+++ trunk/boost/ptr_container/ptr_map_adapter.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -174,10 +174,6 @@
public:
- ptr_map_adapter_base( const allocator_type& a = allocator_type() )
- : base_type(a)
- { }
-
template< class InputIterator >
ptr_map_adapter_base( InputIterator first, InputIterator last,
const allocator_type& a = allocator_type() )
@@ -354,7 +350,7 @@
if( res.second ) // nothrow
ptr.release(); // nothrow
}
-
+
template< class II >
void map_basic_clone_and_insert( II first, II last )
{
@@ -388,10 +384,38 @@
map_basic_clone_and_insert( first, last );
}
+ ptr_map_adapter( const ptr_map_adapter& r )
+ : base_type( key_compare(), allocator_type() )
+ {
+ map_basic_clone_and_insert( r.begin(), r.end() );
+ }
+
+ template< class Key, class U >
+ ptr_map_adapter( const ptr_map_adapter<Key,U>& r )
+ : base_type( key_compare(), allocator_type() )
+ {
+ 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=( const ptr_map_adapter& r )
+ {
+ ptr_map_adapter clone( r );
+ this->swap( clone );
+ return *this;
+ }
+
+ template< class Key, class U >
+ ptr_map_adapter& operator=( const ptr_map_adapter<Key,U> r )
+ {
+ ptr_map_adapter clone( r );
+ this->swap( clone );
+ return *this;
+ }
+
template< class U >
void operator=( std::auto_ptr<U> r )
{
@@ -571,10 +595,38 @@
map_basic_clone_and_insert( first, last );
}
+ ptr_multimap_adapter( const ptr_multimap_adapter& r )
+ : base_type( key_compare(), allocator_type() )
+ {
+ map_basic_clone_and_insert( r.begin(), r.end() );
+ }
+
+ template< class Key, class U >
+ ptr_multimap_adapter( const ptr_multimap_adapter<Key,U>& r )
+ : base_type( key_compare(), allocator_type() )
+ {
+ map_basic_clone_and_insert( r.begin(), r.end() );
+ }
+
template< class U >
ptr_multimap_adapter( std::auto_ptr<U> r ) : base_type( r )
{ }
+ ptr_multimap_adapter& operator=( const ptr_multimap_adapter& r )
+ {
+ ptr_multimap_adapter clone( r );
+ this->swap( clone );
+ return *this;
+ }
+
+ template< class Key, class U >
+ ptr_multimap_adapter& operator=( const ptr_multimap_adapter<Key,U> r )
+ {
+ ptr_multimap_adapter clone( r );
+ this->swap( clone );
+ return *this;
+ }
+
template< class U >
void operator=( std::auto_ptr<U> r )
{
Modified: trunk/boost/ptr_container/ptr_sequence_adapter.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_sequence_adapter.hpp (original)
+++ trunk/boost/ptr_container/ptr_sequence_adapter.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -153,16 +153,29 @@
BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( ptr_sequence_adapter,
base_type )
-
+
+ template< class U >
+ ptr_sequence_adapter( const ptr_sequence_adapter<U,VoidPtrSeq>& r )
+ : base_type( r )
+ { }
+
template< class PtrContainer >
ptr_sequence_adapter( std::auto_ptr<PtrContainer> clone )
: base_type( clone )
{ }
+ template< class U >
+ ptr_sequence_adapter& operator=( const ptr_sequence_adapter<U,VoidPtrSeq>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
+
template< class PtrContainer >
- void operator=( std::auto_ptr<PtrContainer> clone )
+ ptr_sequence_adapter& operator=( std::auto_ptr<PtrContainer> clone )
{
base_type::operator=( clone );
+ return *this;
}
/////////////////////////////////////////////////////////////
@@ -312,11 +325,6 @@
template< class InputIterator >
void assign( InputIterator first, InputIterator last ) // strong
{
-//#ifdef BOOST_NO_SFINAE
-//#else
-// BOOST_STATIC_ASSERT(( boost::is_convertible< typename iterator_reference<InputIterator>::type,
-// reference_type >::value ));
-//#endif
base_type temp( first, last );
this->swap( temp );
}
@@ -418,7 +426,27 @@
this->base().
insert( before.base(),
from.begin().base(), from.end().base() ); // strong
- from.base().clear(); // nothrow
+ from.base().clear(); // nothrow
+ }
+
+ public: // C-array support
+
+ void transfer( iterator before, T** from,
+ size_type size, bool delete_from = true ) // strong
+ {
+ BOOST_ASSERT( from != 0 );
+ this->base().insert( before.base(), from, from + size ); // strong
+ if( delete_from )
+ delete[] from;
+ }
+
+ T** c_array() // nothrow
+ {
+ if( this->empty() )
+ return 0;
+ T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
+ BOOST_ASSERT( &*this->begin().base() == (void**)res );
+ return res;
}
public: // null functions
@@ -441,13 +469,14 @@
else if( size > old_size )
{
for( ; old_size != size; ++old_size )
- this->push_back( new T );
+ this->push_back( new BOOST_DEDUCED_TYPENAME
+ boost::remove_pointer<value_type>::type );
}
BOOST_ASSERT( this->size() == size );
}
- void resize( size_type size, T* to_clone )
+ void resize( size_type size, value_type to_clone )
{
size_type old_size = this->size();
if( old_size > size )
Modified: trunk/boost/ptr_container/ptr_set.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_set.hpp (original)
+++ trunk/boost/ptr_container/ptr_set.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -57,7 +57,8 @@
BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_set,
base_type,
this_type );
-
+ BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_set, base_type )
+
};
@@ -95,7 +96,9 @@
BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multiset,
base_type,
- this_type );
+ this_type );
+ BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_multiset,
+ base_type );
};
Modified: trunk/boost/ptr_container/ptr_set_adapter.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_set_adapter.hpp (original)
+++ trunk/boost/ptr_container/ptr_set_adapter.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -103,30 +103,56 @@
public:
- template< class Compare, class Allocator >
- ptr_set_adapter_base( const Compare& comp,
+ template< class Compare, class Allocator >
+ ptr_set_adapter_base( const Compare& comp,
const Allocator& a )
: base_type( comp, a )
- { }
-
- template< class InputIterator, class Compare, class Allocator >
- ptr_set_adapter_base( InputIterator first, InputIterator last,
+ { }
+
+ template< class InputIterator, class Compare, class Allocator >
+ ptr_set_adapter_base( InputIterator first, InputIterator last,
const Compare& comp,
const Allocator& a )
: base_type( first, last, comp, a )
- { }
-
+ { }
+
+ template< class U, class Set >
+ ptr_set_adapter_base( const ptr_set_adapter_base<U,Set>& r )
+ : base_type( r )
+ { }
+
template< class PtrContainer >
ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
: base_type( clone )
{ }
+
+ template< class U, class Set >
+ ptr_set_adapter_base& operator=( const ptr_set_adapter_base<U,Set>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
template< typename PtrContainer >
- void operator=( std::auto_ptr<PtrContainer> clone )
+ ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )
{
base_type::operator=( clone );
+ return *this;
+ }
+
+ using base_type::erase;
+
+ size_type erase( const key_type& x ) // nothrow
+ {
+ iterator i( this->base().find( const_cast<key_type*>(&x) ) );
+ // nothrow
+ if( i == this->end() ) // nothrow
+ return 0u; // nothrow
+ this->remove( i ); // nothrow
+ return this->base().erase( const_cast<key_type*>(&x) ); // nothrow
}
-
+
+
iterator find( const key_type& x )
{
return iterator( this->base().
@@ -244,7 +270,7 @@
{
BOOST_ASSERT( this->empty() );
}
-
+
template< class InputIterator, class Compare, class Allocator >
ptr_set_adapter( InputIterator first, InputIterator last,
const Compare& comp = Compare(),
@@ -255,10 +281,23 @@
set_basic_clone_and_insert( first, last );
}
- template< class T >
- ptr_set_adapter( std::auto_ptr<T> r ) : base_type( r )
+ template< class U, class Set >
+ ptr_set_adapter( const ptr_set_adapter<U,Set>& r )
+ : base_type( r )
+ { }
+
+ template< class PtrContainer >
+ ptr_set_adapter( std::auto_ptr<PtrContainer> clone )
+ : base_type( clone )
{ }
+ template< class U, class Set >
+ ptr_set_adapter& operator=( const ptr_set_adapter<U,Set>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
+
template< class T >
void operator=( std::auto_ptr<T> r )
{
@@ -337,7 +376,7 @@
return this->single_transfer( first, last, from );
}
-#ifdef BOOST_NO_SFINAE || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
+#ifdef BOOST_NO_SFINAE
#else
template< class PtrSetAdapter, class Range >
@@ -414,10 +453,23 @@
set_basic_clone_and_insert( first, last );
}
- template< class T >
- ptr_multiset_adapter( std::auto_ptr<T> r ) : base_type( r )
+ template< class U, class Set >
+ ptr_multiset_adapter( const ptr_multiset_adapter<U,Set>& r )
+ : base_type( r )
+ { }
+
+ template< class PtrContainer >
+ ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone )
+ : base_type( clone )
{ }
+ template< class U, class Set >
+ ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set>& r )
+ {
+ base_type::operator=( r );
+ return *this;
+ }
+
template< class T >
void operator=( std::auto_ptr<T> r )
{
@@ -458,7 +510,7 @@
set_basic_clone_and_insert( first, last );
}
-#ifdef BOOST_NO_SFINAE || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
+#ifdef BOOST_NO_SFINAE
#else
template< class Range >
@@ -486,7 +538,7 @@
return this->multi_transfer( first, last, from );
}
-#ifdef BOOST_NO_SFINAE || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
+#ifdef BOOST_NO_SFINAE
#else
template< class PtrSetAdapter, class Range >
Modified: trunk/boost/ptr_container/ptr_vector.hpp
==============================================================================
--- trunk/boost/ptr_container/ptr_vector.hpp (original)
+++ trunk/boost/ptr_container/ptr_vector.hpp 2007-10-25 16:47:59 EDT (Thu, 25 Oct 2007)
@@ -42,9 +42,9 @@
public:
- BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( ptr_vector,
- base_class,
- this_type );
+ BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_vector,
+ base_class,
+ this_type );
ptr_vector( size_type n,
const allocator_type& alloc = allocator_type() )
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk