Name

namespace boost
{      
    template
    < 
        class T, 
        class CloneAllocator,
        class VoidPtrContainer
    >
    class reversible_ptr_container 
    {
    public: // typedefs
        typedef  T*                                           value_type;
        typedef  T&                                           reference;
        typedef  const T&                                     const_reference;
        typedef  implementation defined                       iterator;
        typedef  implementation defined                       const_iterator;
        typedef  typename VoidPtrContainer::differnce_type    difference_type; 
        typedef  typename VoidPtrContainer::size_type         size_type;
        typedef  typename VoidPtrContainer::allocator_type    allocator_type;
        typedef  implementation defined                       reverse_iterator;
        typedef  implementation defined                       const_reverse_iterator;
        typedef  implementation defined                       auto_type;
    
    public: // construct/copy/destroy
        reversible_ptr_container();
        reversible_ptr_container( auto_ptr<reversible_ptr_container> r );
        template< class InputIterator >
        reversible_ptr_container( InputIterator first, InputIterator last );
        ~reversible_ptr_container();
        void operator=( std::auto_ptr<reversible_ptr_container> r )  
        allocator_type get_allocator() const;                                      
    
    public: // iterators
        iterator                begin();
        const_iterator          begin() const;
        iterator                end();
        const_iterator          end() const;
        reverse_iterator        rbegin();
        const_reverse_iterator  rbegin() const;
        reverse_iterator        rend();
        const_reverse_iterator  rend() const;
        
    public: // capacity
        size_type  size() const;
        size_type  max_size() const;
        bool       empty() const;       
    
    public: // modifiers
        void      swap( reversible_ptr_container& r );
        void      clear():
    
    public: // pointer container requirements
        auto_type                                replace( iterator position, T* x );
        template< class U >
        auto_type                                replace( iterator position, std::auto_ptr<U> x );    
        std::auto_ptr<reversible_ptr_container>  clone() const;    
        std::auto_ptr<reversible_ptr_container>  release();
        auto_type                                release( iterator position );
        
    public: // serialization
        template< class Archive >
        void save( Archive& ar, const unsigned version ) const;  
        template< class Archive >
        void load( Archive& ar, const unsigned version );       
    
    }; //  class 'reversible_ptr_container'

    // comparison            
    template < class T, class CA, class VPC >
    bool operator==( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T, class CA, class VPC  >
    bool operator<( const reversible_ptr_container<T,CA,VPC>& x,
                    const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T, class CA, class VPC  >
    bool operator!=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator>( const reversible_ptr_container<T,CA,VPC>& x,
                    const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator>=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);
    
    template < class T,  class CA, class VPC >
    bool operator<=( const reversible_ptr_container<T,CA,VPC>& x,
                     const reversible_ptr_container<T,CA,VPC>& y);

    template< class T,  class CA, class VPC  >
    void swap( reversible_ptr_container<T,CA,VPC>& x,
               reversible_ptr_container<T,CA,VPC>& y );

    // clonability
    template< class T,  class CA, class VPC >
    reversible_ptr_container<T,CA,VPC>*
    new_clone( const reversible_ptr_container<T,CA,VPC>& r );

    // null predicate
    template< class Iterator >
    bool is_null( Iterator i );

} // namespace 'boost'