Name

namespace boost
{

    template
    <
        class T,
        class VoidPtrSeq,
        class CloneAllocator = heap_clone_allocator
    >
    class ptr_sequence_adapter
    {
    public: // construct/copy/destroy
        template< class InputIterator >
        assign( InputIterator first, InputIterator last );
        template< class InputRange >
        assign( const InputRange& e );

    public: // element access
        T&        front();
        const T&  front() const;
        T&        back();
        const T&  back() const;

    public: // modifiers
        void      push_back( T* x );
        template< class U >
        void      push_back( std::auto_ptr<U> x );
        auto_type pop_back();
        iterator  insert( iterator position, T* x );
        template< class U >
        iterator  insert( iterator position, std::auto_ptr<U> x );
        template< class InputIterator >
        void      insert( iterator position, InputIterator first, InputIterator last );
        template< class InputRange >
        void      insert( iterator position, const InputRange& r );
        iterator  erase( iterator position );
        iterator  erase( iterator first, iterator last );
        template< class Range >
        iterator  erase( const Range& r );

    public: // pointer container requirements
        template< class PtrSequence >
        void transfer( iterator before, typename PtrSequence::iterator object,
                       PtrSequence& from );                             
        template< class PtrSequence >
        void transfer( iterator before, typename PtrSequence::iterator first, typename PtrSequence::iterator last,
                       PtrSequence& from );
        void template< class PtrSequence, class Range >
        void transfer( iterator before, const Range& r, PtrSequence& from );
        template< class PtrSequence >
        void transfer( iterator before, PtrSequence& from );

    public: // algorithms

        void sort();
        void sort( iterator first, iterator last );
        template< class Compare >
        void sort( Compare comp );
        template< class Compare >
        void sort( iterator begin, iterator end, Compare comp );

        void unique();
        void unique( iterator first, iterator last );
        template< class Compare >
        void unique( Compare comp );
        template< class Compare >
        void unique( iterator begin, iterator end, Compare comp );

        template< class Pred >
        void erase_if( Pred pred );
        template< class Pred >
        void erase_if( iterator begin, iterator end, Pred pred );

        void merge( ptr_sequence_adapter& r );
        template< class Compare >
        void merge( ptr_sequence_adapter& r, Compare comp );
        void merge( iterator first, iterator last, ptr_sequence_adapter& from );
        template< class Compare >
        void merge( iterator first, iterator last, ptr_sequence_adapter& from, Compare comp );

    public: // ptr_list interface

    public: // ptr_vector interface

    public: // ptr_deque interface

    }; //  class 'ptr_sequence_adapter'

} // namespace 'boost'