Class `ptr_sequence_adapter`

This section describes all the common operations for all the pointer sequences:

The ptr_sequence_adapter is also a concrete class that you can use to create custom pointer containers from.

See also:

reversible_ptr_container

Navigate:

Synopsis:

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 );
        auto_type pop_back();
        iterator  insert( iterator position, T* 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

        void  transfer( iterator before, iterator object,
                        ptr_sequence_adapter& from );
        void  transfer( iterator before, iterator first, iterator last,
                        ptr_sequence_adapter& from );
        void template< class Range>
        void transfer( iterator before, const Range& r, ptr_sequence_adapter& from );
        void transfer( iterator before, ptr_sequence_adapter& 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'

Semantics

Semantics: construct/copy/destroy

template< class InputIterator > void assign( InputIterator first, InputIterator last );
- Requirements: (first,last] is a valid range
- Effects: clear(); insert( first, last );
- Postconditions: size() == std::distance( first, last );
- Exception safety: strong guarantee
template< class InputRange > void assign( const InputRange& r );
- Effects: assign( boost::begin(r), boost::end(r) );

Semantics: element access

T& front();
- Requirements: not empty();
- Effects: return *begin();
- Throws: bad_ptr_container_operation if empty() == true
const T& front() const;
- Requirements: not empty();
- Effects: return *begin();
- Throws: bad_ptr_container_operation if empty() == true
T& back();
- Requirements: not empty();
- Effects: return *--end();
- Throws: bad_ptr_container_operation if empty() == true
const T& back() const;
- Requirements: not empty();
- Effects: return *--end();
- Throws: bad_ptr_container_operation if empty() == true

Semantics: modifiers

void push_back( T* x );
- Requirements: x != 0
- Effects: Inserts the pointer into container and takes ownership of it
- Throws: bad_pointer if x == 0
- Exception safety: Strong guarantee

auto_type pop_back();
- Requirements:not empty()
- Effects: Removes the last element in the container
- Postconditions: size() is one less
- Throws: bad_ptr_container_operation if empty() == true
- Exception safety: Strong guarantee
iterator insert( iterator position, T* x );
- Requirements: position is a valid iterator from the container and x != 0
- Effects: Inserts x before position and returns an iterator pointing to it
- Throws: bad_pointer if x == 0
- Exception safety: Strong guarantee

template< class InputIterator > void insert( iterator position, InputIterator first, InputIterator last );
- Requirements: position is a valid iterator from the container
- Effects: Inserts a cloned range before position
- Exception safety: Strong guarantee
template< class InputRange > void insert( iterator position, const InputRange& r );
- Effects: insert( position, boost::begin(r), boost::end(r) );
iterator erase( iterator position );
- Requirements: position is a valid iterator from the container
- Effects: Removes the element defined by position and returns an iterator to the following element
- Throws: Nothing
iterator erase( iterator first, iterator last );
- Requirements: [first,last) is a valid range
- Effects: Removes the range of element defined by [first,last) and returns an iterator to the following element
- Throws: Nothing
template< class Range > void erase( const Range& r );
- Effects: erase( boost::begin(r), boost::end(r) );

Semantics: pointer container requirements

You cannot use transfer() to move elements between two different types of containers. This is to avoid problems with different allocators. The requirement might be weakened in the future.

void transfer( iterator before, iterator object, ptr_sequence_adapter& from );
- Requirements: not from.empty()
- Effects: Inserts the object defined by object into the container and remove it from from. Insertion takes place before before.
- Postconditions: size() is one more, from.size() is one less.
- Exception safety: Strong guarantee
void transfer( iterator before, iterator first, iterator last, ptr_sequence_adapter& from );
- Requirements: not from.empty()
- Effects: Inserts the objects defined by the range [first,last) into the container and remove it from from. Insertion takes place before before.
- Postconditions: Let N == std::distance(first,last); then size() is N more, from.size() is N less.
- Exception safety: Strong guarantee
template< class Range> void transfer( iterator before, const Range& r, ptr_sequence_adapter& from );
- Effects: transfer(before, boost::begin(r), boost::end(r), from);
void transfer( iterator before, ptr_sequence_adapter& from );
- Effects: Transfers all objects from from into the container. Insertion takes place before before.
- Postconditions: from.empty();
- Exception safety: Strong guarantee

Semantics: algorithms

The general requirement for these algorithms is that the container does not contain any nulls.

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 );
- Requirements: (versions without Compare) bool operator<( const T&, const T& ) is defined
- Requirements: (Compare versions) Compare must take const T& arguments
- Effects: sorts the entire container or the specified range
- Exception safety: nothrow guarantee (the behavior is undefined if the comparison operator throws)
- Remarks: The versions of sort() that take two iterators are not available for ptr_list
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 );
- Requirements: (versions without Compare) bool operator==( const T&, const T& ) is defined
- Requirements: (Compare versions) Compare must take const T& arguments
- Effects: removes adjacent and equal objects from the entire container or the specified range
- Exception safety: nothrow guarantee (the behavior is undefined if the comparison operator throws)
template< class Pred > void erase_if( Pred pred );
template< class Pred > void erase_if( iterator begin, iterator end, Pred pred );
- Requirements: Pred must take an const T& argument
- Effects: removes all elements t for which pred(t) returns true from the entire container or the specified range
- Exception safety: nothrow guarantee (the behavior is undefined if the comparison operator throws)
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 );
- Requirements: (Compare versions) Compare must take const T& arguments
- Requirements: both sequences are sorted wrt. the same predicate
- Effects: transfers the entire container or the specified sequence to the container while ensuring the new sequence is also sorted
- Postconditions: (Container versions) r.empty()
- Exception safety: nothrow guarantee (the behavior is undefined if the comparison operator throws)

copyright:	Thorsten Ottosen 2004-2005.

Pointer Container Library