]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright 2002 The Trustees of Indiana University. |
2 | ||
3 | // Use, modification and distribution is subject to the Boost Software | |
4 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
5 | // http://www.boost.org/LICENSE_1_0.txt) | |
6 | ||
7 | // Boost.MultiArray Library | |
8 | // Authors: Ronald Garcia | |
9 | // Jeremy Siek | |
10 | // Andrew Lumsdaine | |
11 | // See http://www.boost.org/libs/multi_array for documentation. | |
12 | ||
13 | #ifndef BOOST_MULTI_ARRAY_RG071801_HPP | |
14 | #define BOOST_MULTI_ARRAY_RG071801_HPP | |
15 | ||
16 | // | |
17 | // multi_array.hpp - contains the multi_array class template | |
18 | // declaration and definition | |
19 | // | |
20 | ||
21 | #include "boost/multi_array/base.hpp" | |
22 | #include "boost/multi_array/collection_concept.hpp" | |
23 | #include "boost/multi_array/copy_array.hpp" | |
24 | #include "boost/multi_array/iterator.hpp" | |
25 | #include "boost/multi_array/subarray.hpp" | |
26 | #include "boost/multi_array/multi_array_ref.hpp" | |
27 | #include "boost/multi_array/algorithm.hpp" | |
28 | #include "boost/array.hpp" | |
29 | #include "boost/mpl/if.hpp" | |
30 | #include "boost/type_traits.hpp" | |
31 | #include <algorithm> | |
32 | #include <cstddef> | |
33 | #include <functional> | |
34 | #include <numeric> | |
35 | #include <vector> | |
36 | ||
37 | ||
38 | ||
39 | namespace boost { | |
40 | namespace detail { | |
41 | namespace multi_array { | |
42 | ||
43 | struct populate_index_ranges { | |
44 | multi_array_types::index_range | |
45 | // RG: underscore on extent_ to stifle strange MSVC warning. | |
46 | operator()(multi_array_types::index base, | |
47 | multi_array_types::size_type extent_) { | |
48 | return multi_array_types::index_range(base,base+extent_); | |
49 | } | |
50 | }; | |
51 | ||
52 | #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
53 | // | |
54 | // Compilers that don't support partial ordering may need help to | |
55 | // disambiguate multi_array's templated constructors. Even vc6/7 are | |
56 | // capable of some limited SFINAE, so we take the most-general version | |
57 | // out of the overload set with disable_multi_array_impl. | |
58 | // | |
59 | template <typename T, std::size_t NumDims, typename TPtr> | |
60 | char is_multi_array_impl_help(const_multi_array_view<T,NumDims,TPtr>&); | |
61 | template <typename T, std::size_t NumDims, typename TPtr> | |
62 | char is_multi_array_impl_help(const_sub_array<T,NumDims,TPtr>&); | |
63 | template <typename T, std::size_t NumDims, typename TPtr> | |
64 | char is_multi_array_impl_help(const_multi_array_ref<T,NumDims,TPtr>&); | |
65 | ||
66 | char ( &is_multi_array_impl_help(...) )[2]; | |
67 | ||
68 | template <class T> | |
69 | struct is_multi_array_impl | |
70 | { | |
71 | static T x; | |
72 | BOOST_STATIC_CONSTANT(bool, value = sizeof((is_multi_array_impl_help)(x)) == 1); | |
73 | ||
74 | typedef mpl::bool_<value> type; | |
75 | }; | |
76 | ||
77 | template <bool multi_array = false> | |
78 | struct disable_multi_array_impl_impl | |
79 | { | |
80 | typedef int type; | |
81 | }; | |
82 | ||
83 | template <> | |
84 | struct disable_multi_array_impl_impl<true> | |
85 | { | |
86 | // forming a pointer to a reference triggers SFINAE | |
87 | typedef int& type; | |
88 | }; | |
89 | ||
90 | ||
91 | template <class T> | |
92 | struct disable_multi_array_impl : | |
93 | disable_multi_array_impl_impl<is_multi_array_impl<T>::value> | |
94 | { }; | |
95 | ||
96 | ||
97 | template <> | |
98 | struct disable_multi_array_impl<int> | |
99 | { | |
100 | typedef int type; | |
101 | }; | |
102 | ||
103 | ||
104 | #endif | |
105 | ||
106 | } //namespace multi_array | |
107 | } // namespace detail | |
108 | ||
109 | template<typename T, std::size_t NumDims, | |
110 | typename Allocator> | |
111 | class multi_array : | |
112 | public multi_array_ref<T,NumDims> | |
113 | { | |
114 | typedef multi_array_ref<T,NumDims> super_type; | |
115 | public: | |
116 | typedef typename super_type::value_type value_type; | |
117 | typedef typename super_type::reference reference; | |
118 | typedef typename super_type::const_reference const_reference; | |
119 | typedef typename super_type::iterator iterator; | |
120 | typedef typename super_type::const_iterator const_iterator; | |
121 | typedef typename super_type::reverse_iterator reverse_iterator; | |
122 | typedef typename super_type::const_reverse_iterator const_reverse_iterator; | |
123 | typedef typename super_type::element element; | |
124 | typedef typename super_type::size_type size_type; | |
125 | typedef typename super_type::difference_type difference_type; | |
126 | typedef typename super_type::index index; | |
127 | typedef typename super_type::extent_range extent_range; | |
128 | ||
129 | ||
130 | template <std::size_t NDims> | |
131 | struct const_array_view { | |
132 | typedef boost::detail::multi_array::const_multi_array_view<T,NDims> type; | |
133 | }; | |
134 | ||
135 | template <std::size_t NDims> | |
136 | struct array_view { | |
137 | typedef boost::detail::multi_array::multi_array_view<T,NDims> type; | |
138 | }; | |
139 | ||
140 | explicit multi_array() : | |
141 | super_type((T*)initial_base_,c_storage_order(), | |
142 | /*index_bases=*/0, /*extents=*/0) { | |
143 | allocate_space(); | |
144 | } | |
145 | ||
146 | template <class ExtentList> | |
147 | explicit multi_array( | |
148 | ExtentList const& extents | |
149 | #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
150 | , typename mpl::if_< | |
151 | detail::multi_array::is_multi_array_impl<ExtentList>, | |
152 | int&,int>::type* = 0 | |
153 | #endif | |
154 | ) : | |
155 | super_type((T*)initial_base_,extents) { | |
156 | boost::function_requires< | |
157 | detail::multi_array::CollectionConcept<ExtentList> >(); | |
158 | allocate_space(); | |
159 | } | |
160 | ||
161 | ||
162 | template <class ExtentList> | |
163 | explicit multi_array(ExtentList const& extents, | |
164 | const general_storage_order<NumDims>& so) : | |
165 | super_type((T*)initial_base_,extents,so) { | |
166 | boost::function_requires< | |
167 | detail::multi_array::CollectionConcept<ExtentList> >(); | |
168 | allocate_space(); | |
169 | } | |
170 | ||
171 | template <class ExtentList> | |
172 | explicit multi_array(ExtentList const& extents, | |
173 | const general_storage_order<NumDims>& so, | |
174 | Allocator const& alloc) : | |
175 | super_type((T*)initial_base_,extents,so), allocator_(alloc) { | |
176 | boost::function_requires< | |
177 | detail::multi_array::CollectionConcept<ExtentList> >(); | |
178 | allocate_space(); | |
179 | } | |
180 | ||
181 | ||
182 | explicit multi_array(const detail::multi_array | |
183 | ::extent_gen<NumDims>& ranges) : | |
184 | super_type((T*)initial_base_,ranges) { | |
185 | ||
186 | allocate_space(); | |
187 | } | |
188 | ||
189 | ||
190 | explicit multi_array(const detail::multi_array | |
191 | ::extent_gen<NumDims>& ranges, | |
192 | const general_storage_order<NumDims>& so) : | |
193 | super_type((T*)initial_base_,ranges,so) { | |
194 | ||
195 | allocate_space(); | |
196 | } | |
197 | ||
198 | ||
199 | explicit multi_array(const detail::multi_array | |
200 | ::extent_gen<NumDims>& ranges, | |
201 | const general_storage_order<NumDims>& so, | |
202 | Allocator const& alloc) : | |
203 | super_type((T*)initial_base_,ranges,so), allocator_(alloc) { | |
204 | ||
205 | allocate_space(); | |
206 | } | |
207 | ||
208 | multi_array(const multi_array& rhs) : | |
209 | super_type(rhs), allocator_(rhs.allocator_) { | |
210 | allocate_space(); | |
211 | boost::detail::multi_array::copy_n(rhs.base_,rhs.num_elements(),base_); | |
212 | } | |
213 | ||
214 | ||
215 | // | |
216 | // A multi_array is constructible from any multi_array_ref, subarray, or | |
217 | // array_view object. The following constructors ensure that. | |
218 | // | |
219 | ||
220 | // Due to limited support for partial template ordering, | |
221 | // MSVC 6&7 confuse the following with the most basic ExtentList | |
222 | // constructor. | |
223 | #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
224 | template <typename OPtr> | |
225 | multi_array(const const_multi_array_ref<T,NumDims,OPtr>& rhs, | |
226 | const general_storage_order<NumDims>& so = c_storage_order()) | |
227 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
228 | { | |
229 | allocate_space(); | |
230 | // Warning! storage order may change, hence the following copy technique. | |
231 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
232 | } | |
233 | ||
234 | template <typename OPtr> | |
235 | multi_array(const detail::multi_array:: | |
236 | const_sub_array<T,NumDims,OPtr>& rhs, | |
237 | const general_storage_order<NumDims>& so = c_storage_order()) | |
238 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
239 | { | |
240 | allocate_space(); | |
241 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
242 | } | |
243 | ||
244 | ||
245 | template <typename OPtr> | |
246 | multi_array(const detail::multi_array:: | |
247 | const_multi_array_view<T,NumDims,OPtr>& rhs, | |
248 | const general_storage_order<NumDims>& so = c_storage_order()) | |
249 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
250 | { | |
251 | allocate_space(); | |
252 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
253 | } | |
254 | ||
255 | #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
256 | // More limited support for MSVC | |
257 | ||
258 | ||
259 | multi_array(const const_multi_array_ref<T,NumDims>& rhs) | |
260 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
261 | { | |
262 | allocate_space(); | |
263 | // Warning! storage order may change, hence the following copy technique. | |
264 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
265 | } | |
266 | ||
267 | multi_array(const const_multi_array_ref<T,NumDims>& rhs, | |
268 | const general_storage_order<NumDims>& so) | |
269 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
270 | { | |
271 | allocate_space(); | |
272 | // Warning! storage order may change, hence the following copy technique. | |
273 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
274 | } | |
275 | ||
276 | multi_array(const detail::multi_array:: | |
277 | const_sub_array<T,NumDims>& rhs) | |
278 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
279 | { | |
280 | allocate_space(); | |
281 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
282 | } | |
283 | ||
284 | multi_array(const detail::multi_array:: | |
285 | const_sub_array<T,NumDims>& rhs, | |
286 | const general_storage_order<NumDims>& so) | |
287 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
288 | { | |
289 | allocate_space(); | |
290 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
291 | } | |
292 | ||
293 | ||
294 | multi_array(const detail::multi_array:: | |
295 | const_multi_array_view<T,NumDims>& rhs) | |
296 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
297 | { | |
298 | allocate_space(); | |
299 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
300 | } | |
301 | ||
302 | multi_array(const detail::multi_array:: | |
303 | const_multi_array_view<T,NumDims>& rhs, | |
304 | const general_storage_order<NumDims>& so) | |
305 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
306 | { | |
307 | allocate_space(); | |
308 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
309 | } | |
310 | ||
311 | #endif // !BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
312 | ||
313 | // Thes constructors are necessary because of more exact template matches. | |
314 | multi_array(const multi_array_ref<T,NumDims>& rhs) | |
315 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
316 | { | |
317 | allocate_space(); | |
318 | // Warning! storage order may change, hence the following copy technique. | |
319 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
320 | } | |
321 | ||
322 | multi_array(const multi_array_ref<T,NumDims>& rhs, | |
323 | const general_storage_order<NumDims>& so) | |
324 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
325 | { | |
326 | allocate_space(); | |
327 | // Warning! storage order may change, hence the following copy technique. | |
328 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
329 | } | |
330 | ||
331 | ||
332 | multi_array(const detail::multi_array:: | |
333 | sub_array<T,NumDims>& rhs) | |
334 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
335 | { | |
336 | allocate_space(); | |
337 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
338 | } | |
339 | ||
340 | multi_array(const detail::multi_array:: | |
341 | sub_array<T,NumDims>& rhs, | |
342 | const general_storage_order<NumDims>& so) | |
343 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
344 | { | |
345 | allocate_space(); | |
346 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
347 | } | |
348 | ||
349 | ||
350 | multi_array(const detail::multi_array:: | |
351 | multi_array_view<T,NumDims>& rhs) | |
352 | : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) | |
353 | { | |
354 | allocate_space(); | |
355 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
356 | } | |
357 | ||
358 | multi_array(const detail::multi_array:: | |
359 | multi_array_view<T,NumDims>& rhs, | |
360 | const general_storage_order<NumDims>& so) | |
361 | : super_type(0,so,rhs.index_bases(),rhs.shape()) | |
362 | { | |
363 | allocate_space(); | |
364 | std::copy(rhs.begin(),rhs.end(),this->begin()); | |
365 | } | |
366 | ||
367 | // Since assignment is a deep copy, multi_array_ref | |
368 | // contains all the necessary code. | |
369 | template <typename ConstMultiArray> | |
370 | multi_array& operator=(const ConstMultiArray& other) { | |
371 | super_type::operator=(other); | |
372 | return *this; | |
373 | } | |
374 | ||
375 | multi_array& operator=(const multi_array& other) { | |
376 | if (&other != this) { | |
377 | super_type::operator=(other); | |
378 | } | |
379 | return *this; | |
380 | } | |
381 | ||
382 | ||
383 | template <typename ExtentList> | |
384 | multi_array& resize(const ExtentList& extents) { | |
385 | boost::function_requires< | |
386 | detail::multi_array::CollectionConcept<ExtentList> >(); | |
387 | ||
388 | typedef detail::multi_array::extent_gen<NumDims> gen_type; | |
389 | gen_type ranges; | |
390 | ||
391 | for (int i=0; i != NumDims; ++i) { | |
392 | typedef typename gen_type::range range_type; | |
393 | ranges.ranges_[i] = range_type(0,extents[i]); | |
394 | } | |
395 | ||
396 | return this->resize(ranges); | |
397 | } | |
398 | ||
399 | ||
400 | ||
401 | multi_array& resize(const detail::multi_array | |
402 | ::extent_gen<NumDims>& ranges) { | |
403 | ||
404 | ||
405 | // build a multi_array with the specs given | |
406 | multi_array new_array(ranges,this->storage_order()); | |
407 | ||
408 | ||
409 | // build a view of tmp with the minimum extents | |
410 | ||
411 | // Get the minimum extents of the arrays. | |
412 | boost::array<size_type,NumDims> min_extents; | |
413 | ||
414 | const size_type& (*min)(const size_type&, const size_type&) = | |
415 | std::min; | |
416 | std::transform(new_array.extent_list_.begin(),new_array.extent_list_.end(), | |
417 | this->extent_list_.begin(), | |
418 | min_extents.begin(), | |
419 | min); | |
420 | ||
421 | ||
422 | // typedef boost::array<index,NumDims> index_list; | |
423 | // Build index_gen objects to create views with the same shape | |
424 | ||
425 | // these need to be separate to handle non-zero index bases | |
426 | typedef detail::multi_array::index_gen<NumDims,NumDims> index_gen; | |
427 | index_gen old_idxes; | |
428 | index_gen new_idxes; | |
429 | ||
430 | std::transform(new_array.index_base_list_.begin(), | |
431 | new_array.index_base_list_.end(), | |
432 | min_extents.begin(),new_idxes.ranges_.begin(), | |
433 | detail::multi_array::populate_index_ranges()); | |
434 | ||
435 | std::transform(this->index_base_list_.begin(), | |
436 | this->index_base_list_.end(), | |
437 | min_extents.begin(),old_idxes.ranges_.begin(), | |
438 | detail::multi_array::populate_index_ranges()); | |
439 | ||
440 | // Build same-shape views of the two arrays | |
441 | typename | |
442 | multi_array::BOOST_NESTED_TEMPLATE array_view<NumDims>::type view_old = (*this)[old_idxes]; | |
443 | typename | |
444 | multi_array::BOOST_NESTED_TEMPLATE array_view<NumDims>::type view_new = new_array[new_idxes]; | |
445 | ||
446 | // Set the right portion of the new array | |
447 | view_new = view_old; | |
448 | ||
449 | using std::swap; | |
450 | // Swap the internals of these arrays. | |
451 | swap(this->super_type::base_,new_array.super_type::base_); | |
452 | swap(this->storage_,new_array.storage_); | |
453 | swap(this->extent_list_,new_array.extent_list_); | |
454 | swap(this->stride_list_,new_array.stride_list_); | |
455 | swap(this->index_base_list_,new_array.index_base_list_); | |
456 | swap(this->origin_offset_,new_array.origin_offset_); | |
457 | swap(this->directional_offset_,new_array.directional_offset_); | |
458 | swap(this->num_elements_,new_array.num_elements_); | |
459 | swap(this->allocator_,new_array.allocator_); | |
460 | swap(this->base_,new_array.base_); | |
461 | swap(this->allocated_elements_,new_array.allocated_elements_); | |
462 | ||
463 | return *this; | |
464 | } | |
465 | ||
466 | ||
467 | ~multi_array() { | |
468 | deallocate_space(); | |
469 | } | |
470 | ||
471 | private: | |
472 | void allocate_space() { | |
473 | typename Allocator::const_pointer no_hint=0; | |
474 | base_ = allocator_.allocate(this->num_elements(),no_hint); | |
475 | this->set_base_ptr(base_); | |
476 | allocated_elements_ = this->num_elements(); | |
477 | std::uninitialized_fill_n(base_,allocated_elements_,T()); | |
478 | } | |
479 | ||
480 | void deallocate_space() { | |
481 | if(base_) { | |
482 | for(T* i = base_; i != base_+allocated_elements_; ++i) | |
483 | allocator_.destroy(i); | |
484 | allocator_.deallocate(base_,allocated_elements_); | |
485 | } | |
486 | } | |
487 | ||
488 | typedef boost::array<size_type,NumDims> size_list; | |
489 | typedef boost::array<index,NumDims> index_list; | |
490 | ||
491 | Allocator allocator_; | |
492 | T* base_; | |
493 | size_type allocated_elements_; | |
494 | enum {initial_base_ = 0}; | |
495 | }; | |
496 | ||
497 | } // namespace boost | |
498 | ||
499 | #endif // BOOST_MULTI_ARRAY_RG071801_HPP |