diff options
Diffstat (limited to 'misc/uClibc++/include/cxx/vector')
-rw-r--r-- | misc/uClibc++/include/cxx/vector | 517 |
1 files changed, 517 insertions, 0 deletions
diff --git a/misc/uClibc++/include/cxx/vector b/misc/uClibc++/include/cxx/vector new file mode 100644 index 000000000..8310bc14e --- /dev/null +++ b/misc/uClibc++/include/cxx/vector @@ -0,0 +1,517 @@ +/* Copyright (C) 2004 Garrett A. Kajmowicz + + This file is part of the uClibc++ Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +#include <basic_definitions> +#include <memory> +#include <iterator> +#include <func_exception> +#include <algorithm> +#include <type_traits> + + +#ifndef __STD_HEADER_VECTOR +#define __STD_HEADER_VECTOR + +#pragma GCC visibility push(default) + +namespace std{ + + template <class T, class Allocator = allocator<T> > class vector; + template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y); + template <class T, class Allocator> void swap(vector<T,Allocator>& x, vector<T,Allocator>& y); + + template <class T, class Allocator> class _UCXXEXPORT vector { + public: + + typedef typename Allocator::reference reference; + typedef typename Allocator::const_reference const_reference; + typedef typename Allocator::size_type size_type; + typedef typename Allocator::difference_type difference_type; + typedef typename Allocator::pointer pointer; + typedef typename Allocator::const_pointer const_pointer; + + typedef T* iterator; + typedef const T* const_iterator; + typedef T value_type; + typedef Allocator allocator_type; + typedef std::reverse_iterator<iterator> reverse_iterator; + typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + + explicit _UCXXEXPORT vector(const Allocator& al= Allocator()): data(0), //defaultValue(T()), + data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al) + { + data = a.allocate(data_size); + } + + explicit _UCXXEXPORT vector(size_type n, const T& value = T(), const Allocator& al= Allocator()) : + data(0), data_size(0), elements(0), a(al) + { + data_size = n + __UCLIBCXX_STL_BUFFER_SIZE__; + data = a.allocate(data_size); + + resize(n, value); + } + + template <class InputIterator> _UCXXEXPORT + vector(InputIterator first, InputIterator last, const Allocator& al = Allocator()): + data(0), data_size(__UCLIBCXX_STL_BUFFER_SIZE__), elements(0), a(al) + { + data = a.allocate(data_size); + assign(first, last); + } + + _UCXXEXPORT vector(const vector<T,Allocator>& x){ + a = x.a; + + elements = x.elements; + data_size = elements + __UCLIBCXX_STL_BUFFER_SIZE__; + data = a.allocate(data_size); + + for(size_type i = 0; i < elements; i++){ + a.construct(data+i, x.data[i]); + } + } + + _UCXXEXPORT ~vector(); //Below + + _UCXXEXPORT vector<T,Allocator>& operator=(const vector<T,Allocator>& x){ + if(&x == this){ + return *this; + } + + reserve(x.elements); //Make sure that we have enough actual memory + + + //Copy as many elements as possible + + size_t minElements = elements; + if(minElements > x.elements){ + minElements = x.elements; + } + for(size_t i = 0; i < minElements; ++i){ + data[i] = x.data[i]; + } + + //If we need to add new elements + if(elements < x.elements){ + for(size_t i = elements; i< x.elements; ++i){ + a.construct(data+i, x.data[i]); + ++elements; + } + } + + if(elements > x.elements){ + downsize(x.elements); + } + + return *this; + } + + template <class InputIterator> _UCXXEXPORT void assign(InputIterator first, InputIterator last){ + clear(); + insert(begin(), first, last); + } + + template <class Size, class U> _UCXXEXPORT void assign(Size n, const U& u = U()){ + clear(); + resize(n, u); + } + + inline allocator_type get_allocator() const{ + return a; + } + + inline iterator begin(){ + return data; + } + + inline const_iterator begin() const{ + return data; + } + + inline iterator end(){ + return (data + elements); + } + + inline const_iterator end() const{ + return (data + elements); + } + + inline reverse_iterator rbegin(){ + return reverse_iterator(end()); + } + + inline const_reverse_iterator rbegin() const{ + return const_reverse_iterator(end()); + } + + inline reverse_iterator rend(){ + return reverse_iterator(begin()); + } + + inline const_reverse_iterator rend() const{ + return const_reverse_iterator(begin()); + } + + inline size_type size() const{ + return elements; + } + + _UCXXEXPORT size_type max_size() const{ + return ((size_type)(-1)) / sizeof(T); + } + + void downsize(size_type sz); + void resize(size_type sz, const T & c = T()); + + inline size_type capacity() const{ + return data_size; + } + + inline bool empty() const{ + return (size() == 0); + } + + void reserve(size_type n); + + inline reference operator[](size_type n){ + return data[n]; + } + + inline const_reference operator[](size_type n) const{ + return data[n]; + } + + _UCXXEXPORT const_reference at(size_type n) const{ + if(n >= elements){ + __throw_out_of_range("Invalid subscript"); + } + return data[n]; + } + + _UCXXEXPORT reference at(size_type n){ + if(n >= elements){ + __throw_out_of_range("Invalid subscript"); + } + return data[n]; + } + + inline reference front(){ + return data[0]; + } + + inline const_reference front() const{ + return data[0]; + } + + inline reference back(){ + return data[ size() - 1]; + } + + inline const_reference back() const{ + return data[ size() - 1 ]; + } + + inline void push_back(const T& x){ + resize( size() + 1, x); + } + + inline void pop_back(){ + downsize(size() - 1); + } + + _UCXXEXPORT iterator insert(iterator position, const T& x = T()){ + size_type index = position - data; + resize(size() + 1, x); + for(size_type i = elements - 1; i > index; --i){ + data[i] = data[i-1]; + } + data[index] = x; + return (data + index); + } + + _UCXXEXPORT void _insert_fill(iterator position, size_type n, const T & x){ + size_type index = position - data; + resize(size() + n, x); + + for(size_type i = elements -1; (i > (index+n-1)); --i){ + data[i] = data[i-n]; + } + for(size_type i = 0; i < n; i++){ + data[i + index] = x; + } + } + + template <class InputIterator> _UCXXEXPORT + void _insert_from_iterator(iterator position, InputIterator first, InputIterator last) + { + T temp; + while(first !=last){ + temp = *first; + position = insert(position, temp); + ++position; + ++first; + } + } + + template <class InputIterator> + inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __true_type) + { + _insert_fill(position, first, last); + } + + template <class InputIterator> + inline void _dispatch_insert(iterator position, InputIterator first, InputIterator last, __false_type) + { + _insert_from_iterator(position, first, last); + } + + inline void insert(iterator position, size_type n, const T& x ){ + _insert_fill(position, n, x); + } + + template <class InputIterator> inline void insert(iterator position, InputIterator first, InputIterator last){ + typedef typename __is_integer<InputIterator>::value __some_type; + _dispatch_insert(position, first, last, __some_type()); + } + + _UCXXEXPORT iterator erase(iterator position){ + size_type index = position - data; + for(size_type i = index; i < (elements - 1); ++i){ + data[i] = data[i+1]; + } + downsize(size() - 1); + return (data + index); + } + + _UCXXEXPORT iterator erase(iterator first, iterator last){ + size_type index = first - data; + size_type width = last - first; + for(size_type i = index; i < (elements - width) ;++i){ + data[i] = data[i+width]; + } + downsize(size() - width); + return (data + index); + } + + _UCXXEXPORT void swap(vector<T,Allocator>& v){ + if(this == &v){ //Avoid dv.swap(v) + return; + } + T* ptr; + size_type temp; + + //Swap pointers first + ptr = data; + data = v.data; + v.data = ptr; + + //Swap element counts + temp = elements; + elements = v.elements; + v.elements = temp; + + //Swap data size + temp = data_size; + data_size = v.data_size; + v.data_size = temp; + } + + _UCXXEXPORT void clear(){ + downsize(0); + } + + protected: + T* data; + size_type data_size; + size_type elements; + Allocator a; + }; + + + + //Here go template instantiations + + template<class T, class Allocator> _UCXXEXPORT vector<T, Allocator>::~vector(){ + for(size_t i = 0; i < elements; ++i){ + a.destroy(data + i); + } + a.deallocate(data, data_size); + } + + + template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::reserve(size_type n){ + if(n > data_size){ //We never shrink... + T * temp_ptr = data; + size_type temp_size = data_size; + + data_size = n; + data = a.allocate(data_size); + + for(size_type i = 0; i<elements; ++i){ + a.construct(data+i, temp_ptr[i]); + a.destroy(temp_ptr+i); + } + a.deallocate(temp_ptr, temp_size); + } + } + + template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::resize(size_type sz, const T & c){ + if(sz > elements){ //Need to actually call constructor + if(sz > data_size){ + reserve(sz + __UCLIBCXX_STL_BUFFER_SIZE__); + } + + for(size_type i = elements; i<sz ; ++i){ + a.construct(data+i, c); + } + elements = sz; + }else{ + downsize(sz); + } + } + + template<class T, class Allocator> _UCXXEXPORT void vector<T, Allocator>::downsize(size_type sz){ + if(sz < elements){ //Actually are downsizing + for(size_t i = sz; i< elements; ++i){ + a.destroy(data+i); + } + elements = sz; + } + } + + +#ifndef __UCLIBCXX_COMPILE_VECTOR__ +#ifdef __UCLIBCXX_EXPAND_VECTOR_BASIC__ + + +#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__ + template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al); + template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al); + + template<> _UCXXEXPORT vector<char, allocator<char> >::~vector(); + template<> _UCXXEXPORT vector<unsigned char, allocator<unsigned char> >::~vector(); + +#endif //__UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__ + + template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<unsigned char, allocator<unsigned char> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<short int, allocator<short int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<unsigned short int, allocator<unsigned short int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<int, allocator<int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<long int, allocator<long int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<unsigned long int, allocator<unsigned long int> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<float, allocator<float> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<double, allocator<double> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<bool, allocator<bool> >::reserve(size_type n); + + template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c); + template<> _UCXXEXPORT void + vector<unsigned char, allocator<unsigned char> >::resize(size_type sz, const unsigned char & c); + template<> _UCXXEXPORT void vector<short int, allocator<short int> >::resize(size_type sz, const short & c); + template<> _UCXXEXPORT void + vector<unsigned short int, allocator<unsigned short int> >::resize(size_type sz, const unsigned short int & c); + template<> _UCXXEXPORT void vector<int, allocator<int> >::resize(size_type sz, const int & c); + template<> _UCXXEXPORT void vector<unsigned int, allocator<unsigned int> >::resize(size_type sz, const unsigned int & c); + template<> _UCXXEXPORT void vector<long int, allocator<long int> >::resize(size_type sz, const long int & c); + template<> _UCXXEXPORT void + vector<unsigned long int, allocator<unsigned long int> >::resize(size_type sz, const unsigned long int & c); + template<> _UCXXEXPORT void vector<float, allocator<float> >::resize(size_type sz, const float & c); + template<> _UCXXEXPORT void vector<double, allocator<double> >::resize(size_type sz, const double & c); + template<> _UCXXEXPORT void vector<bool, allocator<bool> >::resize(size_type sz, const bool & c); + +#elif defined __UCLIBCXX_EXPAND_STRING_CHAR__ + +#ifdef __UCLIBCXX_EXPAND_CONSTRUCTORS_DESTRUCTORS__ + + template<> _UCXXEXPORT vector<char, allocator<char> >::vector(const allocator<char>& al); + template<> _UCXXEXPORT vector<char, allocator<char> >::vector(size_type n, const char & value, const allocator<char> & al); + template<> _UCXXEXPORT vector<char, allocator<char> >::~vector(); + +#endif + + template<> _UCXXEXPORT void vector<char, allocator<char> >::reserve(size_type n); + template<> _UCXXEXPORT void vector<char, allocator<char> >::resize(size_type sz, const char & c); + +#endif +#endif + + + + template <class T, class Allocator> _UCXXEXPORT bool + operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + if(x.size() !=y.size() ){ + return false; + } + for(size_t i = 0; i < x.size(); ++i){ + if(x[i] != y[i]){ + return false; + } + } + return true; + } + + template <class T, class Allocator> _UCXXEXPORT bool + operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + less<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c; + return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c); + } + template <class T, class Allocator> _UCXXEXPORT bool + operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + return !(x == y); + } + template <class T, class Allocator> _UCXXEXPORT bool + operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + greater<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c; + return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c); + } + template <class T, class Allocator> _UCXXEXPORT bool + operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + greater_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c; + return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c); + } + template <class T, class Allocator> _UCXXEXPORT bool + operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y) + { + less_equal<typename iterator_traits<typename vector<T,Allocator>::iterator >::value_type> c; + return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end(), c); + } + + template <class T, class Allocator> _UCXXEXPORT void swap(vector<T,Allocator>& x, vector<T,Allocator>& y){ + x.swap(y); + } + +} + +#pragma GCC visibility pop + +#endif + |