/* * * 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. * * * Copyright (c) 1996 * Silicon Graphics Computer Systems, Inc. * * 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.  Silicon Graphics makes no * representations about the suitability of this software for any * purpose.  It is provided "as is" without express or implied warranty. *//* NOTE: This is an internal header file, included by other STL headers. *   You should not attempt to use it directly. */#ifndef __SGI_STL_INTERNAL_VECTOR_H#define __SGI_STL_INTERNAL_VECTOR_H#include <concept_checks.h>__STL_BEGIN_NAMESPACE #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)#pragma set woff 1174#pragma set woff 1375#endif// The vector base class serves two purposes.  First, its constructor// and destructor allocate (but don't initialize) storage.  This makes// exception safety easier.  Second, the base class encapsulates all of// the differences between SGI-style allocators and standard-conforming// allocators.#ifdef __STL_USE_STD_ALLOCATORS// Base class for ordinary allocators.template <class _Tp, class _Allocator, bool _IsStatic>class _Vector_alloc_base {public:  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type          allocator_type;  allocator_type get_allocator() const { return _M_data_allocator; }  _Vector_alloc_base(const allocator_type& __a)    : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)   {}  protected:  allocator_type _M_data_allocator;  _Tp* _M_start;  _Tp* _M_finish;  _Tp* _M_end_of_storage;  _Tp* _M_allocate(size_t __n)    { return _M_data_allocator.allocate(__n); }  void _M_deallocate(_Tp* __p, size_t __n)    { if (__p) _M_data_allocator.deallocate(__p, __n); }};// Specialization for allocators that have the property that we don't// actually have to store an allocator object.  template <class _Tp, class _Allocator>class _Vector_alloc_base<_Tp, _Allocator, true> {public:  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type          allocator_type;  allocator_type get_allocator() const { return allocator_type(); }  _Vector_alloc_base(const allocator_type&)    : _M_start(0), _M_finish(0), _M_end_of_storage(0)   {}  protected:  _Tp* _M_start;  _Tp* _M_finish;  _Tp* _M_end_of_storage;  typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;  _Tp* _M_allocate(size_t __n)    { return _Alloc_type::allocate(__n); }  void _M_deallocate(_Tp* __p, size_t __n)    { _Alloc_type::deallocate(__p, __n);}};template <class _Tp, class _Alloc>struct _Vector_base  : public _Vector_alloc_base<_Tp, _Alloc,                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>{  typedef _Vector_alloc_base<_Tp, _Alloc,                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>          _Base;  typedef typename _Base::allocator_type allocator_type;  _Vector_base(const allocator_type& __a) : _Base(__a) {}  _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) {    _M_start = _M_allocate(__n);    _M_finish = _M_start;    _M_end_of_storage = _M_start + __n;  }  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }};    #else /* __STL_USE_STD_ALLOCATORS */template <class _Tp, class _Alloc> class _Vector_base {public:  typedef _Alloc allocator_type;  allocator_type get_allocator() const { return allocator_type(); }  _Vector_base(const _Alloc&)    : _M_start(0), _M_finish(0), _M_end_of_storage(0) {}  _Vector_base(size_t __n, const _Alloc&)    : _M_start(0), _M_finish(0), _M_end_of_storage(0)   {    _M_start = _M_allocate(__n);    _M_finish = _M_start;    _M_end_of_storage = _M_start + __n;  }  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }protected:  _Tp* _M_start;  _Tp* _M_finish;  _Tp* _M_end_of_storage;  typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;  _Tp* _M_allocate(size_t __n)    { return _M_data_allocator::allocate(__n); }  void _M_deallocate(_Tp* __p, size_t __n)     { _M_data_allocator::deallocate(__p, __n); }};#endif /* __STL_USE_STD_ALLOCATORS */template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >class vector : protected _Vector_base<_Tp, _Alloc> {  // requirements:  __STL_CLASS_REQUIRES(_Tp, _Assignable);private:  typedef _Vector_base<_Tp, _Alloc> _Base;public:  typedef _Tp value_type;  typedef value_type* pointer;  typedef const value_type* const_pointer;  typedef value_type* iterator;  typedef const value_type* const_iterator;  typedef value_type& reference;  typedef const value_type& const_reference;  typedef size_t size_type;  typedef ptrdiff_t difference_type;  typedef typename _Base::allocator_type allocator_type;  allocator_type get_allocator() const { return _Base::get_allocator(); }#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION  typedef reverse_iterator<const_iterator> const_reverse_iterator;  typedef reverse_iterator<iterator> reverse_iterator;#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */  typedef reverse_iterator<const_iterator, value_type, const_reference,                            difference_type>  const_reverse_iterator;  typedef reverse_iterator<iterator, value_type, reference, difference_type>          reverse_iterator;#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */protected:#ifdef __STL_HAS_NAMESPACES  using _Base::_M_allocate;  using _Base::_M_deallocate;  using _Base::_M_start;  using _Base::_M_finish;  using _Base::_M_end_of_storage;#endif /* __STL_HAS_NAMESPACES */protected:  void _M_insert_aux(iterator __position, const _Tp& __x);  void _M_insert_aux(iterator __position);public:  iterator begin() { return _M_start; }  const_iterator begin() const { return _M_start; }  iterator end() { return _M_finish; }  const_iterator end() const { return _M_finish; }  reverse_iterator rbegin()    { return reverse_iterator(end()); }  const_reverse_iterator rbegin() const    { return const_reverse_iterator(end()); }  reverse_iterator rend()    { return reverse_iterator(begin()); }  const_reverse_iterator rend() const    { return const_reverse_iterator(begin()); }  size_type size() const    { return size_type(end() - begin()); }  size_type max_size() const    { return size_type(-1) / sizeof(_Tp); }  size_type capacity() const    { return size_type(_M_end_of_storage - begin()); }  bool empty() const    { return begin() == end(); }  reference operator[](size_type __n) { return *(begin() + __n); }  const_reference operator[](size_type __n) const { return *(begin() + __n); }#ifdef __STL_THROW_RANGE_ERRORS  void _M_range_check(size_type __n) const {    if (__n >= this->size())      __stl_throw_range_error("vector");  }  reference at(size_type __n)    { _M_range_check(__n); return (*this)[__n]; }  const_reference at(size_type __n) const    { _M_range_check(__n); return (*this)[__n]; }#endif /* __STL_THROW_RANGE_ERRORS */  explicit vector(const allocator_type& __a = allocator_type())    : _Base(__a) {}  vector(size_type __n, const _Tp& __value,         const allocator_type& __a = allocator_type())     : _Base(__n, __a)    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }  explicit vector(size_type __n)    : _Base(__n, allocator_type())    { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }  vector(const vector<_Tp, _Alloc>& __x)     : _Base(__x.size(), __x.get_allocator())    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }#ifdef __STL_MEMBER_TEMPLATES  // Check whether it's an integral type.  If so, it's not an iterator.  template <class _InputIterator>  vector(_InputIterator __first, _InputIterator __last,         const allocator_type& __a = allocator_type()) : _Base(__a) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_initialize_aux(__first, __last, _Integral());  }  template <class _Integer>  void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {    _M_start = _M_allocate(__n);    _M_end_of_storage = _M_start + __n;     _M_finish = uninitialized_fill_n(_M_start, __n, __value);  }  template <class _InputIterator>  void _M_initialize_aux(_InputIterator __first, _InputIterator __last,                         __false_type) {    _M_range_initialize(__first, __last, __ITERATOR_CATEGORY(__first));  }#else  vector(const _Tp* __first, const _Tp* __last,         const allocator_type& __a = allocator_type())    : _Base(__last - __first, __a)     { _M_finish = uninitialized_copy(__first, __last, _M_start); }#endif /* __STL_MEMBER_TEMPLATES */  ~vector() { destroy(_M_start, _M_finish); }  vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);  void reserve(size_type __n) {    if (capacity() < __n) {      const size_type __old_size = size();      iterator __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);      destroy(_M_start, _M_finish);      _M_deallocate(_M_start, _M_end_of_storage - _M_start);      _M_start = __tmp;      _M_finish = __tmp + __old_size;      _M_end_of_storage = _M_start + __n;    }  }  // assign(), a generalized assignment member function.  Two  // versions: one that takes a count, and one that takes a range.  // The range version is a member template, so we dispatch on whether  // or not the type is an integer.  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }  void _M_fill_assign(size_type __n, const _Tp& __val);#ifdef __STL_MEMBER_TEMPLATES    template <class _InputIterator>  void assign(_InputIterator __first, _InputIterator __last) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_assign_dispatch(__first, __last, _Integral());  }  template <class _Integer>  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)    { _M_fill_assign((size_type) __n, (_Tp) __val); }  template <class _InputIter>  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)    { _M_assign_aux(__first, __last, __ITERATOR_CATEGORY(__first)); }  template <class _InputIterator>  void _M_assign_aux(_InputIterator __first, _InputIterator __last,                     input_iterator_tag);  template <class _ForwardIterator>  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,                     forward_iterator_tag); #endif /* __STL_MEMBER_TEMPLATES */  reference front() { return *begin(); }  const_reference front() const { return *begin(); }  reference back() { return *(end() - 1); }  const_reference back() const { return *(end() - 1); }  void push_back(const _Tp& __x) {    if (_M_finish != _M_end_of_storage) {      construct(_M_finish, __x);      ++_M_finish;    }    else      _M_insert_aux(end(), __x);  }  void push_back() {    if (_M_finish != _M_end_of_storage) {      construct(_M_finish);      ++_M_finish;    }    else      _M_insert_aux(end());  }  void swap(vector<_Tp, _Alloc>& __x) {    __STD::swap(_M_start, __x._M_start);    __STD::swap(_M_finish, __x._M_finish);    __STD::swap(_M_end_of_storage, __x._M_end_of_storage);  }  iterator insert(iterator __position, const _Tp& __x) {    size_type __n = __position - begin();    if (_M_finish != _M_end_of_storage && __position == end()) {      construct(_M_finish, __x);      ++_M_finish;    }    else      _M_insert_aux(__position, __x);    return begin() + __n;  }  iterator insert(iterator __position) {    size_type __n = __position - begin();    if (_M_finish != _M_end_of_storage && __position == end()) {      construct(_M_finish);      ++_M_finish;    }    else      _M_insert_aux(__position);    return begin() + __n;  }#ifdef __STL_MEMBER_TEMPLATES  // Check whether it's an integral type.  If so, it's not an iterator.  template <class _InputIterator>  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;    _M_insert_dispatch(__pos, __first, __last, _Integral());  }  template <class _Integer>  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,                          __true_type)    { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); }  template <class _InputIterator>  void _M_insert_dispatch(iterator __pos,                          _InputIterator __first, _InputIterator __last,                          __false_type) {    _M_range_insert(__pos, __first, __last, __ITERATOR_CATEGORY(__first));  }#else /* __STL_MEMBER_TEMPLATES */  void insert(iterator __position,              const_iterator __first, const_iterator __last);#endif /* __STL_MEMBER_TEMPLATES */  void insert (iterator __pos, size_type __n, const _Tp& __x)    { _M_fill_insert(__pos, __n, __x); }  void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x);  void pop_back() {    --_M_finish;    destroy(_M_finish);  }  iterator erase(iterator __position) {    if (__position + 1 != end())      copy(__position + 1, _M_finish, __position);    --_M_finish;    destroy(_M_finish);    return __position;  }  iterator erase(iterator __first, iterator __last) {    iterator __i = copy(__last, _M_finish, __first);    destroy(__i, _M_finish);    _M_finish = _M_finish - (__last - __first);    return __first;  }  void resize(size_type __new_size, const _Tp& __x) {    if (__new_size < size())       erase(begin() + __new_size, end());    else      insert(end(), __new_size - size(), __x);  }  void resize(size_type __new_size) { resize(__new_size, _Tp()); }  void clear() { erase(begin(), end()); }