1 /* 2 * Copyright (c) 2003 3 * Francois Dumont 4 * 5 * This material is provided "as is", with absolutely no warranty expressed 6 * or implied. Any use is at your own risk. 7 * 8 * Permission to use or copy this software for any purpose is hereby granted 9 * without fee, provided the above notices are retained on all copies. 10 * Permission to modify the code and to distribute modified code is granted, 11 * provided the above notices are retained, and a notice that the code was 12 * modified is included with the above copyright notice. 13 * 14 */ 15 16 /* NOTE: This is an internal header file, included by other STL headers. 17 * You should not attempt to use it directly. 18 */ 19 20 #ifndef _STLP_SPECIALIZED_VECTOR_H 21 #define _STLP_SPECIALIZED_VECTOR_H 22 23 #ifndef _STLP_POINTERS_SPEC_TOOLS_H 24 # include <stl/pointers/_tools.h> 25 #endif 26 27 _STLP_BEGIN_NAMESPACE 28 29 #define VECTOR_IMPL _STLP_PTR_IMPL_NAME(vector) 30 31 #if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) 32 _STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV _Vector_base<void*,allocator<void*> >; 33 _STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV VECTOR_IMPL<void*, allocator<void*> >; 34 #endif 35 36 #if defined (_STLP_DEBUG) 37 # define vector _STLP_NON_DBG_NAME(vector) 38 _STLP_MOVE_TO_PRIV_NAMESPACE 39 #endif 40 41 template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) > 42 class vector 43 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (vector) 44 : public __stlport_class<vector<_Tp, _Alloc> > 45 #endif 46 { 47 /* In the vector implementation iterators are pointer which give a number 48 * of opportunities for optimization. To not break those optimizations 49 * iterators passed to template should not be wrapped for casting purpose. 50 * So vector implementation will always use a qualified void pointer type and 51 * won't use iterator wrapping. 52 */ 53 typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_QualifiedType _StorageType; 54 typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc; 55 typedef _STLP_PRIV VECTOR_IMPL<_StorageType, _StorageTypeAlloc> _Base; 56 typedef vector<_Tp, _Alloc> _Self; 57 58 typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits; 59 60 public: 61 typedef _Tp value_type; 62 typedef value_type* pointer; 63 typedef const value_type* const_pointer; 64 typedef value_type* iterator; 65 typedef const value_type* const_iterator; 66 typedef value_type& reference; 67 typedef const value_type& const_reference; 68 typedef size_t size_type; 69 typedef ptrdiff_t difference_type; 70 typedef random_access_iterator_tag _Iterator_category; 71 72 _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS; 73 _STLP_FORCE_ALLOCATORS(value_type, _Alloc) 74 typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type; 75 76 allocator_type get_allocator() const 77 { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); } 78 79 iterator begin() { return cast_traits::to_value_type_ptr(_M_impl.begin()); } 80 const_iterator begin() const { return cast_traits::to_value_type_cptr(_M_impl.begin()); } 81 iterator end() { return cast_traits::to_value_type_ptr(_M_impl.end()); } 82 const_iterator end() const { return cast_traits::to_value_type_cptr(_M_impl.end()); } 83 84 reverse_iterator rbegin() { return reverse_iterator(end()); } 85 const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } 86 reverse_iterator rend() { return reverse_iterator(begin()); } 87 const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } 88 89 size_type size() const { return _M_impl.size(); } 90 size_type max_size() const { return _M_impl.max_size(); } 91 92 size_type capacity() const { return _M_impl.capacity(); } 93 bool empty() const { return _M_impl.empty(); } 94 95 reference operator[](size_type __n) { return cast_traits::to_value_type_ref(_M_impl[__n]); } 96 const_reference operator[](size_type __n) const { return cast_traits::to_value_type_cref(_M_impl[__n]); } 97 98 reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); } 99 const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); } 100 reference back() { return cast_traits::to_value_type_ref(_M_impl.back()); } 101 const_reference back() const { return cast_traits::to_value_type_cref(_M_impl.back()); } 102 103 reference at(size_type __n) { return cast_traits::to_value_type_ref(_M_impl.at(__n)); } 104 const_reference at(size_type __n) const { return cast_traits::to_value_type_cref(_M_impl.at(__n)); } 105 106 explicit vector(const allocator_type& __a = allocator_type()) 107 : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} 108 109 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) 110 explicit vector(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type), 111 #else 112 vector(size_type __n, const value_type& __val, 113 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/ 114 const allocator_type& __a = allocator_type()) 115 : _M_impl(__n, cast_traits::to_storage_type_cref(__val), 116 _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} 117 118 #if defined(_STLP_DONT_SUP_DFLT_PARAM) 119 explicit vector(size_type __n) 120 : _M_impl(__n, allocator_type() ) {} 121 #endif 122 123 vector(const _Self& __x) 124 : _M_impl(__x._M_impl) {} 125 126 #if !defined (_STLP_NO_MOVE_SEMANTIC) 127 explicit vector(__move_source<_Self> src) 128 : _M_impl(__move_source<_Base>(src.get()._M_impl)) {} 129 #endif 130 131 #if defined (_STLP_MEMBER_TEMPLATES) 132 template <class _InputIterator> 133 vector(_InputIterator __first, _InputIterator __last, 134 const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL ) 135 : _M_impl(__first, __last, 136 _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} 137 138 # if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS) 139 template <class _InputIterator> 140 vector(_InputIterator __first, _InputIterator __last) 141 : _M_impl(__first, __last) {} 142 # endif 143 144 #else 145 vector(const_iterator __first, const_iterator __last, 146 const allocator_type& __a = allocator_type()) 147 : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last), 148 _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {} 149 #endif /* _STLP_MEMBER_TEMPLATES */ 150 151 _Self& operator=(const _Self& __x) { _M_impl = __x._M_impl; return *this; } 152 153 void reserve(size_type __n) {_M_impl.reserve(__n);} 154 void assign(size_type __n, const value_type& __val) 155 { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); } 156 157 #if defined (_STLP_MEMBER_TEMPLATES) 158 template <class _InputIterator> 159 void assign(_InputIterator __first, _InputIterator __last) 160 { _M_impl.assign(__first, __last); } 161 #else 162 void assign(const_iterator __first, const_iterator __last) { 163 _M_impl.assign(cast_traits::to_storage_type_cptr(__first), 164 cast_traits::to_storage_type_cptr(__last)); 165 } 166 #endif /* _STLP_MEMBER_TEMPLATES */ 167 168 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) 169 void push_back(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) 170 #else 171 void push_back(const value_type& __x) 172 #endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ 173 { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); } 174 175 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) 176 iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) 177 #else 178 iterator insert(iterator __pos, const value_type& __x) 179 #endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ 180 { return cast_traits::to_value_type_ptr(_M_impl.insert(cast_traits::to_storage_type_ptr(__pos), 181 cast_traits::to_storage_type_cref(__x))); } 182 183 #if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS) 184 void push_back() { _M_impl.push_back(); } 185 iterator insert(iterator __pos) 186 { return _M_impl.insert(cast_traits::to_storage_type_ptr(__pos)); } 187 #endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/ 188 189 void swap(_Self& __x) { _M_impl.swap(__x._M_impl); } 190 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) 191 void _M_swap_workaround(_Self& __x) { swap(__x); } 192 #endif 193 194 #if defined (_STLP_MEMBER_TEMPLATES) 195 template <class _InputIterator> 196 void insert(iterator __pos, _InputIterator __first, _InputIterator __last) 197 { _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __first, __last); } 198 #else 199 void insert(iterator __pos, const_iterator __first, const_iterator __last) { 200 _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), cast_traits::to_storage_type_cptr(__first), 201 cast_traits::to_storage_type_cptr(__last)); 202 } 203 #endif 204 205 void insert (iterator __pos, size_type __n, const value_type& __x) { 206 _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __n, cast_traits::to_storage_type_cref(__x)); 207 } 208 209 void pop_back() {_M_impl.pop_back();} 210 iterator erase(iterator __pos) 211 {return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__pos)));} 212 iterator erase(iterator __first, iterator __last) { 213 return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__first), 214 cast_traits::to_storage_type_ptr(__last))); 215 } 216 217 #if !defined(_STLP_DONT_SUP_DFLT_PARAM) 218 void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type)) 219 #else 220 void resize(size_type __new_size, const value_type& __x) 221 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/ 222 { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); } 223 224 #if defined(_STLP_DONT_SUP_DFLT_PARAM) 225 void resize(size_type __new_size) { _M_impl.resize(__new_size); } 226 #endif /*_STLP_DONT_SUP_DFLT_PARAM*/ 227 228 void clear() { _M_impl.clear(); } 229 230 private: 231 _Base _M_impl; 232 }; 233 234 #if defined (vector) 235 # undef vector 236 _STLP_MOVE_TO_STD_NAMESPACE 237 #endif 238 239 #undef VECTOR_IMPL 240 241 _STLP_END_NAMESPACE 242 243 #endif /* _STLP_SPECIALIZED_VECTOR_H */ 244
