first commit

extern/stdcxx/4.2.1/include/deque_spec.h

@@ -0,0 +1,622 @@
+// -*- 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__*/