]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* The following code declares class array, |
2 | * an STL container (as wrapper) for arrays of constant size. | |
3 | * | |
4 | * See | |
5 | * http://www.boost.org/libs/array/ | |
6 | * for documentation. | |
7 | * | |
8 | * The original author site is at: http://www.josuttis.com/ | |
9 | * | |
10 | * (C) Copyright Nicolai M. Josuttis 2001. | |
11 | * | |
12 | * Distributed under the Boost Software License, Version 1.0. (See | |
13 | * accompanying file LICENSE_1_0.txt or copy at | |
14 | * http://www.boost.org/LICENSE_1_0.txt) | |
15 | * | |
16 | * 14 Apr 2012 - (mtc) Added support for boost::hash | |
17 | * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility. | |
18 | * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group. | |
19 | * See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168 | |
20 | * Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow) | |
21 | * 10 Mar 2010 - added workaround for SUNCC and !STLPort [trac #3893] (Marshall Clow) | |
22 | * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis) | |
23 | * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries. | |
24 | * 05 Aug 2001 - minor update (Nico Josuttis) | |
25 | * 20 Jan 2001 - STLport fix (Beman Dawes) | |
26 | * 29 Sep 2000 - Initial Revision (Nico Josuttis) | |
27 | * | |
28 | * Jan 29, 2004 | |
29 | */ | |
30 | #ifndef BOOST_ARRAY_HPP | |
31 | #define BOOST_ARRAY_HPP | |
32 | ||
33 | #include <boost/detail/workaround.hpp> | |
34 | ||
35 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
36 | # pragma warning(push) | |
37 | # pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe | |
38 | # pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated | |
39 | # pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required | |
40 | #endif | |
41 | ||
42 | #include <cstddef> | |
43 | #include <stdexcept> | |
44 | #include <boost/assert.hpp> | |
45 | #include <boost/swap.hpp> | |
46 | ||
47 | // Handles broken standard libraries better than <iterator> | |
48 | #include <boost/detail/iterator.hpp> | |
49 | #include <boost/throw_exception.hpp> | |
50 | #include <boost/functional/hash_fwd.hpp> | |
51 | #include <algorithm> | |
52 | ||
53 | // FIXES for broken compilers | |
54 | #include <boost/config.hpp> | |
55 | ||
56 | ||
57 | namespace boost { | |
58 | ||
59 | template<class T, std::size_t N> | |
60 | class array { | |
61 | public: | |
62 | T elems[N]; // fixed-size array of elements of type T | |
63 | ||
64 | public: | |
65 | // type definitions | |
66 | typedef T value_type; | |
67 | typedef T* iterator; | |
68 | typedef const T* const_iterator; | |
69 | typedef T& reference; | |
70 | typedef const T& const_reference; | |
71 | typedef std::size_t size_type; | |
72 | typedef std::ptrdiff_t difference_type; | |
73 | ||
74 | // iterator support | |
75 | iterator begin() { return elems; } | |
76 | const_iterator begin() const { return elems; } | |
77 | const_iterator cbegin() const { return elems; } | |
78 | ||
79 | iterator end() { return elems+N; } | |
80 | const_iterator end() const { return elems+N; } | |
81 | const_iterator cend() const { return elems+N; } | |
82 | ||
83 | // reverse iterator support | |
84 | #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) | |
85 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
86 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
87 | #elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310) | |
88 | // workaround for broken reverse_iterator in VC7 | |
89 | typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator, | |
90 | reference, iterator, reference> > reverse_iterator; | |
91 | typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator, | |
92 | const_reference, iterator, reference> > const_reverse_iterator; | |
93 | #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) | |
94 | typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, | |
95 | value_type, reference, iterator, difference_type> reverse_iterator; | |
96 | typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag, | |
97 | value_type, const_reference, const_iterator, difference_type> const_reverse_iterator; | |
98 | #else | |
99 | // workaround for broken reverse_iterator implementations | |
100 | typedef std::reverse_iterator<iterator,T> reverse_iterator; | |
101 | typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator; | |
102 | #endif | |
103 | ||
104 | reverse_iterator rbegin() { return reverse_iterator(end()); } | |
105 | const_reverse_iterator rbegin() const { | |
106 | return const_reverse_iterator(end()); | |
107 | } | |
108 | const_reverse_iterator crbegin() const { | |
109 | return const_reverse_iterator(end()); | |
110 | } | |
111 | ||
112 | reverse_iterator rend() { return reverse_iterator(begin()); } | |
113 | const_reverse_iterator rend() const { | |
114 | return const_reverse_iterator(begin()); | |
115 | } | |
116 | const_reverse_iterator crend() const { | |
117 | return const_reverse_iterator(begin()); | |
118 | } | |
119 | ||
120 | // operator[] | |
121 | reference operator[](size_type i) | |
122 | { | |
123 | BOOST_ASSERT_MSG( i < N, "out of range" ); | |
124 | return elems[i]; | |
125 | } | |
126 | ||
127 | const_reference operator[](size_type i) const | |
128 | { | |
129 | BOOST_ASSERT_MSG( i < N, "out of range" ); | |
130 | return elems[i]; | |
131 | } | |
132 | ||
133 | // at() with range check | |
134 | reference at(size_type i) { rangecheck(i); return elems[i]; } | |
135 | const_reference at(size_type i) const { rangecheck(i); return elems[i]; } | |
136 | ||
137 | // front() and back() | |
138 | reference front() | |
139 | { | |
140 | return elems[0]; | |
141 | } | |
142 | ||
143 | const_reference front() const | |
144 | { | |
145 | return elems[0]; | |
146 | } | |
147 | ||
148 | reference back() | |
149 | { | |
150 | return elems[N-1]; | |
151 | } | |
152 | ||
153 | const_reference back() const | |
154 | { | |
155 | return elems[N-1]; | |
156 | } | |
157 | ||
158 | // size is constant | |
159 | static size_type size() { return N; } | |
160 | static bool empty() { return false; } | |
161 | static size_type max_size() { return N; } | |
162 | enum { static_size = N }; | |
163 | ||
164 | // swap (note: linear complexity) | |
165 | void swap (array<T,N>& y) { | |
166 | for (size_type i = 0; i < N; ++i) | |
167 | boost::swap(elems[i],y.elems[i]); | |
168 | } | |
169 | ||
170 | // direct access to data (read-only) | |
171 | const T* data() const { return elems; } | |
172 | T* data() { return elems; } | |
173 | ||
174 | // use array as C array (direct read/write access to data) | |
175 | T* c_array() { return elems; } | |
176 | ||
177 | // assignment with type conversion | |
178 | template <typename T2> | |
179 | array<T,N>& operator= (const array<T2,N>& rhs) { | |
180 | std::copy(rhs.begin(),rhs.end(), begin()); | |
181 | return *this; | |
182 | } | |
183 | ||
184 | // assign one value to all elements | |
185 | void assign (const T& value) { fill ( value ); } // A synonym for fill | |
186 | void fill (const T& value) | |
187 | { | |
188 | std::fill_n(begin(),size(),value); | |
189 | } | |
190 | ||
191 | // check range (may be private because it is static) | |
192 | static void rangecheck (size_type i) { | |
193 | if (i >= size()) { | |
194 | std::out_of_range e("array<>: index out of range"); | |
195 | boost::throw_exception(e); | |
196 | } | |
197 | } | |
198 | ||
199 | }; | |
200 | ||
201 | #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) | |
202 | template< class T > | |
203 | class array< T, 0 > { | |
204 | ||
205 | public: | |
206 | // type definitions | |
207 | typedef T value_type; | |
208 | typedef T* iterator; | |
209 | typedef const T* const_iterator; | |
210 | typedef T& reference; | |
211 | typedef const T& const_reference; | |
212 | typedef std::size_t size_type; | |
213 | typedef std::ptrdiff_t difference_type; | |
214 | ||
215 | // iterator support | |
216 | iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); } | |
217 | const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); } | |
218 | const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); } | |
219 | ||
220 | iterator end() { return begin(); } | |
221 | const_iterator end() const { return begin(); } | |
222 | const_iterator cend() const { return cbegin(); } | |
223 | ||
224 | // reverse iterator support | |
225 | #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) | |
226 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
227 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
228 | #elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310) | |
229 | // workaround for broken reverse_iterator in VC7 | |
230 | typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator, | |
231 | reference, iterator, reference> > reverse_iterator; | |
232 | typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator, | |
233 | const_reference, iterator, reference> > const_reverse_iterator; | |
234 | #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) | |
235 | typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, | |
236 | value_type, reference, iterator, difference_type> reverse_iterator; | |
237 | typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag, | |
238 | value_type, const_reference, const_iterator, difference_type> const_reverse_iterator; | |
239 | #else | |
240 | // workaround for broken reverse_iterator implementations | |
241 | typedef std::reverse_iterator<iterator,T> reverse_iterator; | |
242 | typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator; | |
243 | #endif | |
244 | ||
245 | reverse_iterator rbegin() { return reverse_iterator(end()); } | |
246 | const_reverse_iterator rbegin() const { | |
247 | return const_reverse_iterator(end()); | |
248 | } | |
249 | const_reverse_iterator crbegin() const { | |
250 | return const_reverse_iterator(end()); | |
251 | } | |
252 | ||
253 | reverse_iterator rend() { return reverse_iterator(begin()); } | |
254 | const_reverse_iterator rend() const { | |
255 | return const_reverse_iterator(begin()); | |
256 | } | |
257 | const_reverse_iterator crend() const { | |
258 | return const_reverse_iterator(begin()); | |
259 | } | |
260 | ||
261 | // operator[] | |
262 | reference operator[](size_type /*i*/) | |
263 | { | |
264 | return failed_rangecheck(); | |
265 | } | |
266 | ||
267 | const_reference operator[](size_type /*i*/) const | |
268 | { | |
269 | return failed_rangecheck(); | |
270 | } | |
271 | ||
272 | // at() with range check | |
273 | reference at(size_type /*i*/) { return failed_rangecheck(); } | |
274 | const_reference at(size_type /*i*/) const { return failed_rangecheck(); } | |
275 | ||
276 | // front() and back() | |
277 | reference front() | |
278 | { | |
279 | return failed_rangecheck(); | |
280 | } | |
281 | ||
282 | const_reference front() const | |
283 | { | |
284 | return failed_rangecheck(); | |
285 | } | |
286 | ||
287 | reference back() | |
288 | { | |
289 | return failed_rangecheck(); | |
290 | } | |
291 | ||
292 | const_reference back() const | |
293 | { | |
294 | return failed_rangecheck(); | |
295 | } | |
296 | ||
297 | // size is constant | |
298 | static size_type size() { return 0; } | |
299 | static bool empty() { return true; } | |
300 | static size_type max_size() { return 0; } | |
301 | enum { static_size = 0 }; | |
302 | ||
303 | void swap (array<T,0>& /*y*/) { | |
304 | } | |
305 | ||
306 | // direct access to data (read-only) | |
307 | const T* data() const { return 0; } | |
308 | T* data() { return 0; } | |
309 | ||
310 | // use array as C array (direct read/write access to data) | |
311 | T* c_array() { return 0; } | |
312 | ||
313 | // assignment with type conversion | |
314 | template <typename T2> | |
315 | array<T,0>& operator= (const array<T2,0>& ) { | |
316 | return *this; | |
317 | } | |
318 | ||
319 | // assign one value to all elements | |
320 | void assign (const T& value) { fill ( value ); } | |
321 | void fill (const T& ) {} | |
322 | ||
323 | // check range (may be private because it is static) | |
324 | static reference failed_rangecheck () { | |
325 | std::out_of_range e("attempt to access element of an empty array"); | |
326 | boost::throw_exception(e); | |
327 | #if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__)) | |
328 | // | |
329 | // We need to return something here to keep | |
330 | // some compilers happy: however we will never | |
331 | // actually get here.... | |
332 | // | |
333 | static T placeholder; | |
334 | return placeholder; | |
335 | #endif | |
336 | } | |
337 | }; | |
338 | #endif | |
339 | ||
340 | // comparisons | |
341 | template<class T, std::size_t N> | |
342 | bool operator== (const array<T,N>& x, const array<T,N>& y) { | |
343 | return std::equal(x.begin(), x.end(), y.begin()); | |
344 | } | |
345 | template<class T, std::size_t N> | |
346 | bool operator< (const array<T,N>& x, const array<T,N>& y) { | |
347 | return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end()); | |
348 | } | |
349 | template<class T, std::size_t N> | |
350 | bool operator!= (const array<T,N>& x, const array<T,N>& y) { | |
351 | return !(x==y); | |
352 | } | |
353 | template<class T, std::size_t N> | |
354 | bool operator> (const array<T,N>& x, const array<T,N>& y) { | |
355 | return y<x; | |
356 | } | |
357 | template<class T, std::size_t N> | |
358 | bool operator<= (const array<T,N>& x, const array<T,N>& y) { | |
359 | return !(y<x); | |
360 | } | |
361 | template<class T, std::size_t N> | |
362 | bool operator>= (const array<T,N>& x, const array<T,N>& y) { | |
363 | return !(x<y); | |
364 | } | |
365 | ||
366 | // global swap() | |
367 | template<class T, std::size_t N> | |
368 | inline void swap (array<T,N>& x, array<T,N>& y) { | |
369 | x.swap(y); | |
370 | } | |
371 | ||
372 | #if defined(__SUNPRO_CC) | |
373 | // Trac ticket #4757; the Sun Solaris compiler can't handle | |
374 | // syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]' | |
375 | // | |
376 | // We can't just use this for all compilers, because the | |
377 | // borland compilers can't handle this form. | |
378 | namespace detail { | |
379 | template <typename T, std::size_t N> struct c_array | |
380 | { | |
381 | typedef T type[N]; | |
382 | }; | |
383 | } | |
384 | ||
385 | // Specific for boost::array: simply returns its elems data member. | |
386 | template <typename T, std::size_t N> | |
387 | typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg) | |
388 | { | |
389 | return arg.elems; | |
390 | } | |
391 | ||
392 | // Specific for boost::array: simply returns its elems data member. | |
393 | template <typename T, std::size_t N> | |
394 | typename const detail::c_array<T,N>::type& get_c_array(const boost::array<T,N>& arg) | |
395 | { | |
396 | return arg.elems; | |
397 | } | |
398 | #else | |
399 | // Specific for boost::array: simply returns its elems data member. | |
400 | template <typename T, std::size_t N> | |
401 | T(&get_c_array(boost::array<T,N>& arg))[N] | |
402 | { | |
403 | return arg.elems; | |
404 | } | |
405 | ||
406 | // Const version. | |
407 | template <typename T, std::size_t N> | |
408 | const T(&get_c_array(const boost::array<T,N>& arg))[N] | |
409 | { | |
410 | return arg.elems; | |
411 | } | |
412 | #endif | |
413 | ||
414 | #if 0 | |
415 | // Overload for std::array, assuming that std::array will have | |
416 | // explicit conversion functions as discussed at the WG21 meeting | |
417 | // in Summit, March 2009. | |
418 | template <typename T, std::size_t N> | |
419 | T(&get_c_array(std::array<T,N>& arg))[N] | |
420 | { | |
421 | return static_cast<T(&)[N]>(arg); | |
422 | } | |
423 | ||
424 | // Const version. | |
425 | template <typename T, std::size_t N> | |
426 | const T(&get_c_array(const std::array<T,N>& arg))[N] | |
427 | { | |
428 | return static_cast<T(&)[N]>(arg); | |
429 | } | |
430 | #endif | |
431 | ||
432 | ||
433 | template<class T, std::size_t N> | |
434 | std::size_t hash_value(const array<T,N>& arr) | |
435 | { | |
436 | return boost::hash_range(arr.begin(), arr.end()); | |
437 | } | |
438 | ||
439 | } /* namespace boost */ | |
440 | ||
441 | ||
442 | #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) | |
443 | # pragma warning(pop) | |
444 | #endif | |
445 | ||
446 | #endif /*BOOST_ARRAY_HPP*/ |