You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
752 lines
26 KiB
752 lines
26 KiB
// |
|
// 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_REVERSIBLE_PTR_CONTAINER_HPP |
|
#define BOOST_PTR_CONTAINER_DETAIL_REVERSIBLE_PTR_CONTAINER_HPP |
|
|
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200) |
|
# pragma once |
|
#endif |
|
|
|
#include <boost/ptr_container/detail/throw_exception.hpp> |
|
#include <boost/ptr_container/detail/scoped_deleter.hpp> |
|
#include <boost/ptr_container/detail/static_move_ptr.hpp> |
|
#include <boost/ptr_container/exception.hpp> |
|
#include <boost/ptr_container/clone_allocator.hpp> |
|
#include <boost/ptr_container/nullable.hpp> |
|
|
|
#ifdef BOOST_NO_SFINAE |
|
#else |
|
#include <boost/range/functions.hpp> |
|
#endif |
|
|
|
#include <boost/config.hpp> |
|
#include <boost/iterator/reverse_iterator.hpp> |
|
#include <boost/range/iterator.hpp> |
|
#include <boost/utility/enable_if.hpp> |
|
#include <boost/type_traits/is_pointer.hpp> |
|
#include <boost/type_traits/is_integral.hpp> |
|
#include <typeinfo> |
|
#include <memory> |
|
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) |
|
#pragma warning(push) |
|
#pragma warning(disable:4127) |
|
#endif |
|
|
|
namespace boost |
|
{ |
|
|
|
namespace ptr_container_detail |
|
{ |
|
template< class CloneAllocator > |
|
struct clone_deleter |
|
{ |
|
template< class T > |
|
void operator()( const T* p ) const |
|
{ |
|
CloneAllocator::deallocate_clone( p ); |
|
} |
|
}; |
|
|
|
template< class T > |
|
struct is_pointer_or_integral |
|
{ |
|
BOOST_STATIC_CONSTANT(bool, value = is_pointer<T>::value || is_integral<T>::value ); |
|
}; |
|
|
|
struct is_pointer_or_integral_tag {}; |
|
struct is_range_tag {}; |
|
struct sequence_tag {}; |
|
struct fixed_length_sequence_tag : sequence_tag {}; |
|
struct associative_container_tag {}; |
|
struct ordered_associative_container_tag : associative_container_tag {}; |
|
struct unordered_associative_container_tag : associative_container_tag {}; |
|
|
|
|
|
|
|
template |
|
< |
|
class Config, |
|
class CloneAllocator |
|
> |
|
class reversible_ptr_container |
|
{ |
|
private: |
|
BOOST_STATIC_CONSTANT( bool, allow_null = Config::allow_null ); |
|
|
|
typedef BOOST_DEDUCED_TYPENAME Config::value_type Ty_; |
|
|
|
template< bool allow_null_values > |
|
struct null_clone_allocator |
|
{ |
|
template< class Iter > |
|
static Ty_* allocate_clone_from_iterator( Iter i ) |
|
{ |
|
return allocate_clone( Config::get_const_pointer( i ) ); |
|
} |
|
|
|
static Ty_* allocate_clone( const Ty_* x ) |
|
{ |
|
if( allow_null_values ) |
|
{ |
|
if( x == 0 ) |
|
return 0; |
|
} |
|
else |
|
{ |
|
BOOST_ASSERT( x != 0 && "Cannot insert clone of null!" ); |
|
} |
|
|
|
Ty_* res = CloneAllocator::allocate_clone( *x ); |
|
BOOST_ASSERT( typeid(*res) == typeid(*x) && |
|
"CloneAllocator::allocate_clone() does not clone the " |
|
"object properly. Check that new_clone() is implemented" |
|
" correctly" ); |
|
return res; |
|
} |
|
|
|
static void deallocate_clone( const Ty_* x ) |
|
{ |
|
if( allow_null_values ) |
|
{ |
|
if( x == 0 ) |
|
return; |
|
} |
|
|
|
CloneAllocator::deallocate_clone( x ); |
|
} |
|
}; |
|
|
|
typedef BOOST_DEDUCED_TYPENAME Config::void_container_type Cont; |
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
|
typedef null_clone_allocator<reversible_ptr_container::allow_null> |
|
null_cloner_type; |
|
#else |
|
typedef null_clone_allocator<allow_null> null_cloner_type; |
|
#endif |
|
typedef clone_deleter<null_cloner_type> Deleter; |
|
|
|
Cont c_; |
|
|
|
public: |
|
Cont& base() { return c_; } |
|
protected: // having this public could break encapsulation |
|
const Cont& base() const { return c_; } |
|
|
|
public: // typedefs |
|
typedef Ty_* value_type; |
|
typedef Ty_* pointer; |
|
typedef Ty_& reference; |
|
typedef const Ty_& const_reference; |
|
|
|
typedef BOOST_DEDUCED_TYPENAME Config::iterator |
|
iterator; |
|
typedef BOOST_DEDUCED_TYPENAME Config::const_iterator |
|
const_iterator; |
|
typedef boost::reverse_iterator< iterator > |
|
reverse_iterator; |
|
typedef boost::reverse_iterator< const_iterator > |
|
const_reverse_iterator; |
|
typedef BOOST_DEDUCED_TYPENAME Cont::difference_type |
|
difference_type; |
|
typedef BOOST_DEDUCED_TYPENAME Cont::size_type |
|
size_type; |
|
typedef BOOST_DEDUCED_TYPENAME Config::allocator_type |
|
allocator_type; |
|
typedef CloneAllocator clone_allocator_type; |
|
typedef ptr_container_detail::static_move_ptr<Ty_,Deleter> |
|
auto_type; |
|
|
|
protected: |
|
|
|
typedef ptr_container_detail::scoped_deleter<Ty_,null_cloner_type> |
|
scoped_deleter; |
|
typedef BOOST_DEDUCED_TYPENAME Cont::iterator |
|
ptr_iterator; |
|
typedef BOOST_DEDUCED_TYPENAME Cont::const_iterator |
|
ptr_const_iterator; |
|
private: |
|
|
|
template< class InputIterator > |
|
void copy( InputIterator first, InputIterator last ) |
|
{ |
|
std::copy( first, last, begin() ); |
|
} |
|
|
|
void copy( const reversible_ptr_container& r ) |
|
{ |
|
copy( r.begin(), r.end() ); |
|
} |
|
|
|
void copy_clones_and_release( scoped_deleter& sd ) // nothrow |
|
{ |
|
BOOST_ASSERT( size_type( std::distance( sd.begin(), sd.end() ) ) == c_.size() ); |
|
std::copy( sd.begin(), sd.end(), c_.begin() ); |
|
sd.release(); |
|
} |
|
|
|
template< class ForwardIterator > |
|
void clone_assign( ForwardIterator first, |
|
ForwardIterator last ) // strong |
|
{ |
|
BOOST_ASSERT( first != last ); |
|
scoped_deleter sd( first, last ); // strong |
|
copy_clones_and_release( sd ); // nothrow |
|
} |
|
|
|
template< class ForwardIterator > |
|
void clone_back_insert( ForwardIterator first, |
|
ForwardIterator last ) |
|
{ |
|
BOOST_ASSERT( first != last ); |
|
scoped_deleter sd( first, last ); |
|
insert_clones_and_release( sd, end() ); |
|
} |
|
|
|
void remove_all() |
|
{ |
|
remove( begin(), end() ); |
|
} |
|
|
|
protected: |
|
|
|
void insert_clones_and_release( scoped_deleter& sd, |
|
iterator where ) // strong |
|
{ |
|
// |
|
// 'c_.insert' always provides the strong guarantee for T* elements |
|
// since a copy constructor of a pointer cannot throw |
|
// |
|
c_.insert( where.base(), |
|
sd.begin(), sd.end() ); |
|
sd.release(); |
|
} |
|
|
|
void insert_clones_and_release( scoped_deleter& sd ) // strong |
|
{ |
|
c_.insert( sd.begin(), sd.end() ); |
|
sd.release(); |
|
} |
|
|
|
template< class U > |
|
void remove( U* ptr ) |
|
{ |
|
null_policy_deallocate_clone( ptr ); |
|
} |
|
|
|
template< class I > |
|
void remove( I i ) |
|
{ |
|
null_policy_deallocate_clone( Config::get_const_pointer(i) ); |
|
} |
|
|
|
template< class I > |
|
void remove( I first, I last ) |
|
{ |
|
for( ; first != last; ++first ) |
|
remove( first ); |
|
} |
|
|
|
static void enforce_null_policy( const Ty_* x, const char* msg ) |
|
{ |
|
if( !allow_null ) |
|
{ |
|
BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed", |
|
bad_pointer, msg ); |
|
} |
|
} |
|
|
|
static Ty_* null_policy_allocate_clone( const Ty_* x ) |
|
{ |
|
return null_cloner_type::allocate_clone( x ); |
|
} |
|
|
|
static void null_policy_deallocate_clone( const Ty_* x ) |
|
{ |
|
null_cloner_type::deallocate_clone( x ); |
|
} |
|
|
|
private: |
|
template< class ForwardIterator > |
|
ForwardIterator advance( ForwardIterator begin, size_type n ) |
|
{ |
|
ForwardIterator iter = begin; |
|
std::advance( iter, n ); |
|
return iter; |
|
} |
|
|
|
template< class I > |
|
void constructor_impl( I first, I last, std::input_iterator_tag ) // basic |
|
{ |
|
while( first != last ) |
|
{ |
|
insert( end(), null_cloner_type::allocate_clone_from_iterator(first) ); |
|
++first; |
|
} |
|
} |
|
|
|
template< class I > |
|
void constructor_impl( I first, I last, std::forward_iterator_tag ) // strong |
|
{ |
|
if( first == last ) |
|
return; |
|
clone_back_insert( first, last ); |
|
} |
|
|
|
template< class I > |
|
void associative_constructor_impl( I first, I last ) // strong |
|
{ |
|
if( first == last ) |
|
return; |
|
|
|
scoped_deleter sd( first, last ); |
|
insert_clones_and_release( sd ); |
|
} |
|
|
|
public: // foundation! should be protected! |
|
reversible_ptr_container() |
|
{ } |
|
|
|
template< class SizeType > |
|
reversible_ptr_container( SizeType n, unordered_associative_container_tag ) |
|
: c_( n ) |
|
{ } |
|
|
|
template< class SizeType > |
|
reversible_ptr_container( SizeType n, fixed_length_sequence_tag ) |
|
: c_( n ) |
|
{ } |
|
|
|
template< class SizeType > |
|
reversible_ptr_container( SizeType n, const allocator_type& a, |
|
fixed_length_sequence_tag ) |
|
: c_( n, a ) |
|
{ } |
|
|
|
explicit reversible_ptr_container( const allocator_type& a ) |
|
: c_( a ) |
|
{ } |
|
|
|
template< class PtrContainer > |
|
explicit reversible_ptr_container( std::auto_ptr<PtrContainer> clone ) |
|
{ |
|
swap( *clone ); |
|
} |
|
|
|
reversible_ptr_container( const reversible_ptr_container& r ) |
|
{ |
|
constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); |
|
} |
|
|
|
template< class C, class V > |
|
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 |
|
{ |
|
swap( *clone ); |
|
return *this; |
|
} |
|
|
|
reversible_ptr_container& operator=( reversible_ptr_container r ) // strong |
|
{ |
|
swap( r ); |
|
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 > |
|
reversible_ptr_container( InputIterator first, |
|
InputIterator last, |
|
const allocator_type& a = allocator_type() ) // basic, strong |
|
: c_( a ) |
|
{ |
|
constructor_impl( first, last, |
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
|
#else |
|
BOOST_DEDUCED_TYPENAME |
|
#endif |
|
iterator_category<InputIterator>::type() ); |
|
} |
|
|
|
template< class Compare > |
|
reversible_ptr_container( const Compare& comp, |
|
const allocator_type& a ) |
|
: c_( comp, a ) {} |
|
|
|
template< class ForwardIterator > |
|
reversible_ptr_container( ForwardIterator first, |
|
ForwardIterator last, |
|
fixed_length_sequence_tag ) |
|
: c_( std::distance(first,last) ) |
|
{ |
|
constructor_impl( first, last, |
|
std::forward_iterator_tag() ); |
|
} |
|
|
|
template< class SizeType, class InputIterator > |
|
reversible_ptr_container( SizeType n, |
|
InputIterator first, |
|
InputIterator last, |
|
fixed_length_sequence_tag ) |
|
: c_( n ) |
|
{ |
|
constructor_impl( first, last, |
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
|
#else |
|
BOOST_DEDUCED_TYPENAME |
|
#endif |
|
iterator_category<InputIterator>::type() ); |
|
} |
|
|
|
template< class Compare > |
|
reversible_ptr_container( const Compare& comp, |
|
const allocator_type& a, |
|
associative_container_tag ) |
|
: c_( comp, a ) |
|
{ } |
|
|
|
template< class InputIterator > |
|
reversible_ptr_container( InputIterator first, |
|
InputIterator last, |
|
associative_container_tag ) |
|
{ |
|
associative_constructor_impl( first, last ); |
|
} |
|
|
|
template< class InputIterator, class Compare > |
|
reversible_ptr_container( InputIterator first, |
|
InputIterator last, |
|
const Compare& comp, |
|
const allocator_type& a, |
|
associative_container_tag ) |
|
: c_( comp, a ) |
|
{ |
|
associative_constructor_impl( first, last ); |
|
} |
|
|
|
explicit reversible_ptr_container( size_type n ) |
|
: c_( n ) {} |
|
|
|
template< class Hash, class Pred > |
|
reversible_ptr_container( const Hash& h, |
|
const Pred& pred, |
|
const allocator_type& a ) |
|
: c_( h, pred, a ) {} |
|
|
|
template< class InputIterator, class Hash, class Pred > |
|
reversible_ptr_container( InputIterator first, |
|
InputIterator last, |
|
const Hash& h, |
|
const Pred& pred, |
|
const allocator_type& a ) |
|
: c_( h, pred, a ) |
|
{ |
|
associative_constructor_impl( first, last ); |
|
} |
|
|
|
public: |
|
~reversible_ptr_container() |
|
{ |
|
remove_all(); |
|
} |
|
|
|
public: |
|
|
|
allocator_type get_allocator() const |
|
{ |
|
return c_.get_allocator(); |
|
} |
|
|
|
public: // container requirements |
|
iterator begin() |
|
{ return iterator( c_.begin() ); } |
|
const_iterator begin() const |
|
{ return const_iterator( c_.begin() ); } |
|
iterator end() |
|
{ return iterator( c_.end() ); } |
|
const_iterator end() const |
|
{ return const_iterator( c_.end() ); } |
|
|
|
reverse_iterator rbegin() |
|
{ return reverse_iterator( this->end() ); } |
|
const_reverse_iterator rbegin() const |
|
{ return const_reverse_iterator( this->end() ); } |
|
reverse_iterator rend() |
|
{ return reverse_iterator( this->begin() ); } |
|
const_reverse_iterator rend() const |
|
{ return const_reverse_iterator( this->begin() ); } |
|
|
|
const_iterator cbegin() const |
|
{ return const_iterator( c_.begin() ); } |
|
const_iterator cend() const |
|
{ return const_iterator( c_.end() ); } |
|
|
|
const_reverse_iterator crbegin() const |
|
{ return const_reverse_iterator( this->end() ); } |
|
const_reverse_iterator crend() const |
|
{ return const_reverse_iterator( this->begin() ); } |
|
|
|
void swap( reversible_ptr_container& r ) // nothrow |
|
{ |
|
c_.swap( r.c_ ); |
|
} |
|
|
|
size_type size() const // nothrow |
|
{ |
|
return c_.size(); |
|
} |
|
|
|
size_type max_size() const // nothrow |
|
{ |
|
return c_.max_size(); |
|
} |
|
|
|
bool empty() const // nothrow |
|
{ |
|
return c_.empty(); |
|
} |
|
|
|
public: // optional container requirements |
|
|
|
bool operator==( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
if( size() != r.size() ) |
|
return false; |
|
else |
|
return std::equal( begin(), end(), r.begin() ); |
|
} |
|
|
|
bool operator!=( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
return !(*this == r); |
|
} |
|
|
|
bool operator<( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
return std::lexicographical_compare( begin(), end(), r.begin(), r.end() ); |
|
} |
|
|
|
bool operator<=( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
return !(r < *this); |
|
} |
|
|
|
bool operator>( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
return r < *this; |
|
} |
|
|
|
bool operator>=( const reversible_ptr_container& r ) const // nothrow |
|
{ |
|
return !(*this < r); |
|
} |
|
|
|
public: // modifiers |
|
|
|
iterator insert( iterator before, Ty_* x ) |
|
{ |
|
enforce_null_policy( x, "Null pointer in 'insert()'" ); |
|
|
|
auto_type ptr( x ); // nothrow |
|
iterator res( c_.insert( before.base(), x ) ); // strong, commit |
|
ptr.release(); // nothrow |
|
return res; |
|
} |
|
|
|
template< class U > |
|
iterator insert( iterator before, std::auto_ptr<U> x ) |
|
{ |
|
return insert( before, x.release() ); |
|
} |
|
|
|
iterator erase( iterator x ) // nothrow |
|
{ |
|
BOOST_ASSERT( !empty() ); |
|
BOOST_ASSERT( x != end() ); |
|
|
|
remove( x ); |
|
return iterator( c_.erase( x.base() ) ); |
|
} |
|
|
|
iterator erase( iterator first, iterator last ) // nothrow |
|
{ |
|
remove( first, last ); |
|
return iterator( c_.erase( first.base(), |
|
last.base() ) ); |
|
} |
|
|
|
template< class Range > |
|
iterator erase( const Range& r ) |
|
{ |
|
return erase( boost::begin(r), boost::end(r) ); |
|
} |
|
|
|
void clear() |
|
{ |
|
remove_all(); |
|
c_.clear(); |
|
} |
|
|
|
public: // access interface |
|
|
|
auto_type release( iterator where ) |
|
{ |
|
BOOST_ASSERT( where != end() ); |
|
|
|
BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation, |
|
"'release()' on empty container" ); |
|
|
|
auto_type ptr( Config::get_pointer( where ) ); // nothrow |
|
c_.erase( where.base() ); // nothrow |
|
return boost::ptr_container_detail::move( ptr ); |
|
} |
|
|
|
auto_type replace( iterator where, Ty_* x ) // strong |
|
{ |
|
BOOST_ASSERT( where != end() ); |
|
|
|
enforce_null_policy( x, "Null pointer in 'replace()'" ); |
|
|
|
auto_type ptr( x ); |
|
|
|
BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation, |
|
"'replace()' on empty container" ); |
|
|
|
auto_type old( Config::get_pointer( where ) ); // nothrow |
|
const_cast<void*&>(*where.base()) = ptr.release(); |
|
return boost::ptr_container_detail::move( old ); |
|
} |
|
|
|
template< class U > |
|
auto_type replace( iterator where, std::auto_ptr<U> x ) |
|
{ |
|
return replace( where, x.release() ); |
|
} |
|
|
|
auto_type replace( size_type idx, Ty_* x ) // strong |
|
{ |
|
enforce_null_policy( x, "Null pointer in 'replace()'" ); |
|
|
|
auto_type ptr( x ); |
|
|
|
BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= size(), bad_index, |
|
"'replace()' out of bounds" ); |
|
|
|
auto_type old( static_cast<Ty_*>( c_[idx] ) ); // nothrow |
|
c_[idx] = ptr.release(); // nothrow, commit |
|
return boost::ptr_container_detail::move( old ); |
|
} |
|
|
|
template< class U > |
|
auto_type replace( size_type idx, std::auto_ptr<U> x ) |
|
{ |
|
return replace( idx, x.release() ); |
|
} |
|
|
|
}; // 'reversible_ptr_container' |
|
|
|
|
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) |
|
#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \ |
|
typename base_type::auto_type \ |
|
release( typename base_type::iterator i ) \ |
|
{ \ |
|
return boost::ptr_container_detail::move(base_type::release(i)); \ |
|
} |
|
#else |
|
#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \ |
|
using base_type::release; |
|
#endif |
|
|
|
// |
|
// two-phase lookup of template functions |
|
// is buggy on most compilers, so we use a macro instead |
|
// |
|
#define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type ) \ |
|
explicit PC( std::auto_ptr<this_type> r ) \ |
|
: base_type ( r ) { } \ |
|
\ |
|
PC& operator=( std::auto_ptr<this_type> r ) \ |
|
{ \ |
|
base_type::operator=( r ); \ |
|
return *this; \ |
|
} \ |
|
\ |
|
std::auto_ptr<this_type> release() \ |
|
{ \ |
|
std::auto_ptr<this_type> ptr( new this_type );\ |
|
this->swap( *ptr ); \ |
|
return ptr; \ |
|
} \ |
|
BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \ |
|
\ |
|
std::auto_ptr<this_type> clone() const \ |
|
{ \ |
|
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 ) { } \ |
|
\ |
|
PC& operator=( PC r ) \ |
|
{ \ |
|
this->swap( 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; \ |
|
typedef BOOST_DEDUCED_TYPENAME base_type::const_reference const_reference; \ |
|
typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type allocator_type; \ |
|
PC() {} \ |
|
explicit PC( const allocator_type& a ) : base_type(a) {} \ |
|
template< class InputIterator > \ |
|
PC( InputIterator first, InputIterator last ) : base_type( first, last ) {} \ |
|
template< class InputIterator > \ |
|
PC( InputIterator first, InputIterator last, \ |
|
const allocator_type& a ) : 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 ) |
|
|
|
#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 |
|
// |
|
namespace ptr_container |
|
{ |
|
using ptr_container_detail::move; |
|
} |
|
|
|
} // namespace 'boost' |
|
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) |
|
#pragma warning(pop) |
|
#endif |
|
|
|
#endif
|
|
|