// Profiling vector implementation -*- C++ -*-// Copyright (C) 2009, 2010 Free Software Foundation, Inc.//// This file is part of the GNU ISO C++ Library. This library is free// software; you can redistribute it and/or modify it under the// terms of the GNU General Public License as published by the// Free Software Foundation; either version 2, or (at your option)// any later version.// This library is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.// You should have received a copy of the GNU General Public License along// with this library; see the file COPYING. If not, write to the Free// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,// USA.// As a special exception, you may use this file as part of a free software// library without restriction. Specifically, if other files instantiate// templates or use macros or inline functions from this file, or you compile// this file and link it with other files to produce an executable, this// file does not by itself cause the resulting executable to be covered by// the GNU General Public License. This exception does not however// invalidate any other reasons why the executable file might be covered by// the GNU General Public License./** @file profile/vector* This file is a GNU profile extension to the Standard C++ Library.*/#ifndef _GLIBCXX_PROFILE_VECTOR#define _GLIBCXX_PROFILE_VECTOR 1#include <vector>#include <utility>#include <profile/base.h>#include <profile/iterator_tracker.h>namespace std{namespace __profile{template<typename _Tp,typename _Allocator = std::allocator<_Tp> >class vector: public _GLIBCXX_STD_PR::vector<_Tp, _Allocator>{typedef _GLIBCXX_STD_PR::vector<_Tp, _Allocator> _Base;public:typedef typename _Base::reference reference;typedef typename _Base::const_reference const_reference;typedef __iterator_tracker<typename _Base::iterator, vector>iterator;typedef __iterator_tracker<typename _Base::const_iterator, vector>const_iterator;typedef typename _Base::size_type size_type;typedef typename _Base::difference_type difference_type;typedef _Tp value_type;typedef _Allocator allocator_type;typedef typename _Base::pointer pointer;typedef typename _Base::const_pointer const_pointer;typedef std::reverse_iterator<iterator> reverse_iterator;typedef std::reverse_iterator<const_iterator> const_reverse_iterator;_Base&_M_base() { return *this; }const _Base&_M_base() const { return *this; }// 23.2.4.1 construct/copy/destroy:explicit vector(const _Allocator& __a = _Allocator()): _Base(__a){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}explicit vector(size_type __n, const _Tp& __value = _Tp(),const _Allocator& __a = _Allocator()): _Base(__n, __value, __a){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}template<class _InputIterator>vector(_InputIterator __first, _InputIterator __last,const _Allocator& __a = _Allocator()): _Base(__first, __last, __a){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}vector(const vector& __x): _Base(__x){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}/// Construction from a release-mode vectorvector(const _Base& __x): _Base(__x){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}#ifdef __GXX_EXPERIMENTAL_CXX0X__vector(vector&& __x): _Base(std::forward<vector>(__x)){__profcxx_vector_construct(this, this->capacity());__profcxx_vector_construct2(this);}vector(initializer_list<value_type> __l,const allocator_type& __a = allocator_type()): _Base(__l, __a) { }#endif~vector() {__profcxx_vector_destruct(this, this->capacity(), this->size());__profcxx_vector_destruct2(this);}vector&operator=(const vector& __x){static_cast<_Base&>(*this) = __x;return *this;}#ifdef __GXX_EXPERIMENTAL_CXX0X__vector&operator=(vector&& __x){// NB: DR 1204.// NB: DR 675.this->clear();this->swap(__x);return *this;}vector&operator=(initializer_list<value_type> __l){static_cast<_Base&>(*this) = __l;return *this;}#endifusing _Base::assign;using _Base::get_allocator;// iterators:iteratorbegin(){ return iterator(_Base::begin(), this); }const_iteratorbegin() const{ return const_iterator(_Base::begin(), this); }iteratorend(){ return iterator(_Base::end(), this); }const_iteratorend() const{ return const_iterator(_Base::end(), this); }reverse_iteratorrbegin(){ return reverse_iterator(end()); }const_reverse_iteratorrbegin() const{ return const_reverse_iterator(end()); }reverse_iteratorrend(){ return reverse_iterator(begin()); }const_reverse_iteratorrend() const{ return const_reverse_iterator(begin()); }#ifdef __GXX_EXPERIMENTAL_CXX0X__const_iteratorcbegin() const{ return const_iterator(_Base::begin(), this); }const_iteratorcend() const{ return const_iterator(_Base::end(), this); }const_reverse_iteratorcrbegin() const{ return const_reverse_iterator(end()); }const_reverse_iteratorcrend() const{ return const_reverse_iterator(begin()); }#endif// 23.2.4.2 capacity:using _Base::size;using _Base::max_size;voidresize(size_type __sz, _Tp __c = _Tp()){__profcxx_vector_invalid_operator(this);_M_profile_resize(this, this->capacity(), __sz);_Base::resize(__sz, __c);}#ifdef __GXX_EXPERIMENTAL_CXX0X__using _Base::shrink_to_fit;#endifusing _Base::empty;// element access:referenceoperator[](size_type __n){__profcxx_vector_invalid_operator(this);return _M_base()[__n];}const_referenceoperator[](size_type __n) const{__profcxx_vector_invalid_operator(this);return _M_base()[__n];}using _Base::at;referencefront(){return _Base::front();}const_referencefront() const{return _Base::front();}referenceback(){return _Base::back();}const_referenceback() const{return _Base::back();}// _GLIBCXX_RESOLVE_LIB_DEFECTS// DR 464. Suggestion for new member functions in standard containers.using _Base::data;// 23.2.4.3 modifiers:voidpush_back(const _Tp& __x){size_type __old_size = this->capacity();_Base::push_back(__x);_M_profile_resize(this, __old_size, this->capacity());}#ifdef __GXX_EXPERIMENTAL_CXX0X__voidpush_back(_Tp&& __x){size_type __old_size = this->capacity();_Base::push_back(__x);_M_profile_resize(this, __old_size, this->capacity());}#endifiteratorinsert(iterator __position, const _Tp& __x){__profcxx_vector_insert(this, __position.base() - _Base::begin(),this->size());size_type __old_size = this->capacity();typename _Base::iterator __res = _Base::insert(__position.base(), __x);_M_profile_resize(this, __old_size, this->capacity());return iterator(__res, this);}#ifdef __GXX_EXPERIMENTAL_CXX0X__iteratorinsert(iterator __position, _Tp&& __x){__profcxx_vector_insert(this, __position.base() - _Base::begin(),this->size());size_type __old_size = this->capacity();typename _Base::iterator __res = _Base::insert(__position.base(), __x);_M_profile_resize(this, __old_size, this->capacity());return iterator(__res, this);}voidinsert(iterator __position, initializer_list<value_type> __l){ this->insert(__position, __l.begin(), __l.end()); }#endif#ifdef __GXX_EXPERIMENTAL_CXX0X__voidswap(vector&& __x){_Base::swap(__x);}#endifvoidswap(vector& __x){_Base::swap(__x);}voidinsert(iterator __position, size_type __n, const _Tp& __x){__profcxx_vector_insert(this, __position.base() - _Base::begin(),this->size());size_type __old_size = this->capacity();_Base::insert(__position, __n, __x);_M_profile_resize(this, __old_size, this->capacity());}template<class _InputIterator>voidinsert(iterator __position,_InputIterator __first, _InputIterator __last){__profcxx_vector_insert(this, __position.base()-_Base::begin(),this->size());size_type __old_size = this->capacity();_Base::insert(__position, __first, __last);_M_profile_resize(this, __old_size, this->capacity());}iteratorerase(iterator __position){typename _Base::iterator __res = _Base::erase(__position.base());return iterator(__res, this);}iteratorerase(iterator __first, iterator __last){// _GLIBCXX_RESOLVE_LIB_DEFECTS// 151. can't currently clear() empty containertypename _Base::iterator __res = _Base::erase(__first.base(),__last.base());return iterator(__res, this);}voidclear(){__profcxx_vector_destruct(this, this->capacity(), this->size());__profcxx_vector_destruct2(this);_Base::clear();}inline void _M_profile_find() const{__profcxx_vector_find(this, size());}inline void _M_profile_iterate(int __rewind = 0) const{__profcxx_vector_iterate(this);}private:void _M_profile_resize(void* obj, size_type __old_size,size_type __new_size){if (__old_size < __new_size) {__profcxx_vector_resize(this, this->size(), __new_size);__profcxx_vector_resize2(this, this->size(), __new_size);}}};template<typename _Tp, typename _Alloc>inline booloperator==(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() == __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline booloperator!=(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() != __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline booloperator<(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() < __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline booloperator<=(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() <= __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline booloperator>=(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() >= __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline booloperator>(const vector<_Tp, _Alloc>& __lhs,const vector<_Tp, _Alloc>& __rhs){ return __lhs._M_base() > __rhs._M_base(); }template<typename _Tp, typename _Alloc>inline voidswap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs){ __lhs.swap(__rhs); }#ifdef __GXX_EXPERIMENTAL_CXX0X__template<typename _Tp, typename _Alloc>inline voidswap(vector<_Tp, _Alloc>&& __lhs, vector<_Tp, _Alloc>& __rhs){ __lhs.swap(__rhs); }template<typename _Tp, typename _Alloc>inline voidswap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>&& __rhs){ __lhs.swap(__rhs); }#endif} // namespace __profile#ifdef __GXX_EXPERIMENTAL_CXX0X__// DR 1182./// std::hash specialization for vector<bool>.template<typename _Alloc>struct hash<__profile::vector<bool, _Alloc>>: public std::unary_function<__profile::vector<bool, _Alloc>, size_t>{size_toperator()(const __profile::vector<bool, _Alloc>& __b) const{ return std::hash<_GLIBCXX_STD_D::vector<bool, _Alloc>>()(__b._M_base()); }};#endif} // namespace std#endif