Line data Source code
1 : #ifndef VSET_VTREE_ARRAY_HPP
2 : #define VSET_VTREE_ARRAY_HPP
3 :
4 : #include <algorithm>
5 : #include <cstddef>
6 : #include <stdexcept>
7 : #include <iterator>
8 : //#include <fas/typemanip/remove_const.hpp>
9 :
10 : namespace vset{
11 :
12 : template<typename T, size_t N>
13 : class array
14 : {
15 : public:
16 : enum { dimension = N};
17 : typedef T value_type;
18 : //typedef typename fas::remove_const<T>::type data_type[N];
19 : typedef value_type data_type[N];
20 : typedef size_t size_type;
21 : typedef T& reference;
22 : typedef const T& const_reference;
23 : typedef T* pointer;
24 : typedef const T* const_pointer;
25 : typedef pointer iterator;
26 : typedef const_pointer const_iterator;
27 : typedef std::reverse_iterator<iterator> reverse_iterator;
28 : typedef const std::reverse_iterator<iterator> const_reverse_iterator;
29 : typedef std::ptrdiff_t difference_type;
30 :
31 1438 : array()
32 : : _size()
33 1438 : , _data()
34 : {
35 1438 : }
36 :
37 : reference operator[](size_type n)
38 : {
39 : return this->at(n);
40 : }
41 :
42 : const_reference operator[](size_type n) const
43 : {
44 : return this->at(n);
45 : }
46 :
47 128 : const_reference at ( size_type n ) const
48 : {
49 128 : if ( n < _size)
50 256 : return _data[n];
51 0 : throw std::out_of_range("array::at");
52 : }
53 :
54 21589 : reference at ( size_type n )
55 : {
56 21589 : if ( n < _size )
57 43178 : return _data[n];
58 0 : throw std::out_of_range("array::at");
59 : }
60 :
61 90596 : reference front ( )
62 : {
63 90596 : if ( _size==0 )
64 0 : throw std::out_of_range("array::at");
65 90596 : return _data[0];
66 : }
67 :
68 : const_reference front ( ) const
69 : {
70 : if ( _size==0 )
71 : throw std::out_of_range("array::at");
72 : return _data[0];
73 : }
74 :
75 72374 : reference back ( )
76 : {
77 72374 : if ( _size==0 )
78 0 : throw std::out_of_range("array::at");
79 72374 : return _data[_size-1];
80 : }
81 :
82 : const_reference back ( ) const
83 : {
84 : if ( _size==0 )
85 : throw std::out_of_range("array::at");
86 : return _data[_size-1];
87 : }
88 :
89 158919 : size_type size() const
90 : {
91 158919 : return _size;
92 : }
93 :
94 21356 : static size_type max_size()
95 : {
96 21356 : return N;
97 : }
98 :
99 13247 : static size_type capacity()
100 : {
101 13247 : return N;
102 : }
103 :
104 16856 : bool empty () const
105 : {
106 16856 : return _size==0;
107 : }
108 :
109 21356 : bool filled () const
110 : {
111 21356 : return _size == N;
112 : }
113 :
114 16918 : void resize ( size_type sz, T value = value_type() )
115 : {
116 16918 : if (sz > _size)
117 0 : std::fill_n( end(), sz - _size, value );
118 16918 : _size = sz;
119 16918 : }
120 :
121 : static void reserve ( size_type ) {}
122 :
123 : reverse_iterator rbegin()
124 : {
125 : return reverse_iterator(end());
126 : }
127 :
128 : const_reverse_iterator rbegin() const
129 : {
130 : return const_reverse_iterator( end() );
131 : }
132 :
133 : reverse_iterator rend()
134 : {
135 : return reverse_iterator( begin() );
136 : }
137 :
138 : const_reverse_iterator rend() const
139 : {
140 : return const_reverse_iterator( begin() );
141 : }
142 :
143 222924 : iterator begin()
144 : {
145 222924 : return _data;
146 : }
147 :
148 14 : const_iterator begin() const
149 : {
150 14 : return _data;
151 : }
152 :
153 176390 : iterator end()
154 : {
155 176390 : return _data + _size;
156 : }
157 :
158 14 : const_iterator end() const
159 : {
160 14 : return _data + _size;
161 : }
162 :
163 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
164 :
165 : const reverse_iterator crbegin() const
166 : {
167 : return const_reverse_iterator(cend());
168 : }
169 :
170 : const_reverse_iterator crend() const
171 : {
172 : return const_reverse_iterator( begin() );
173 : }
174 :
175 33720 : const_iterator cbegin() const
176 : {
177 33720 : return _data;
178 : }
179 :
180 33726 : const_iterator cend() const
181 : {
182 33726 : return _data + _size;
183 : }
184 :
185 : #endif
186 :
187 : iterator last()
188 : {
189 : return _data + _size - 1;
190 : }
191 :
192 : const_iterator last() const
193 : {
194 : return _data + _size - 1;
195 : }
196 :
197 : void clear()
198 : {
199 : _size = 0;
200 : }
201 :
202 : template <class InputIterator>
203 62 : void assign ( InputIterator f, InputIterator l )
204 : {
205 62 : std::copy( f, l, _data );
206 62 : _size = static_cast<size_t>(std::distance(f, l));
207 62 : }
208 :
209 : void assign ( size_type n, const T& u )
210 : {
211 : std::fill_n( begin(), n, u );
212 : _size = n;
213 : }
214 :
215 2432 : void push_back ( const T& x )
216 : {
217 2432 : _data[_size++] = x;
218 2432 : }
219 :
220 : void pop_back ( )
221 : {
222 : --_size;
223 : }
224 :
225 21356 : iterator insert ( iterator position, const T& x )
226 : {
227 21356 : if ( this->size() + 1 > this->max_size() )
228 0 : throw std::out_of_range("array::insert");
229 :
230 21356 : iterator first = position;
231 21356 : iterator l = this->end();
232 21356 : iterator d_last = l+1;
233 3924076 : while (first != l)
234 : {
235 3881364 : *(--d_last) = *(--l);
236 : }
237 :
238 21356 : *position = x;
239 21356 : ++_size;
240 21356 : return position;
241 : }
242 :
243 : void insert ( iterator position, size_type n, const T& x )
244 : {
245 : if ( this->size() + n > this->max_size() )
246 : throw std::out_of_range("array::insert");
247 : std::copy_backward(position, end(), end()+n);
248 : std::fill_n(position, n, x);
249 : _size+=n;
250 : }
251 :
252 : template <class InputIterator>
253 : void insert ( iterator position, InputIterator f, InputIterator l )
254 : {
255 : difference_type dist = std::distance(f,l);
256 : if (dist<=0)
257 : return;
258 : if ( this->size() + dist > this->max_size() )
259 : throw std::out_of_range("array::insert");
260 :
261 : std::copy_backward(position, end(), end()+dist );
262 : std::copy(f, l, position);
263 : _size+=dist;
264 : }
265 :
266 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
267 :
268 : iterator erase ( const_iterator position )
269 : {
270 : if ( position == this->cend() )
271 : throw std::out_of_range("iterator array<>::erase ( iterator position )");
272 :
273 : std::copy( position + 1, this->end(), position);
274 : this->resize( _size - 1 );
275 : return position;
276 : }
277 :
278 : #else
279 :
280 : iterator erase ( iterator position )
281 : {
282 : if ( position == this->end() )
283 : throw std::out_of_range("iterator array<>::erase ( iterator position )");
284 :
285 : std::copy( position + 1, this->end(), position);
286 : this->resize( _size - 1 );
287 : return position;
288 : }
289 :
290 : #endif
291 :
292 : iterator erase ( iterator f, iterator l )
293 : {
294 : difference_type dist = std::distance(f,l);;
295 : std::copy( l, this->end(), f);
296 : this->resize( _size - dist );
297 : return f;
298 : }
299 :
300 : private:
301 :
302 : size_type _size;
303 : data_type _data;
304 : };
305 :
306 : }
307 :
308 : #endif
|
