623 lines
16 KiB
C++
623 lines
16 KiB
C++
// -*- 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__*/
|