include/deque_spec.h

// -*- C++ -*-
/***************************************************************************
 *
 * deque_spec.h - deque <_TypeT*> partial specialization
 *
 ***************************************************************************
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 1994-2006 Rogue Wave Software.
 * 
 **************************************************************************/

#ifndef __STD_DEQUE_SPEC__
#define __STD_DEQUE_SPEC__

#include <rw/_defs.h>


#ifndef __STD_DEQUE__
#include <deque>
#endif   // __STD_DEQUE__


_RWSTD_NAMESPACE (std) { 


template class deque <void*, allocator <void*> >;


template <class _TypeT>
class deque <_TypeT*, allocator <_TypeT*> >
{
    typedef allocator <_TypeT*>                   _Allocator;
    typedef _RWSTD_REBIND (_Allocator, void*) __imp_alloc_type;
    typedef deque <void*, __imp_alloc_type>  __imp_type;

    __imp_type                                __imp;

public:

    typedef _TypeT*                               value_type;
    typedef _Allocator                        allocator_type;

    class        iterator;
    class        const_iterator;
    friend class iterator;
    friend class const_iterator;

    typedef _TYPENAME allocator_type::reference       reference;
    typedef _TYPENAME allocator_type::const_reference const_reference;
    typedef _TYPENAME allocator_type::size_type       size_type;
    typedef _TYPENAME allocator_type::difference_type difference_type;
    typedef _TYPENAME allocator_type::pointer         pointer;
    typedef _TYPENAME allocator_type::const_pointer   const_pointer;


protected:

    typedef _RWSTD_REBIND (_Allocator, pointer)   __map_alloc_type;
    typedef _TYPENAME __map_alloc_type::pointer  __map_pointer;

    typedef _STD::iterator <random_access_iterator_tag, value_type,
        difference_type, pointer,reference> __it;

    typedef _STD::iterator <random_access_iterator_tag, value_type, 
        difference_type, const_pointer, const_reference> __cit;

public:

    class const_iterator;

    class iterator : public __it
    {
        typedef _TYPENAME __imp_type::iterator __imp_iter;

        __imp_iter __imp;

        friend class deque<_TypeT, allocator <_TypeT> >;
        friend class const_iterator;

          // implicit conversions from and to implementation-specific iterator
          // used only internally
        iterator (const __imp_iter &imp)
            : __imp (imp) {}

        operator __imp_iter () {
            return __imp;
        }

    public:

        iterator () {}

        __iterator_base::reference operator* () const {
            return __iterator_base::reference (*__imp);
        }


#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN

        __iterator_base::pointer operator-> () const {
            return __iterator_base::pointer (&*__imp);
        }

#endif   // _RWSTD_NO_NONCLASS_ARROW_RETURN


        iterator& operator++ () { 
            ++__imp;
            return *this;
        }

        iterator operator++ (int) {
            iterator tmp = *this;
            ++*this;
            return tmp;
        }

        iterator& operator-- () {
            --__imp;
            return *this;
        }

        iterator operator-- (int) {
            iterator tmp = *this;
            --*this;
            return tmp;
        }

        iterator& operator+= (__iterator_base::difference_type n) {
            __imp += n;
            return *this;
        }

        iterator& operator-= (__iterator_base::difference_type n) {
            __imp -= n;
            return *this;
        }

        __iterator_base::difference_type operator- (const iterator& x) const {
            return __imp - x.__imp;
        }

        iterator operator- (__iterator_base::difference_type n) {
            return __imp - n;
        }

        iterator operator+ (__iterator_base::difference_type n) {
            return __imp + n;
        }

        __iterator_base::reference operator[] (__iterator_base::difference_type n) {
            return __imp [n];
        }

        bool operator== (const iterator &x) const {
            return __imp == x.__imp;
        }

        bool operator< (const iterator &x) const {
            return __imp < x.__imp;
        }

        bool operator> (const iterator &x) const {
            return x.__imp < *this;
        }

        bool operator!= (const iterator &x) const {
            return !(*this == x.__imp);
        }

        bool operator<= (const iterator &x) const {
            return !(*x.__imp < *this);
        }

        bool operator>= (const iterator &x) const {
            return !(x.__imp < *this);
        }
    };


    class const_iterator : public __cit
    {
        typedef _TYPENAME __imp_type::const_iterator __imp_iter;

        __imp_iter __imp;

        friend class deque<_TypeT, allocator <_TypeT> >;

        const_iterator (const __imp_iter &imp): __imp (imp) {}
    
    public:
      
        const_iterator () {}

        const_iterator (const iterator &x) : __imp (x.__imp) {}

        const_reference operator* () const {
            return const_reference (*__imp);
        }


#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN

        const_pointer operator-> () const {
            return const_pointer (&*__imp);
        }

#endif   //  _RWSTD_NO_NONCLASS_ARROW_RETURN


        const_iterator& operator++ () { 
            ++__imp;
            return *this;
        }

        const_iterator operator++ (int) {
            const_iterator tmp = *this;
            ++*this;
            return tmp;
        }

        const_iterator& operator-- () {
            --__imp;
            return *this;
        }

        const_iterator operator-- (int) {
            const_iterator tmp = *this;
            --*this;
            return tmp;
        }

        const_iterator& operator+= (__iterator_base::difference_type n) {
            __imp += n;
            return *this;
        }

        const_iterator& operator-= (__iterator_base::difference_type n) {
            __imp -= n;
            return *this;
        }

        __iterator_base::difference_type operator- (const const_iterator& x) const {
            return __imp - x.__imp;
        }

        const_iterator operator- (__iterator_base::difference_type n) {
            return __imp - n;
        }

        const_iterator operator+ (__iterator_base::difference_type n) {
            return __imp + n;
        }

        const_reference operator[] (__iterator_base::difference_type n) {
            return __imp [n];
        }

        bool operator== (const const_iterator &x) const {
            return __imp == x.__imp;
        }

        bool operator< (const const_iterator &x) const {
            return __imp < x.__imp;
        }

        bool operator> (const const_iterator &x) const {
            return x.__imp < *this;
        }

        bool operator!= (const const_iterator &x) const {
            return !(*this == x.__imp);
        }

        bool operator<= (const const_iterator &x) const {
            return !(*x.__imp < *this);
        }

        bool operator>= (const const_iterator &x) const {
            return !(x.__imp < *this);
        }
    };


#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC 
    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
#else
    typedef _STD::reverse_iterator<const_iterator, 
        random_access_iterator_tag, value_type, 
        const_reference, const_pointer, difference_type>
    const_reverse_iterator;

    typedef _STD::reverse_iterator<iterator, 
        random_access_iterator_tag, value_type,
        reference, pointer, difference_type>
    reverse_iterator;
#endif

public:

    _EXPLICIT deque (const _Allocator &alloc _RWSTD_DEFAULT_ARG (_Allocator ())) 
        : __imp (alloc) { }


#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS

    deque () 
        : __imp () { }

    deque (size_type n, const_reference x)
        : __imp (n, x) { }

#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS


    _EXPLICIT deque (size_type n)
        : __imp (n) { }


    deque (size_type n, const_reference x,
           const _Allocator& alloc _RWSTD_DEFAULT_ARG (_Allocator()))
        : __imp (n, x, alloc) { }


#ifndef _RWSTD_NO_MEMBER_TEMPLATES

    template <class InputIterator>
    deque (InputIterator first, InputIterator last,
           const _Allocator& alloc _RWSTD_DEFAULT_ARG (_Allocator ()))
        : __imp (first, last, alloc) { }

#else   // if defined (_RWSTD_NO_MEMBER_TEMPLATES)

    deque (const_iterator first, const_iterator last,
           const _Allocator& alloc _RWSTD_DEFAULT_ARG(_Allocator()))
        : __imp (first, last, alloc) { }
    
    deque (const_pointer first, const_pointer last,
           const _Allocator& alloc _RWSTD_DEFAULT_ARG(_Allocator()))
        : __imp (first, last, alloc) { }


#ifdef _RWSTD_NO_DEFAULT_TEMPLATE_ARGS

    deque (const_iterator first, const_iterator last)
        : __imp (first, last) { }
    
    deque (const_pointer first, const_pointer last)
        : __imp (first, last) { }

#endif // _RWSTD_NO_DEFAULT_TEMPLATE_ARGS
#endif // _RWSTD_NO_MEMBER_TEMPLATES


    deque (const deque &x)
        : __imp (x.__imp) { }

    deque& operator= (const deque &x) {
        __imp = x.__imp;
        return *this;
    }


#ifndef _RWSTD_NO_MEMBER_TEMPLATES

    template<class InputIterator>
    void assign (InputIterator first, InputIterator last) {
        __imp.assign (first, last);
    }

#else   // if defined (_RWSTD_NO_MEMBER_TEMPLATES)

    void assign (const_iterator first, const_iterator last) {
        __imp.assign (first, last);
    }

    void assign (const_pointer first, const_pointer last) {
        __imp.assign (first, last);
    }

#endif // _RWSTD_NO_MEMBER_TEMPLATES


    void assign (size_type n, const_reference x) {
        __imp.assign (n, x);
    }

    allocator_type get_allocator () const
    {
      return __imp.get_allocator ();
    }

    iterator begin () {
        return __imp.begin ();
    }

    const_iterator begin () const {
        return __imp.begin ();
    }

    iterator end () {
        return __imp.end ();
    }

    const_iterator end () const {
        return __imp.end ();
    }

    reverse_iterator rbegin () {
        return reverse_iterator (end ());
    }

    const_reverse_iterator rbegin () const {
        return reverse_iterator (end ());
    }

    reverse_iterator rend () {
        return reverse_iterator (begin ());
    }

    const_reverse_iterator rend () const {
        return reverse_iterator (begin ());
    }

    bool empty () const {
        return __imp.empty ();
    }

    size_type size () const {
        return __imp.size ();
    }

    size_type max_size () const {
        return __imp.max_size ();
    }

    void resize (size_type new_size) {
        __imp.resize (new_size);
    }

    void resize (size_type new_size, const_reference x) {
        __imp.resize (new_size, x);
    }

    reference operator[] (size_type n) {
        return reference (__imp [n]);
    }

    const_reference operator[] (size_type n) const {
        return const_reference (__imp [n]);
    }

    const_reference at (size_type n) const {
        return __imp.at (n);
    }

    reference at (size_type n) {
        return __imp.at (n);
    }

    reference front () {
        return reference (__imp.front ());
    }

    const_reference front () const {
        return const_reference (__imp.front ());
    }

    reference back () {
        return reference (__imp.back ());
    }

    const_reference back () const {
        return const_reference (__imp.back ());
    }

    void push_front (const_reference x) {
        __imp.push_front (x);
    }

    void push_back (const_reference x) {
        __imp.push_back (x);
    }

    void pop_front () {
        __imp.pop_front ();
    }

    void pop_back () {
        __imp.pop_back ();
    }

    iterator insert (iterator pos, const_reference x) {
        return __imp.insert (pos, x);
    }


#ifndef _RWSTD_NO_MEMBER_TEMPLATES

    template <class InputIterator>
    void insert (iterator pos, InputIterator first, InputIterator last) {
        __imp.insert (pos, first, last);
    }

#else   // if defined (_RWSTD_NO_MEMBER_TEMPLATES)

    void insert (iterator pos, const_iterator first, const_iterator last) {
        __imp.insert (pos, first, last);
    }        

#endif // _RWSTD_NO_MEMBER_TEMPLATES


    void insert (iterator pos, size_type n, const_reference x) {
        __imp.insert (pos, n, x);
    }

    iterator erase (iterator pos) {
        return __imp.erase (pos);
    }

    iterator erase (iterator first, iterator last) {
        return __imp.erase (first, last);
    }

    void swap (deque &x) {
        __imp.swap (x.__imp);
    }

    void clear () {
        __imp.clear ();
    }
};

template <class _TypeT>
inline bool operator== (const deque <_TypeT*, allocator <_TypeT*> > &x,
                        const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return x.size () == y.size () && equal (x.begin (), x.end (), y.begin ());
}

template <class _TypeT>
inline bool operator< (const deque <_TypeT*, allocator <_TypeT*> > &x,
                       const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return lexicographical_compare (x.begin (), x.end (), y.begin (), y.end ());
}


#if !defined (_RWSTD_NO_NAMESPACE) || !defined (_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class _TypeT>
inline bool operator!= (const deque <_TypeT*, allocator <_TypeT*> > &x,
                        const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return !(x == y);
}

template <class _TypeT>
inline bool operator> (const deque <_TypeT*, allocator <_TypeT*> > &x,
                       const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return y < x;
}

template <class _TypeT>
inline bool operator>= (const deque <_TypeT*, allocator <_TypeT*> > &x,
                        const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return !(x < y);
}

template <class _TypeT>
inline bool operator<= (const deque <_TypeT*, allocator <_TypeT*> > &x,
                        const deque <_TypeT*, allocator <_TypeT*> > &y)
{
    return !(y <  x);
}

template <class _TypeT>
inline void swap (deque <_TypeT*, allocator <_TypeT*> > &a,
                  deque <_TypeT*, allocator <_TypeT*> > &b)
{
    a.swap(b);
}

#endif // !defined(_RWSTD_NO_NAMESPACE) || !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)


}   // namespace std


#endif /*__STD_DEQUE_SPEC__*/