Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Classes | Public Types | Public Member Functions | Protected Types | List of all members
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > Class Template Reference

#include <ptr_sequence_adapter.hpp>

Inheritance diagram for boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >:
Inheritance graph
[legend]
Collaboration diagram for boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >:
Collaboration graph
[legend]

Classes

class  void_ptr_delete_if
 

Public Types

typedef BOOST_DEDUCED_TYPENAME
base_type::value_type 		value_type
 
typedef BOOST_DEDUCED_TYPENAME
base_type::reference 		reference
 
typedef BOOST_DEDUCED_TYPENAME
base_type::const_reference 		const_reference
 
typedef BOOST_DEDUCED_TYPENAME
base_type::auto_type 		auto_type
 
typedef BOOST_DEDUCED_TYPENAME
base_type::clone_allocator_type 		clone_allocator_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::allocator_type 		allocator_type
 

Public Member Functions

 ptr_sequence_adapter ()
 
template<class Allocator >
 ptr_sequence_adapter (const Allocator &a)
 
template<class SizeType >
 ptr_sequence_adapter (SizeType n, ptr_container_detail::fixed_length_sequence_tag tag)
 
template<class SizeType , class Allocator >
 ptr_sequence_adapter (SizeType n, const Allocator &a, ptr_container_detail::fixed_length_sequence_tag tag)
 
template<class InputIterator >
 ptr_sequence_adapter (InputIterator first, InputIterator last)
 
template<class InputIterator , class Allocator >
 ptr_sequence_adapter (InputIterator first, InputIterator last, const Allocator &a)
 
template<class ForwardIterator >
 ptr_sequence_adapter (ForwardIterator first, ForwardIterator last, ptr_container_detail::fixed_length_sequence_tag tag)
 
template<class SizeType , class ForwardIterator >
 ptr_sequence_adapter (SizeType n, ForwardIterator first, ForwardIterator last, ptr_container_detail::fixed_length_sequence_tag tag)
 
 ptr_sequence_adapter (const ptr_sequence_adapter &r)
 
template<class U >
 ptr_sequence_adapter (const ptr_sequence_adapter< U, VoidPtrSeq, CloneAllocator > &r)
 
 ptr_sequence_adapter (const ptr_sequence_adapter &r, ptr_container_detail::fixed_length_sequence_tag tag)
 
template<class U >
 ptr_sequence_adapter (const ptr_sequence_adapter< U, VoidPtrSeq, CloneAllocator > &r, ptr_container_detail::fixed_length_sequence_tag tag)
 
template<class PtrContainer >
 ptr_sequence_adapter (std::auto_ptr< PtrContainer > clone)
 
ptr_sequence_adapter & operator= (const ptr_sequence_adapter r)
 
template<class PtrContainer >
ptr_sequence_adapter & operator= (std::auto_ptr< PtrContainer > clone)
 
void push_back (value_type x)
 
template<class U >
void push_back (std::auto_ptr< U > x)
 
void push_front (value_type x)
 
template<class U >
void push_front (std::auto_ptr< U > x)
 
auto_type pop_back ()
 
auto_type pop_front ()
 
reference front ()
 
const_reference front () const
 
reference back ()
 
const_reference back () const
 
reference operator[] (size_type n)
 
const_reference operator[] (size_type n) const
 
reference at (size_type n)
 
const_reference at (size_type n) const
 
size_type capacity () const
 
void reserve (size_type n)
 
void reverse ()
 
template<class InputIterator >
void assign (InputIterator first, InputIterator last)
 
template<class Range >
void assign (const Range &r)
 
template<class InputIterator >
void insert (iterator before, InputIterator first, InputIterator last)
 
template<class Range >
BOOST_DEDUCED_TYPENAME
boost::disable_if
< ptr_container_detail::is_pointer_or_integral
< Range > >::type 		insert (iterator before, const Range &r)
 
template<class PtrSeqAdapter >
void transfer (iterator before, BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, PtrSeqAdapter &from)
 
template<class PtrSeqAdapter >
void transfer (iterator before, BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, PtrSeqAdapter &from)
 
template<class PtrSeqAdapter , class Range >
BOOST_DEDUCED_TYPENAME
boost::disable_if
< boost::is_same< Range,
BOOST_DEDUCED_TYPENAME
PtrSeqAdapter::iterator >
>::type 		transfer (iterator before, const Range &r, PtrSeqAdapter &from)
 
template<class PtrSeqAdapter >
void transfer (iterator before, PtrSeqAdapter &from)
 
void transfer (iterator before, value_type *from, size_type size, bool delete_from=true)
 
value_type * c_array ()
 
bool is_null (size_type idx) const
 
void resize (size_type size)
 
void resize (size_type size, value_type to_clone)
 
void rresize (size_type size)
 
void rresize (size_type size, value_type to_clone)
 
void sort (iterator first, iterator last)
 
void sort ()
 
template<class Compare >
void sort (iterator first, iterator last, Compare comp)
 
template<class Compare >
void sort (Compare comp)
 
void unique (iterator first, iterator last)
 
void unique ()
 
template<class Compare >
void unique (iterator first, iterator last, Compare comp)
 
template<class Compare >
void unique (Compare comp)
 
template<class Pred >
void erase_if (iterator first, iterator last, Pred pred)
 
template<class Pred >
void erase_if (Pred pred)
 
void merge (iterator first, iterator last, ptr_sequence_adapter &from)
 
template<class BinPred >
void merge (iterator first, iterator last, ptr_sequence_adapter &from, BinPred pred)
 
void merge (ptr_sequence_adapter &r)
 
template<class BinPred >
void merge (ptr_sequence_adapter &r, BinPred pred)
 

Protected Types

typedef BOOST_DEDUCED_TYPENAME
base_type::scoped_deleter 		scoped_deleter
 

Member Typedef Documentation

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::allocator_type
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::auto_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::auto_type
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::clone_allocator_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::clone_allocator_type
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::const_reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::const_reference
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::iterator boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::iterator
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::reference
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::scoped_deleter
protected
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::size_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::size_type
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
typedef BOOST_DEDUCED_TYPENAME base_type::value_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::value_type

Constructor & Destructor Documentation

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( )
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Allocator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( const Allocator &  a)
inlineexplicit
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class SizeType >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( SizeType  n,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class SizeType , class Allocator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( SizeType  n,
const Allocator &  a,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class InputIterator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( InputIterator  first,
InputIterator  last 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class InputIterator , class Allocator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( InputIterator  first,
InputIterator  last,
const Allocator &  a 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class ForwardIterator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( ForwardIterator  first,
ForwardIterator  last,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class SizeType , class ForwardIterator >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( SizeType  n,
ForwardIterator  first,
ForwardIterator  last,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( const ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  r)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class U >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( const ptr_sequence_adapter< U, VoidPtrSeq, CloneAllocator > &  r)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( const ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  r,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class U >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( const ptr_sequence_adapter< U, VoidPtrSeq, CloneAllocator > &  r,
ptr_container_detail::fixed_length_sequence_tag  tag 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrContainer >
boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::ptr_sequence_adapter ( std::auto_ptr< PtrContainer >  clone)
inlineexplicit

Member Function Documentation

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class InputIterator >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::assign ( InputIterator  first,
InputIterator  last 
)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::assign().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Range >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::assign ( const Range &  r)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::at ( size_type  n)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
const_reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::at ( size_type  n) const
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::back ( )
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::back(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::pop_back().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
const_reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::back ( ) const
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
value_type* boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::c_array ( )
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
size_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::capacity ( ) const
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Pred >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::erase_if ( iterator  first,
iterator  last,
Pred  pred 
)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::erase_if().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Pred >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::erase_if ( Pred  pred)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::front ( void  )
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::front(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::pop_front().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
const_reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::front ( void  ) const
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class InputIterator >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::insert ( iterator  before,
InputIterator  first,
InputIterator  last 
)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::insert(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::transfer().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Range >
BOOST_DEDUCED_TYPENAME boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::insert ( iterator  before,
const Range &  r 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
bool boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::is_null ( size_type  idx) const
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::at(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::operator[]().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::merge ( iterator  first,
iterator  last,
ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  from 
)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::merge().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class BinPred >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::merge ( iterator  first,
iterator  last,
ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  from,
BinPred  pred 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::merge ( ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  r)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class BinPred >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::merge ( ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator > &  r,
BinPred  pred 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
ptr_sequence_adapter& boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::operator= ( const ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >  r)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrContainer >
ptr_sequence_adapter& boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::operator= ( std::auto_ptr< PtrContainer >  clone)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::operator[] ( size_type  n)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
const_reference boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::operator[] ( size_type  n) const
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
auto_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::pop_back ( )
inline

Referenced by boost::assign_detail::generic_ptr_list< T >::convert().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
auto_type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::pop_front ( )
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::push_back ( value_type  x)
inline

Referenced by boost::assign_detail::generic_ptr_list< T >::push_back(), boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::push_back(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::resize().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class U >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::push_back ( std::auto_ptr< U >  x)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::push_front ( value_type  x)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::push_front(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::rresize().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class U >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::push_front ( std::auto_ptr< U >  x)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::reserve ( size_type  n)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::resize ( size_type  size)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::resize ( size_type  size,
value_type  to_clone 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::reverse ( )
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::rresize ( size_type  size)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::rresize ( size_type  size,
value_type  to_clone 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::sort ( iterator  first,
iterator  last 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::sort ( )
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::sort().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Compare >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::sort ( iterator  first,
iterator  last,
Compare  comp 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Compare >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::sort ( Compare  comp)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrSeqAdapter >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::transfer ( iterator  before,
BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator  first,
BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator  last,
PtrSeqAdapter &  from 
)
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::merge(), and boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::transfer().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrSeqAdapter >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::transfer ( iterator  before,
BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator  object,
PtrSeqAdapter &  from 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrSeqAdapter , class Range >
BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range, BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::transfer ( iterator  before,
const Range &  r,
PtrSeqAdapter &  from 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class PtrSeqAdapter >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::transfer ( iterator  before,
PtrSeqAdapter &  from 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::transfer ( iterator  before,
value_type *  from,
size_type  size,
bool  delete_from = true 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::unique ( iterator  first,
iterator  last 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::unique ( void  )
inline

Referenced by boost::ptr_sequence_adapter< T, boost::circular_buffer< void *, Allocator >, CloneAllocator >::unique().

template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Compare >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::unique ( iterator  first,
iterator  last,
Compare  comp 
)
inline
template<class T, class VoidPtrSeq, class CloneAllocator = heap_clone_allocator>
template<class Compare >
void boost::ptr_sequence_adapter< T, VoidPtrSeq, CloneAllocator >::unique ( Compare  comp)
inline
The documentation for this class was generated from the following file: