00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00058 #ifndef STLSOFT_INCL_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY
00059 #define STLSOFT_INCL_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY
00060
00061 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00062 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY_MAJOR 4
00063 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY_MINOR 9
00064 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY_REVISION 5
00065 # define STLSOFT_VER_STLSOFT_CONTAINERS_HPP_FIXED_ARRAY_EDIT 191
00066 #endif
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00084 # include <stlsoft/stlsoft.h>
00085 #endif
00086
00087 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00088 _MSC_VER < 1200
00089 # error stlsoft/containers/fixed_array.hpp is not compatible with Visual C++ 5.0 or earlier
00090 #endif
00091
00092 #ifndef STLSOFT_INCL_STLSOFT_MEMORY_HPP_ALLOCATOR_SELECTOR
00093 # include <stlsoft/memory/allocator_selector.hpp>
00094 #endif
00095 #ifndef STLSOFT_INCL_STLSOFT_UTIL_STD_HPP_ITERATOR_HELPER
00096 # include <stlsoft/util/std/iterator_helper.hpp>
00097 #endif
00098 #ifndef STLSOFT_INCL_STLSOFT_CONTAINERS_UTIL_HPP_ARRAY_POLICIES
00099 # include <stlsoft/containers/util/array_policies.hpp>
00100 #endif
00101 #ifndef STLSOFT_INCL_STLSOFT_META_HPP_CAPABILITIES
00102 # include <stlsoft/meta/capabilities.hpp>
00103 #endif
00104 #ifndef STLSOFT_INCL_STLSOFT_COLLECTIONS_UTIL_HPP_COLLECTIONS
00105 # include <stlsoft/collections/util/collections.hpp>
00106 #endif
00107 #ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_STD_SWAP
00108 # include <stlsoft/util/std_swap.hpp>
00109 #endif
00110
00111 #if defined(STLSOFT_COMPILER_IS_MSVC) && \
00112 defined(STLSOFT_CF_STD_LIBRARY_IS_STLPORT)
00113 # ifndef STLSOFT_INCL_STRING
00114 # define STLSOFT_INCL_STRING
00115 # include <string>
00116 # endif
00117 #endif
00118 #ifndef STLSOFT_INCL_STDEXCEPT
00119 # define STLSOFT_INCL_STDEXCEPT
00120 # include <stdexcept>
00121 #endif
00122
00123
00124
00125
00126
00127 #ifndef _STLSOFT_NO_NAMESPACE
00128 namespace stlsoft
00129 {
00130 #endif
00131
00132
00133
00134
00135
00136 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00137
00138 template< ss_typename_param_k T
00139 , ss_typename_param_k A
00140 , ss_typename_param_k P
00141 , ss_bool_t R
00142 >
00143 class fixed_array_1d;
00144
00145 template< ss_typename_param_k T
00146 , ss_typename_param_k A
00147 , ss_typename_param_k P
00148 , ss_bool_t R
00149 >
00150 class fixed_array_2d;
00151
00152 template< ss_typename_param_k T
00153 , ss_typename_param_k A
00154 , ss_typename_param_k P
00155 , ss_bool_t R
00156 >
00157 class fixed_array_3d;
00158
00159 template< ss_typename_param_k T
00160 , ss_typename_param_k A
00161 , ss_typename_param_k P
00162 , ss_bool_t R
00163 >
00164 class fixed_array_4d;
00165
00166 template< ss_typename_param_k T
00167 , ss_typename_param_k A
00168 , ss_typename_param_k P
00169 , ss_bool_t R
00170 >
00171 class fixed_array_5d;
00172
00173 #endif
00174
00175
00176
00177
00178
00187 template< ss_typename_param_k T
00188 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00189 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
00190 , ss_typename_param_k P = do_construction<T>
00191 , ss_bool_t R = true
00192 #else
00193 , ss_typename_param_k A
00194 , ss_typename_param_k P
00195 , ss_typename_param_k R
00196 #endif
00197 >
00198
00199 class fixed_array_1d
00200 : protected A
00201 , public stl_collection_tag
00202 {
00203 public:
00204 typedef fixed_array_1d<T, A, P, R> class_type;
00205 typedef T dimension_element_type;
00206 typedef dimension_element_type const_dimension_element_type;
00207 typedef A allocator_type;
00208 typedef T value_type;
00209 typedef value_type& reference;
00210 typedef value_type const& const_reference;
00211 typedef value_type* pointer;
00212 typedef value_type const* const_pointer;
00213 typedef ss_size_t size_type;
00214 typedef ss_size_t index_type;
00215 typedef ss_ptrdiff_t difference_type;
00216 typedef ss_bool_t bool_type;
00217 typedef
00218 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00219 ss_typename_type_k
00220 #endif
00221 pointer_iterator < value_type
00222 , pointer
00223 , reference
00224 >::type iterator;
00225 typedef
00226 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00227 ss_typename_type_k
00228 #endif
00229 pointer_iterator < value_type const
00230 , const_pointer
00231 , const_reference
00232 >::type const_iterator;
00233 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00234 typedef reverse_iterator_base < iterator
00235 , value_type
00236 , reference
00237 , pointer
00238 , difference_type
00239 > reverse_iterator;
00240 typedef const_reverse_iterator_base < const_iterator
00241 , value_type const
00242 , const_reference
00243 , const_pointer
00244 , difference_type
00245 > const_reverse_iterator;
00246 #endif
00247
00248
00249 private:
00250 fixed_array_1d(T *data, index_type d0);
00251 public:
00252 ss_explicit_k fixed_array_1d(index_type d0);
00253 fixed_array_1d(index_type d0, allocator_type const& ator);
00254 fixed_array_1d(index_type d0, value_type const& t);
00255 fixed_array_1d(index_type d0, value_type const& t, allocator_type const& ator);
00256 fixed_array_1d(class_type const& rhs);
00257 ~fixed_array_1d() stlsoft_throw_0();
00258
00259 allocator_type get_allocator() const;
00260
00261 void swap(class_type& rhs) stlsoft_throw_0();
00262
00263
00264 public:
00265 reference at(index_type i0);
00266 const_reference at(index_type i0) const;
00267
00268 reference at_unchecked(index_type i0);
00269 const_reference at_unchecked(index_type i0) const;
00270
00271 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
00272 reference operator ()(index_type i0);
00273 const_reference operator ()(index_type i0) const;
00274 #endif
00275
00276 reference operator [](index_type i0);
00277 const_reference operator [](index_type i0) const;
00278
00280
00282
00283
00284 reference front();
00285 reference back();
00286 const_reference front() const;
00287 const_reference back() const;
00288
00289
00290 public:
00291 index_type dimension0() const;
00292 index_type size() const;
00293 bool_type empty() const;
00294 static size_type max_size();
00295
00296
00297 public:
00298 iterator begin();
00299 iterator end();
00300 const_iterator begin() const;
00301 const_iterator end() const;
00302
00303 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00304 reverse_iterator rbegin();
00305 reverse_iterator rend();
00306 const_reverse_iterator rbegin() const;
00307 const_reverse_iterator rend() const;
00308 #endif
00309
00310
00311 public:
00312 pointer data();
00313 const_pointer data() const;
00314
00315
00316 private:
00317 pointer allocate_(size_type n);
00318 void deallocate_(pointer p, size_type n);
00319
00320 pointer data_();
00321 index_type calc_index_(index_type i0) const;
00322 void range_check_(index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00323
00324 allocator_type& get_allocator_();
00325
00326
00327 private:
00328 T* m_data;
00329 index_type m_d0;
00330
00331 friend class fixed_array_2d<T, A, P, true>;
00332 friend class fixed_array_2d<T, A, P, false>;
00333
00334
00335 private:
00336 class_type const& operator =(class_type const& rhs);
00337 };
00338
00347 template< ss_typename_param_k T
00348 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00349 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
00350 , ss_typename_param_k P = do_construction<T>
00351 , ss_bool_t R = true
00352 #else
00353 , ss_typename_param_k A
00354 , ss_typename_param_k P
00355 , ss_bool_t R
00356 #endif
00357 >
00358
00359 class fixed_array_2d
00360 : protected A
00361 , public stl_collection_tag
00362 {
00363 public:
00364 typedef fixed_array_2d<T, A, P, R> class_type;
00365 typedef fixed_array_1d<T, A, P, false> dimension_element_type;
00366 typedef dimension_element_type const_dimension_element_type;
00367 typedef A allocator_type;
00368 typedef T value_type;
00369 typedef value_type& reference;
00370 typedef value_type const& const_reference;
00371 typedef value_type* pointer;
00372 typedef value_type const* const_pointer;
00373 typedef ss_size_t size_type;
00374 typedef ss_size_t index_type;
00375 typedef ss_ptrdiff_t difference_type;
00376 typedef ss_bool_t bool_type;
00377 typedef
00378 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00379 ss_typename_type_k
00380 #endif
00381 pointer_iterator < value_type
00382 , pointer
00383 , reference
00384 >::type iterator;
00385 typedef
00386 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00387 ss_typename_type_k
00388 #endif
00389 pointer_iterator < value_type const
00390 , const_pointer
00391 , const_reference
00392 >::type const_iterator;
00393 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00394 typedef reverse_iterator_base < iterator
00395 , value_type
00396 , reference
00397 , pointer
00398 , difference_type
00399 > reverse_iterator;
00400 typedef const_reverse_iterator_base < const_iterator
00401 , value_type const
00402 , const_reference
00403 , const_pointer
00404 , difference_type
00405 > const_reverse_iterator;
00406 #endif
00407
00408
00409 private:
00410 fixed_array_2d(T *data, index_type d0, index_type d1);
00411 public:
00412 fixed_array_2d(index_type d0, index_type d1);
00413 fixed_array_2d(index_type d0, index_type d1, allocator_type const& ator);
00414 fixed_array_2d(index_type d0, index_type d1, value_type const& t);
00415 fixed_array_2d(index_type d0, index_type d1, value_type const& t, allocator_type const& ator);
00416 fixed_array_2d(class_type const& rhs);
00417 ~fixed_array_2d() stlsoft_throw_0();
00418
00419 allocator_type get_allocator() const;
00420
00421 void swap(class_type& rhs) stlsoft_throw_0();
00422
00423
00424 public:
00425 reference at(index_type i0, index_type i1);
00426 const_reference at(index_type i0, index_type i1) const;
00427
00428 reference at_unchecked(index_type i0, index_type i1);
00429 const_reference at_unchecked(index_type i0, index_type i1) const;
00430
00431 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
00432 reference operator ()(index_type i0, index_type i1);
00433 const_reference operator ()(index_type i0, index_type i1) const;
00434 #endif
00435
00436 dimension_element_type at(index_type i0);
00437 const_dimension_element_type at(index_type i0) const;
00438
00439 dimension_element_type at_unchecked(index_type i0);
00440 const_dimension_element_type at_unchecked(index_type i0) const;
00441
00442 dimension_element_type operator [](index_type i0);
00443 const_dimension_element_type operator [](index_type i0) const;
00444
00446 reference front();
00447 reference back();
00448 const_reference front() const;
00449 const_reference back() const;
00450
00451
00452 public:
00453 index_type dimension0() const;
00454 index_type dimension1() const;
00455 index_type size() const;
00456 bool_type empty() const;
00457 static size_type max_size();
00458
00459
00460 public:
00461 iterator begin();
00462 iterator end();
00463 const_iterator begin() const;
00464 const_iterator end() const;
00465
00466 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00467 reverse_iterator rbegin();
00468 reverse_iterator rend();
00469 const_reverse_iterator rbegin() const;
00470 const_reverse_iterator rend() const;
00471 #endif
00472
00473
00474 public:
00475 pointer data();
00476 const_pointer data() const;
00477
00478
00479 private:
00480 pointer allocate_(size_type n);
00481 void deallocate_(pointer p, size_type n);
00482
00483 pointer data_();
00484 index_type calc_index_(index_type i0, index_type i1) const;
00485 void range_check_(index_type i0, index_type i1) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00486 void range_check_(index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00487
00488 allocator_type& get_allocator_();
00489
00490
00491 private:
00492 T* m_data;
00493 index_type m_d0;
00494 index_type m_d1;
00495 size_type m_size;
00496
00497 friend class fixed_array_3d<T, A, P, true>;
00498 friend class fixed_array_3d<T, A, P, false>;
00499
00500
00501 private:
00502 class_type const& operator =(class_type const& rhs);
00503 };
00504
00513 template< ss_typename_param_k T
00514 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00515 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
00516 , ss_typename_param_k P = do_construction<T>
00517 , ss_bool_t R = true
00518 #else
00519 , ss_typename_param_k A
00520 , ss_typename_param_k P
00521 , ss_bool_t R
00522 #endif
00523 >
00524
00525 class fixed_array_3d
00526 : protected A
00527 , public stl_collection_tag
00528 {
00529 public:
00530 typedef fixed_array_3d<T, A, P, R> class_type;
00531 typedef fixed_array_2d<T, A, P, false> dimension_element_type;
00532 typedef dimension_element_type const_dimension_element_type;
00533 typedef A allocator_type;
00534 typedef T value_type;
00535 typedef value_type& reference;
00536 typedef value_type const& const_reference;
00537 typedef value_type* pointer;
00538 typedef value_type const* const_pointer;
00539 typedef ss_size_t size_type;
00540 typedef ss_size_t index_type;
00541 typedef ss_ptrdiff_t difference_type;
00542 typedef ss_bool_t bool_type;
00543 typedef
00544 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00545 ss_typename_type_k
00546 #endif
00547 pointer_iterator < value_type
00548 , pointer
00549 , reference
00550 >::type iterator;
00551 typedef
00552 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00553 ss_typename_type_k
00554 #endif
00555 pointer_iterator < value_type const
00556 , const_pointer
00557 , const_reference
00558 >::type const_iterator;
00559 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00560 typedef reverse_iterator_base < iterator
00561 , value_type
00562 , reference
00563 , pointer
00564 , difference_type
00565 > reverse_iterator;
00566 typedef const_reverse_iterator_base < const_iterator
00567 , value_type const
00568 , const_reference
00569 , const_pointer
00570 , difference_type
00571 > const_reverse_iterator;
00572 #endif
00573
00574
00575 private:
00576 fixed_array_3d(pointer data, index_type d0, index_type d1, index_type d2);
00577 public:
00578 fixed_array_3d(index_type d0, index_type d1, index_type d2);
00579 fixed_array_3d(index_type d0, index_type d1, index_type d2, allocator_type const& ator);
00580 fixed_array_3d(index_type d0, index_type d1, index_type d2, value_type const& t);
00581 fixed_array_3d(index_type d0, index_type d1, index_type d2, value_type const& t, allocator_type const& ator);
00582 fixed_array_3d(class_type const& rhs);
00583 ~fixed_array_3d() stlsoft_throw_0();
00584
00585 allocator_type get_allocator() const;
00586
00587 void swap(class_type& rhs) stlsoft_throw_0();
00588
00589
00590 public:
00591 reference at(index_type i0, index_type i1, index_type i2);
00592 const_reference at(index_type i0, index_type i1, index_type i3) const;
00593
00594 reference at_unchecked(index_type i0, index_type i1, index_type i2);
00595 const_reference at_unchecked(index_type i0, index_type i1, index_type i2) const;
00596
00597 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
00598 reference operator ()(index_type i0, index_type i1, index_type i2);
00599 const_reference operator ()(index_type i0, index_type i1, index_type i2) const;
00600 #endif
00601
00602 dimension_element_type at(index_type i0);
00603 const_dimension_element_type at(index_type i0) const;
00604
00605 dimension_element_type at_unchecked(index_type i0);
00606 const_dimension_element_type at_unchecked(index_type i0) const;
00607
00608 dimension_element_type operator [](index_type i0);
00609 const_dimension_element_type operator [](index_type i0) const;
00610
00611 reference front();
00612 reference back();
00613 const_reference front() const;
00614 const_reference back() const;
00615
00616
00617 public:
00618 index_type dimension0() const;
00619 index_type dimension1() const;
00620 index_type dimension2() const;
00621 index_type size() const;
00622 bool_type empty() const;
00623 static size_type max_size();
00624
00625
00626 public:
00627 iterator begin();
00628 iterator end();
00629 const_iterator begin() const;
00630 const_iterator end() const;
00631
00632 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00633 reverse_iterator rbegin();
00634 reverse_iterator rend();
00635 const_reverse_iterator rbegin() const;
00636 const_reverse_iterator rend() const;
00637 #endif
00638
00639
00640 public:
00641 pointer data();
00642 const_pointer data() const;
00643
00644
00645 private:
00646 pointer allocate_(size_type n);
00647 void deallocate_(pointer p, size_type n);
00648
00649 pointer data_();
00650 index_type calc_index_(index_type i0, index_type i1, index_type i2) const;
00651 void range_check_(index_type i0, index_type i1, index_type i2) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00652 void range_check_(index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00653
00654 allocator_type& get_allocator_();
00655
00656
00657 private:
00658 T* m_data;
00659 index_type m_d0;
00660 index_type m_d1;
00661 index_type m_d2;
00662
00663 friend class fixed_array_4d<T, A, P, true>;
00664 friend class fixed_array_4d<T, A, P, false>;
00665
00666
00667 private:
00668 class_type const& operator =(class_type const& rhs);
00669 };
00670
00679 template< ss_typename_param_k T
00680 #ifdef STLSOFT_CF_TEMPLATE_CLASS_DEFAULT_CLASS_ARGUMENT_SUPPORT
00681 , ss_typename_param_k A = ss_typename_type_def_k allocator_selector<T>::allocator_type
00682 , ss_typename_param_k P = do_construction<T>
00683 , ss_bool_t R = true
00684 #else
00685 , ss_typename_param_k A
00686 , ss_typename_param_k P
00687 , ss_bool_t R
00688 #endif
00689 >
00690
00691 class fixed_array_4d
00692 : protected A
00693 , public stl_collection_tag
00694 {
00695 public:
00696 typedef fixed_array_4d<T, A, P, R> class_type;
00697 typedef fixed_array_3d<T, A, P, false> dimension_element_type;
00698 typedef dimension_element_type const_dimension_element_type;
00699 typedef A allocator_type;
00700 typedef T value_type;
00701 typedef value_type& reference;
00702 typedef value_type const& const_reference;
00703 typedef value_type* pointer;
00704 typedef value_type const* const_pointer;
00705 typedef ss_size_t size_type;
00706 typedef ss_size_t index_type;
00707 typedef ss_ptrdiff_t difference_type;
00708 typedef ss_bool_t bool_type;
00709 typedef
00710 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00711 ss_typename_type_k
00712 #endif
00713 pointer_iterator < value_type
00714 , pointer
00715 , reference
00716 >::type iterator;
00717 typedef
00718 #if !defined(STLSOFT_COMPILER_IS_BORLAND)
00719 ss_typename_type_k
00720 #endif
00721 pointer_iterator < value_type const
00722 , const_pointer
00723 , const_reference
00724 >::type const_iterator;
00725 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00726 typedef reverse_iterator_base < iterator
00727 , value_type
00728 , reference
00729 , pointer
00730 , difference_type
00731 > reverse_iterator;
00732 typedef const_reverse_iterator_base < const_iterator
00733 , value_type const
00734 , const_reference
00735 , const_pointer
00736 , difference_type
00737 > const_reverse_iterator;
00738 #endif
00739
00740
00741 private:
00742 fixed_array_4d(T *data, index_type d0, index_type d1, index_type d2, index_type d3);
00743 public:
00744 fixed_array_4d(index_type d0, index_type d1, index_type d2, index_type d3);
00745 fixed_array_4d(index_type d0, index_type d1, index_type d2, index_type d3, allocator_type const& ator);
00746 fixed_array_4d(index_type d0, index_type d1, index_type d2, index_type d3, value_type const& t);
00747 fixed_array_4d(index_type d0, index_type d1, index_type d2, index_type d3, value_type const& t, allocator_type const& ator);
00748 fixed_array_4d(class_type const& rhs);
00749 ~fixed_array_4d() stlsoft_throw_0();
00750
00751 allocator_type get_allocator() const;
00752
00753 void swap(class_type& rhs) stlsoft_throw_0();
00754
00755
00756 public:
00757 reference at(index_type i0, index_type i1, index_type i2, index_type i3);
00758 const_reference at(index_type i0, index_type i1, index_type i2, index_type i3) const;
00759
00760 reference at_unchecked(index_type i0, index_type i1, index_type i2, index_type i3);
00761 const_reference at_unchecked(index_type i0, index_type i1, index_type i2, index_type i3) const;
00762
00763 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
00764 reference operator ()(index_type i0, index_type i1, index_type i2, index_type i3);
00765 const_reference operator ()(index_type i0, index_type i1, index_type i2, index_type i3) const;
00766 #endif
00767
00768 dimension_element_type at(index_type i0);
00769 const_dimension_element_type at(index_type i0) const;
00770
00771 dimension_element_type at_unchecked(index_type i0);
00772 const_dimension_element_type at_unchecked(index_type i0) const;
00773
00774 dimension_element_type operator [](index_type i0);
00775 const_dimension_element_type operator [](index_type i0) const;
00776
00777 reference front();
00778 reference back();
00779 const_reference front() const;
00780 const_reference back() const;
00781
00782
00783 public:
00784 index_type dimension0() const;
00785 index_type dimension1() const;
00786 index_type dimension2() const;
00787 index_type dimension3() const;
00788 index_type size() const;
00789 bool_type empty() const;
00790 static size_type max_size();
00791
00792
00793 public:
00794 iterator begin();
00795 iterator end();
00796 const_iterator begin() const;
00797 const_iterator end() const;
00798
00799 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
00800 reverse_iterator rbegin();
00801 reverse_iterator rend();
00802 const_reverse_iterator rbegin() const;
00803 const_reverse_iterator rend() const;
00804 #endif
00805
00806
00807 public:
00808 pointer data();
00809 const_pointer data() const;
00810
00811
00812 private:
00813 pointer allocate_(size_type n);
00814 void deallocate_(pointer p, size_type n);
00815
00816 pointer data_();
00817 index_type calc_index_(index_type i0, index_type i1, index_type i2, index_type i3) const;
00818 void range_check_(index_type i0, index_type i1, index_type i2, index_type i3) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00819 void range_check_(index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) );
00820
00821 allocator_type& get_allocator_();
00822
00823
00824 private:
00825 T* m_data;
00826 index_type m_d0;
00827 index_type m_d1;
00828 index_type m_d2;
00829 index_type m_d3;
00830
00831 friend class fixed_array_5d<T, A, P, true>;
00832 friend class fixed_array_5d<T, A, P, false>;
00833
00834
00835 private:
00836 class_type const& operator =(class_type const& rhs);
00837 };
00838
00840
00841
00842 #ifdef STLSOFT_UNITTEST
00843 # include "./unittest/fixed_array_unittest_.h"
00844 #endif
00845
00846
00847
00848
00849
00850 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00851
00852
00853
00854 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00855 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::pointer fixed_array_1d<T, A, P, R>::allocate_(ss_typename_type_k fixed_array_1d<T, A, P, R>::size_type n)
00856 {
00857 allocator_type &ator = *this;
00858
00859 return ator.allocate(n, NULL);
00860 }
00861
00862 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00863 inline void fixed_array_1d<T, A, P, R>::deallocate_(ss_typename_type_k fixed_array_1d<T, A, P, R>::pointer p, ss_typename_type_k fixed_array_1d<T, A, P, R>::size_type n)
00864 {
00865 allocator_type &ator = *this;
00866
00867 ator.deallocate(p, n);
00868 }
00869
00870 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00871 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::pointer fixed_array_1d<T, A, P, R>::data_()
00872 {
00873 return m_data;
00874 }
00875
00876 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00877 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::index_type fixed_array_1d<T, A, P, R>::calc_index_(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const
00878 {
00879 return i0;
00880 }
00881
00882 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00883 inline void fixed_array_1d<T, A, P, R>::range_check_(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
00884 {
00885 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
00886 if(!(i0 < m_d0))
00887 {
00888 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
00889 }
00890 #else
00891 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
00892 #endif
00893 }
00894
00895 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00896 inline ss_typename_type_k fixed_array_1d<T, A, P, R>::allocator_type& fixed_array_1d<T, A, P, R>::get_allocator_()
00897 {
00898 return *this;
00899 }
00900
00901 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00902 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(T* src, ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type d0)
00903 : m_data(src)
00904 , m_d0(d0)
00905 {
00906 STLSOFT_STATIC_ASSERT(!R);
00907 }
00908
00909 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00910 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type d0)
00911 : m_data(allocate_(d0))
00912 , m_d0(d0)
00913 {
00914 STLSOFT_STATIC_ASSERT(R);
00915 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
00916 }
00917
00918 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00919 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_1d<T, A, P, R>::allocator_type const& ator)
00920 : allocator_type(ator)
00921 , m_data(allocate_(d0))
00922 , m_d0(d0)
00923 {
00924 STLSOFT_STATIC_ASSERT(R);
00925 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
00926 }
00927
00928 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00929 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type d0, value_type const& t)
00930 : m_data(allocate_(d0))
00931 , m_d0(d0)
00932 {
00933 STLSOFT_STATIC_ASSERT(R);
00934 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
00935 }
00936
00937 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00938 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type d0, value_type const& t, ss_typename_type_k fixed_array_1d<T, A, P, R>::allocator_type const& ator)
00939 : allocator_type(ator)
00940 , m_data(allocate_(d0))
00941 , m_d0(d0)
00942 {
00943 STLSOFT_STATIC_ASSERT(R);
00944 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
00945 }
00946
00947 #ifdef STLSOFT_MULTIDIM_ARRAY_FEATURE_REQUIRES_COPY_CTOR_WITH_RVO
00948
00949 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00950 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(fixed_array_1d<T, A, P, R> const& rhs)
00951 : m_data(R ? allocate_(rhs.dimension0()) : rhs.m_data)
00952 , m_d0(rhs.dimension0())
00953 {
00954 if(R)
00955 {
00956 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
00957 }
00958 }
00959
00960 #else
00961
00962 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00963 inline fixed_array_1d<T, A, P, R>::fixed_array_1d(fixed_array_1d<T, A, P, R> const& rhs)
00964 : m_data(allocate_(rhs.dimension0()))
00965 , m_d0(rhs.dimension0())
00966 {
00967 STLSOFT_STATIC_ASSERT(R);
00968 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
00969 }
00970
00971 #endif
00972
00973 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00974 inline fixed_array_1d<T, A, P, R>::~fixed_array_1d() stlsoft_throw_0()
00975 {
00976 if(R)
00977 {
00978 array_range_initialiser<T, A, P>::destroy(*this, data_(), size());
00979 deallocate_(m_data, size());
00980 }
00981 }
00982
00983 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00984 inline ss_typename_type_k fixed_array_1d<T, A, P, R>::allocator_type fixed_array_1d<T, A, P, R>::get_allocator() const
00985 {
00986 return *this;
00987 }
00988
00989 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
00990 inline void fixed_array_1d<T, A, P, R>::swap(ss_typename_type_k fixed_array_1d<T, A, P, R>::class_type& rhs) stlsoft_throw_0()
00991 {
00992
00993
00994
00995
00996 std_swap(get_allocator_(), rhs.get_allocator_());
00997 std_swap(m_data, rhs.m_data);
00998 std_swap(m_d0, rhs.m_d0);
00999 }
01000
01001 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01002 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::at(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0)
01003 {
01004 range_check_(i0);
01005
01006 return m_data[i0];
01007 }
01008
01009 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01010 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::at(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const
01011 {
01012 range_check_(i0);
01013
01014 return m_data[i0];
01015 }
01016
01017 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01018 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0)
01019 {
01020 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01021
01022 return m_data[i0];
01023 }
01024
01025 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01026 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const
01027 {
01028 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01029
01030 return m_data[i0];
01031 }
01032
01033 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
01034 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01035 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0)
01036 {
01037 return at_unchecked(i0);
01038 }
01039
01040 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01041 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const
01042 {
01043 return at_unchecked(i0);
01044 }
01045 #endif
01046
01047 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01048 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0)
01049 {
01050 return at_unchecked(i0);
01051 }
01052
01053 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01054 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_1d<T, A, P, R>::index_type i0) const
01055 {
01056 return at_unchecked(i0);
01057 }
01058
01059 #if 0
01060 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01061 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::pointer fixed_array_1d<T, A, P, R>::operator &()
01062 {
01063 return &m_data[0];
01064 }
01065
01066 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01067 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_pointer fixed_array_1d<T, A, P, R>::operator &() const
01068 {
01069 return &m_data[0];
01070 }
01071 #endif
01072
01073 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01074 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::front()
01075 {
01076 return at(0);
01077 }
01078
01079 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01080 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reference fixed_array_1d<T, A, P, R>::back()
01081 {
01082 return at(m_d0 - 1);
01083 }
01084
01085 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01086 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::front() const
01087 {
01088 return at(0);
01089 }
01090
01091 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01092 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reference fixed_array_1d<T, A, P, R>::back() const
01093 {
01094 return at(m_d0 - 1);
01095 }
01096
01097 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01098 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::index_type fixed_array_1d<T, A, P, R>::dimension0() const
01099 {
01100 return m_d0;
01101 }
01102
01103 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01104 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::index_type fixed_array_1d<T, A, P, R>::size() const
01105 {
01106 return m_d0;
01107 }
01108
01109 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01110 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::bool_type fixed_array_1d<T, A, P, R>::empty() const
01111 {
01112 return 0 == size();
01113 }
01114
01115 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01116 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::size_type fixed_array_1d<T, A, P, R>::max_size()
01117 {
01118 return static_cast<size_type>(-1) / sizeof(T);
01119 }
01120
01121 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01122 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::iterator fixed_array_1d<T, A, P, R>::begin()
01123 {
01124 return m_data;
01125 }
01126
01127 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01128 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::iterator fixed_array_1d<T, A, P, R>::end()
01129 {
01130 return m_data + size();
01131 }
01132
01133 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01134 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_iterator fixed_array_1d<T, A, P, R>::begin() const
01135 {
01136 return m_data;
01137 }
01138
01139 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01140 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_iterator fixed_array_1d<T, A, P, R>::end() const
01141 {
01142 return m_data + size();
01143 }
01144
01145 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
01146
01147 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01148 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reverse_iterator fixed_array_1d<T, A, P, R>::rbegin()
01149 {
01150 return reverse_iterator(end());
01151 }
01152
01153 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01154 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::reverse_iterator fixed_array_1d<T, A, P, R>::rend()
01155 {
01156 return reverse_iterator(begin());
01157 }
01158
01159 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01160 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reverse_iterator fixed_array_1d<T, A, P, R>::rbegin() const
01161 {
01162 return const_reverse_iterator(end());
01163 }
01164
01165 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01166 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_reverse_iterator fixed_array_1d<T, A, P, R>::rend() const
01167 {
01168 return const_reverse_iterator(begin());
01169 }
01170
01171 #endif
01172
01173 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01174 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::pointer fixed_array_1d<T, A, P, R>::data()
01175 {
01176 return m_data;
01177 }
01178
01179 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01180 inline ss_typename_type_ret_k fixed_array_1d<T, A, P, R>::const_pointer fixed_array_1d<T, A, P, R>::data() const
01181 {
01182 return m_data;
01183 }
01184
01185
01186
01187
01188 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01189 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::pointer fixed_array_2d<T, A, P, R>::allocate_(ss_typename_type_k fixed_array_2d<T, A, P, R>::size_type n)
01190 {
01191 allocator_type &ator = *this;
01192
01193 return ator.allocate(n, NULL);
01194 }
01195
01196 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01197 inline void fixed_array_2d<T, A, P, R>::deallocate_(ss_typename_type_k fixed_array_2d<T, A, P, R>::pointer p, ss_typename_type_k fixed_array_2d<T, A, P, R>::size_type n)
01198 {
01199 allocator_type &ator = *this;
01200
01201 ator.deallocate(p, n);
01202 }
01203
01204 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01205 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::pointer fixed_array_2d<T, A, P, R>::data_()
01206 {
01207 return m_data;
01208 }
01209
01210 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01211 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::index_type fixed_array_2d<T, A, P, R>::calc_index_(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1) const
01212 {
01213 return (i0 * m_d1) + i1;
01214 }
01215
01216 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01217 inline void fixed_array_2d<T, A, P, R>::range_check_(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
01218 {
01219 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01220 if( !(i0 < m_d0) ||
01221 !(i1 < m_d1))
01222 {
01223 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
01224 }
01225 #else
01226 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1));
01227 #endif
01228 }
01229
01230 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01231 inline ss_typename_type_k fixed_array_2d<T, A, P, R>::allocator_type& fixed_array_2d<T, A, P, R>::get_allocator_()
01232 {
01233 return *this;
01234 }
01235
01236 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01237 inline void fixed_array_2d<T, A, P, R>::range_check_(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
01238 {
01239 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01240 if(!(i0 < m_d0))
01241 {
01242 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
01243 }
01244 #else
01245 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01246 #endif
01247 }
01248
01249 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01250 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(T* src, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d1)
01251 : m_data(src)
01252 , m_d0(d0)
01253 , m_d1(d1)
01254 , m_size(d0 * d1)
01255 {
01256 STLSOFT_STATIC_ASSERT(!R);
01257 }
01258
01259 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01260 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d1)
01261 : m_data(allocate_(d0 * d1))
01262 , m_d0(d0)
01263 , m_d1(d1)
01264 , m_size(d0 * d1)
01265 {
01266 STLSOFT_STATIC_ASSERT(R);
01267 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
01268 }
01269
01270 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01271 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_2d<T, A, P, R>::allocator_type const& ator)
01272 : allocator_type(ator)
01273 , m_data(allocate_(d0 * d1))
01274 , m_d0(d0)
01275 , m_d1(d1)
01276 , m_size(d0 * d1)
01277 {
01278 STLSOFT_STATIC_ASSERT(R);
01279 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
01280 }
01281
01282 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01283 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d1, value_type const& t)
01284 : m_data(allocate_(d0 * d1))
01285 , m_d0(d0)
01286 , m_d1(d1)
01287 , m_size(d0 * d1)
01288 {
01289 STLSOFT_STATIC_ASSERT(R);
01290 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
01291 }
01292
01293 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01294 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type d1, value_type const& t, ss_typename_type_k fixed_array_2d<T, A, P, R>::allocator_type const& ator)
01295 : allocator_type(ator)
01296 , m_data(allocate_(d0 * d1))
01297 , m_d0(d0)
01298 , m_d1(d1)
01299 , m_size(d0 * d1)
01300 {
01301 STLSOFT_STATIC_ASSERT(R);
01302 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
01303 }
01304
01305 #ifdef STLSOFT_MULTIDIM_ARRAY_FEATURE_REQUIRES_COPY_CTOR_WITH_RVO
01306
01307 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01308 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(fixed_array_2d<T, A, P, R> const& rhs)
01309 : m_data(R ? allocate_(rhs.dimension0() * rhs.dimension1()) : rhs.m_data)
01310 , m_d0(rhs.dimension0())
01311 , m_d1(rhs.dimension1())
01312 , m_size(rhs.dimension0() * rhs.dimension1())
01313 {
01314 if(R)
01315 {
01316 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
01317 }
01318 }
01319
01320 #else
01321
01322 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01323 inline fixed_array_2d<T, A, P, R>::fixed_array_2d(fixed_array_2d<T, A, P, R> const& rhs)
01324 : m_data(allocate_(rhs.dimension0() * rhs.dimension1()))
01325 , m_d0(rhs.dimension0())
01326 , m_d1(rhs.dimension1())
01327 , m_size(rhs.dimension0() * rhs.dimension1())
01328 {
01329 STLSOFT_STATIC_ASSERT(R);
01330 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
01331 }
01332
01333 #endif
01334
01335 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01336 inline fixed_array_2d<T, A, P, R>::~fixed_array_2d() stlsoft_throw_0()
01337 {
01338 if(R)
01339 {
01340 array_range_initialiser<T, A, P>::destroy(*this, data_(), size());
01341 deallocate_(m_data, size());
01342 }
01343 }
01344
01345 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01346 inline ss_typename_type_k fixed_array_2d<T, A, P, R>::allocator_type fixed_array_2d<T, A, P, R>::get_allocator() const
01347 {
01348 return *this;
01349 }
01350
01351 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01352 inline void fixed_array_2d<T, A, P, R>::swap(ss_typename_type_k fixed_array_2d<T, A, P, R>::class_type& rhs) stlsoft_throw_0()
01353 {
01354
01355
01356
01357
01358 std_swap(get_allocator_(), rhs.get_allocator_());
01359 std_swap(m_data, rhs.m_data);
01360 std_swap(m_d0, rhs.m_d0);
01361 std_swap(m_d1, rhs.m_d1);
01362 std_swap(m_size, rhs.m_size);
01363 }
01364
01365 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01366 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reference fixed_array_2d<T, A, P, R>::at(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1)
01367 {
01368 range_check_(i0, i1);
01369
01370 return *(m_data + calc_index_(i0, i1));
01371 }
01372
01373 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01374 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reference fixed_array_2d<T, A, P, R>::at(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1) const
01375 {
01376 range_check_(i0, i1);
01377
01378 return *(m_data + calc_index_(i0, i1));
01379 }
01380
01381 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01382 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reference fixed_array_2d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1)
01383 {
01384 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1));
01385
01386 return *(m_data + calc_index_(i0, i1));
01387 }
01388
01389 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01390 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reference fixed_array_2d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1) const
01391 {
01392 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1));
01393
01394 return *(m_data + calc_index_(i0, i1));
01395 }
01396
01397 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
01398 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01399 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reference fixed_array_2d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1)
01400 {
01401 return at_unchecked(i0, i1);
01402 }
01403
01404 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01405 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reference fixed_array_2d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i1) const
01406 {
01407 return at_unchecked(i0, i1);
01408 }
01409 #endif
01410
01411 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01412 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::dimension_element_type fixed_array_2d<T, A, P, R>::at(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0)
01413 {
01414 range_check_(i0);
01415
01416 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01417 }
01418
01419 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01420 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_dimension_element_type fixed_array_2d<T, A, P, R>::at(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0) const
01421 {
01422 range_check_(i0);
01423
01424 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01425 }
01426
01427 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01428 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::dimension_element_type fixed_array_2d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0)
01429 {
01430 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01431
01432 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01433 }
01434
01435 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01436 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_dimension_element_type fixed_array_2d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0) const
01437 {
01438 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01439
01440 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01441 }
01442
01443 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01444 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::dimension_element_type fixed_array_2d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0)
01445 {
01446 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01447
01448 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01449 }
01450
01451 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01452 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_dimension_element_type fixed_array_2d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_2d<T, A, P, R>::index_type i0) const
01453 {
01454 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01455
01456 return dimension_element_type(m_data + i0 * m_d1, m_d1);
01457 }
01458
01459 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01460 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reference fixed_array_2d<T, A, P, R>::front()
01461 {
01462 return at(0, 0);
01463 }
01464
01465 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01466 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reference fixed_array_2d<T, A, P, R>::back()
01467 {
01468 return at(m_d0 - 1, m_d1 - 1);
01469 }
01470
01471 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01472 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reference fixed_array_2d<T, A, P, R>::front() const
01473 {
01474 return at(0, 0);
01475 }
01476
01477 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01478 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reference fixed_array_2d<T, A, P, R>::back() const
01479 {
01480 return at(m_d0 - 1, m_d1 - 1);
01481 }
01482
01483 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01484 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::index_type fixed_array_2d<T, A, P, R>::dimension0() const
01485 {
01486 return m_d0;
01487 }
01488
01489 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01490 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::index_type fixed_array_2d<T, A, P, R>::dimension1() const
01491 {
01492 return m_d1;
01493 }
01494
01495 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01496 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::index_type fixed_array_2d<T, A, P, R>::size() const
01497 {
01498 STLSOFT_ASSERT(m_size == m_d0 * m_d1);
01499
01500 return m_size;
01501 }
01502
01503 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01504 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::bool_type fixed_array_2d<T, A, P, R>::empty() const
01505 {
01506 return 0 == size();
01507 }
01508
01509 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01510 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::size_type fixed_array_2d<T, A, P, R>::max_size()
01511 {
01512 return static_cast<size_type>(-1) / sizeof(T);
01513 }
01514
01515 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01516 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::iterator fixed_array_2d<T, A, P, R>::begin()
01517 {
01518 return m_data;
01519 }
01520
01521 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01522 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::iterator fixed_array_2d<T, A, P, R>::end()
01523 {
01524 return m_data + size();
01525 }
01526
01527 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01528 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_iterator fixed_array_2d<T, A, P, R>::begin() const
01529 {
01530 return m_data;
01531 }
01532
01533 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01534 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_iterator fixed_array_2d<T, A, P, R>::end() const
01535 {
01536 return m_data + size();
01537 }
01538
01539 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
01540
01541 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01542 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reverse_iterator fixed_array_2d<T, A, P, R>::rbegin()
01543 {
01544 return reverse_iterator(end());
01545 }
01546
01547 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01548 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::reverse_iterator fixed_array_2d<T, A, P, R>::rend()
01549 {
01550 return reverse_iterator(begin());
01551 }
01552
01553 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01554 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reverse_iterator fixed_array_2d<T, A, P, R>::rbegin() const
01555 {
01556 return const_reverse_iterator(end());
01557 }
01558
01559 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01560 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_reverse_iterator fixed_array_2d<T, A, P, R>::rend() const
01561 {
01562 return const_reverse_iterator(begin());
01563 }
01564
01565 #endif
01566
01567 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01568 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::pointer fixed_array_2d<T, A, P, R>::data()
01569 {
01570 return m_data;
01571 }
01572
01573 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01574 inline ss_typename_type_ret_k fixed_array_2d<T, A, P, R>::const_pointer fixed_array_2d<T, A, P, R>::data() const
01575 {
01576 return m_data;
01577 }
01578
01579
01580
01581 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01582 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::pointer fixed_array_3d<T, A, P, R>::allocate_(ss_typename_type_k fixed_array_3d<T, A, P, R>::size_type n)
01583 {
01584 allocator_type &ator = *this;
01585
01586 return ator.allocate(n, NULL);
01587 }
01588
01589 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01590 inline void fixed_array_3d<T, A, P, R>::deallocate_(ss_typename_type_k fixed_array_3d<T, A, P, R>::pointer p, ss_typename_type_k fixed_array_3d<T, A, P, R>::size_type n)
01591 {
01592 allocator_type &ator = *this;
01593
01594 ator.deallocate(p, n);
01595 }
01596
01597 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01598 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::pointer fixed_array_3d<T, A, P, R>::data_()
01599 {
01600 return m_data;
01601 }
01602
01603 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01604 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::index_type fixed_array_3d<T, A, P, R>::calc_index_(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2) const
01605 {
01606 return ((i0 * m_d1) + i1) * m_d2 + i2;
01607 }
01608
01609 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01610 inline void fixed_array_3d<T, A, P, R>::range_check_(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
01611 {
01612 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01613 if( !(i0 < m_d0) ||
01614 !(i1 < m_d1) ||
01615 !(i2 < m_d2))
01616 {
01617 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
01618 }
01619 #else
01620 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2));
01621 #endif
01622 }
01623
01624 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01625 inline ss_typename_type_k fixed_array_3d<T, A, P, R>::allocator_type& fixed_array_3d<T, A, P, R>::get_allocator_()
01626 {
01627 return *this;
01628 }
01629
01630 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01631 inline void fixed_array_3d<T, A, P, R>::range_check_(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
01632 {
01633 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
01634 if(!(i0 < m_d0))
01635 {
01636 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
01637 }
01638 #else
01639 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01640 #endif
01641 }
01642
01643 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01644 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(ss_typename_type_k fixed_array_3d<T, A, P, R>::pointer src, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d2)
01645 : m_data(src)
01646 , m_d0(d0)
01647 , m_d1(d1)
01648 , m_d2(d2)
01649 {
01650 STLSOFT_STATIC_ASSERT(!R);
01651 }
01652
01653 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01654 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d2)
01655 : m_data(allocate_(d0 * d1 * d2))
01656 , m_d0(d0)
01657 , m_d1(d1)
01658 , m_d2(d2)
01659 {
01660 STLSOFT_STATIC_ASSERT(R);
01661 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
01662 }
01663
01664 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01665 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d2, ss_typename_type_k fixed_array_3d<T, A, P, R>::allocator_type const& ator)
01666 : allocator_type(ator)
01667 , m_data(allocate_(d0 * d1 * d2))
01668 , m_d0(d0)
01669 , m_d1(d1)
01670 , m_d2(d2)
01671 {
01672 STLSOFT_STATIC_ASSERT(R);
01673 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
01674 }
01675
01676 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01677 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d2, ss_typename_type_k fixed_array_3d<T, A, P, R>::value_type const& t)
01678 : m_data(allocate_(d0 * d1 * d2))
01679 , m_d0(d0)
01680 , m_d1(d1)
01681 , m_d2(d2)
01682 {
01683 STLSOFT_STATIC_ASSERT(R);
01684 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
01685 }
01686
01687 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01688 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type d2, ss_typename_type_k fixed_array_3d<T, A, P, R>::value_type const& t, ss_typename_type_k fixed_array_3d<T, A, P, R>::allocator_type const& ator)
01689 : allocator_type(ator)
01690 , m_data(allocate_(d0 * d1 * d2))
01691 , m_d0(d0)
01692 , m_d1(d1)
01693 , m_d2(d2)
01694 {
01695 STLSOFT_STATIC_ASSERT(R);
01696 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
01697 }
01698
01699 #ifdef STLSOFT_MULTIDIM_ARRAY_FEATURE_REQUIRES_COPY_CTOR_WITH_RVO
01700
01701 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01702 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(fixed_array_3d<T, A, P, R> const& rhs)
01703 : m_data(R ? allocate_(rhs.dimension0() * rhs.dimension1() * rhs.dimension2()) : rhs.m_data)
01704 , m_d0(rhs.dimension0())
01705 , m_d1(rhs.dimension1())
01706 , m_d2(rhs.dimension2())
01707 {
01708 if(R)
01709 {
01710 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
01711 }
01712 }
01713
01714 #else
01715
01716 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01717 inline fixed_array_3d<T, A, P, R>::fixed_array_3d(fixed_array_3d<T, A, P, R> const& rhs)
01718 : m_data(allocate_(rhs.dimension0() * rhs.dimension1() * rhs.dimension2()))
01719 , m_d0(rhs.dimension0())
01720 , m_d1(rhs.dimension1())
01721 , m_d2(rhs.dimension2())
01722 {
01723 STLSOFT_STATIC_ASSERT(R);
01724 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
01725 }
01726
01727 #endif
01728
01729 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01730 inline fixed_array_3d<T, A, P, R>::~fixed_array_3d() stlsoft_throw_0()
01731 {
01732 if(R)
01733 {
01734 array_range_initialiser<T, A, P>::destroy(*this, data_(), size());
01735 deallocate_(m_data, size());
01736 }
01737 }
01738
01739 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01740 inline ss_typename_type_k fixed_array_3d<T, A, P, R>::allocator_type fixed_array_3d<T, A, P, R>::get_allocator() const
01741 {
01742 return *this;
01743 }
01744
01745 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01746 inline void fixed_array_3d<T, A, P, R>::swap(ss_typename_type_k fixed_array_3d<T, A, P, R>::class_type& rhs) stlsoft_throw_0()
01747 {
01748
01749
01750
01751
01752 std_swap(get_allocator_(), rhs.get_allocator_());
01753 std_swap(m_data, rhs.m_data);
01754 std_swap(m_d0, rhs.m_d0);
01755 std_swap(m_d1, rhs.m_d1);
01756 std_swap(m_d2, rhs.m_d2);
01757 }
01758
01759 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01760 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reference fixed_array_3d<T, A, P, R>::at(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2)
01761 {
01762 range_check_(i0, i1, i2);
01763
01764 return *(m_data + calc_index_(i0, i1, i2));
01765 }
01766
01767 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01768 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reference fixed_array_3d<T, A, P, R>::at(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2) const
01769 {
01770 range_check_(i0, i1, i2);
01771
01772 return *(m_data + calc_index_(i0, i1, i2));
01773 }
01774
01775 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01776 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reference fixed_array_3d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2)
01777 {
01778 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2));
01779
01780 return *(m_data + calc_index_(i0, i1, i2));
01781 }
01782
01783 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01784 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reference fixed_array_3d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2) const
01785 {
01786 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2));
01787
01788 return *(m_data + calc_index_(i0, i1, i2));
01789 }
01790
01791 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
01792 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01793 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reference fixed_array_3d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2)
01794 {
01795 return at_unchecked(i0, i1, i2);
01796 }
01797
01798 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01799 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reference fixed_array_3d<T, A, P, R>::operator ()(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i1, ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i2) const
01800 {
01801 return at_unchecked(i0, i1, i2);
01802 }
01803 #endif
01804
01805 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01806 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::dimension_element_type fixed_array_3d<T, A, P, R>::at(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0)
01807 {
01808 range_check_(i0);
01809
01810 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01811 }
01812
01813 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01814 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_dimension_element_type fixed_array_3d<T, A, P, R>::at(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0) const
01815 {
01816 range_check_(i0);
01817
01818 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01819 }
01820
01821 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01822 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::dimension_element_type fixed_array_3d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0)
01823 {
01824 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01825
01826 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01827 }
01828
01829 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01830 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_dimension_element_type fixed_array_3d<T, A, P, R>::at_unchecked(ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0) const
01831 {
01832 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01833
01834 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01835 }
01836
01837 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01838 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::dimension_element_type fixed_array_3d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0)
01839 {
01840 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01841
01842 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01843 }
01844
01845 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01846 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_dimension_element_type fixed_array_3d<T, A, P, R>::operator [](ss_typename_type_k fixed_array_3d<T, A, P, R>::index_type i0) const
01847 {
01848 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
01849
01850 return dimension_element_type(m_data + i0 * m_d1 * m_d2, m_d1, m_d2);
01851 }
01852
01853 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01854 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reference fixed_array_3d<T, A, P, R>::front()
01855 {
01856 return at(0, 0, 0);
01857 }
01858
01859 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01860 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reference fixed_array_3d<T, A, P, R>::back()
01861 {
01862 return at(m_d0 - 1, m_d1 - 1, m_d2 - 1);
01863 }
01864
01865 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01866 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reference fixed_array_3d<T, A, P, R>::front() const
01867 {
01868 return at(0, 0, 0);
01869 }
01870
01871 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01872 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reference fixed_array_3d<T, A, P, R>::back() const
01873 {
01874 return at(m_d0 - 1, m_d1 - 1, m_d2 - 1);
01875 }
01876
01877 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01878 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::index_type fixed_array_3d<T, A, P, R>::dimension0() const
01879 {
01880 return m_d0;
01881 }
01882
01883 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01884 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::index_type fixed_array_3d<T, A, P, R>::dimension1() const
01885 {
01886 return m_d1;
01887 }
01888
01889 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01890 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::index_type fixed_array_3d<T, A, P, R>::dimension2() const
01891 {
01892 return m_d2;
01893 }
01894
01895 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01896 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::index_type fixed_array_3d<T, A, P, R>::size() const
01897 {
01898 return m_d0 * m_d1 * m_d2;
01899 }
01900
01901 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01902 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::bool_type fixed_array_3d<T, A, P, R>::empty() const
01903 {
01904 return 0 == size();
01905 }
01906
01907 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01908 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::size_type fixed_array_3d<T, A, P, R>::max_size()
01909 {
01910 return static_cast<size_type>(-1) / sizeof(T);
01911 }
01912
01913 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01914 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::iterator fixed_array_3d<T, A, P, R>::begin()
01915 {
01916 return m_data;
01917 }
01918
01919 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01920 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::iterator fixed_array_3d<T, A, P, R>::end()
01921 {
01922 return m_data + size();
01923 }
01924
01925 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01926 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_iterator fixed_array_3d<T, A, P, R>::begin() const
01927 {
01928 return m_data;
01929 }
01930
01931 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01932 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_iterator fixed_array_3d<T, A, P, R>::end() const
01933 {
01934 return m_data + size();
01935 }
01936
01937 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
01938
01939 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01940 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reverse_iterator fixed_array_3d<T, A, P, R>::rbegin()
01941 {
01942 return reverse_iterator(end());
01943 }
01944
01945 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01946 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::reverse_iterator fixed_array_3d<T, A, P, R>::rend()
01947 {
01948 return reverse_iterator(begin());
01949 }
01950
01951 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01952 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reverse_iterator fixed_array_3d<T, A, P, R>::rbegin() const
01953 {
01954 return const_reverse_iterator(end());
01955 }
01956
01957 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01958 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_reverse_iterator fixed_array_3d<T, A, P, R>::rend() const
01959 {
01960 return const_reverse_iterator(begin());
01961 }
01962
01963 #endif
01964
01965 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01966 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::pointer fixed_array_3d<T, A, P, R>::data()
01967 {
01968 return m_data;
01969 }
01970
01971 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01972 inline ss_typename_type_ret_k fixed_array_3d<T, A, P, R>::const_pointer fixed_array_3d<T, A, P, R>::data() const
01973 {
01974 return m_data;
01975 }
01976
01977
01978
01979 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01980 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::pointer fixed_array_4d<T, A, P, R>::allocate_(ss_typename_type_k fixed_array_4d<T, A, P, R>::size_type n)
01981 {
01982 allocator_type &ator = *this;
01983
01984 return ator.allocate(n, NULL);
01985 }
01986
01987 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01988 inline void fixed_array_4d<T, A, P, R>::deallocate_(ss_typename_type_k fixed_array_4d<T, A, P, R>::pointer p, ss_typename_type_k fixed_array_4d<T, A, P, R>::size_type n)
01989 {
01990 allocator_type &ator = *this;
01991
01992 ator.deallocate(p, n);
01993 }
01994
01995 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
01996 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::pointer fixed_array_4d<T, A, P, R>::data_()
01997 {
01998 return m_data;
01999 }
02000
02001 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02002 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::calc_index_(ss_typename_type_k fixed_array_4d<T, A, P, R>::index_type i0, index_type i1, index_type i2, index_type i3) const
02003 {
02004 return (((i0 * m_d1) + i1) * m_d2 + i2) * m_d3 + i3;
02005 }
02006
02007 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02008 inline void fixed_array_4d<T, A, P, R>::range_check_(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
02009 {
02010 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
02011 if( !(i0 < m_d0) ||
02012 !(i1 < m_d1) ||
02013 !(i2 < m_d2) ||
02014 !(i3 < m_d3))
02015 {
02016 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
02017 }
02018 #else
02019 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2 && i3 < m_d3));
02020 #endif
02021 }
02022
02023 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02024 inline ss_typename_type_k fixed_array_4d<T, A, P, R>::allocator_type& fixed_array_4d<T, A, P, R>::get_allocator_()
02025 {
02026 return *this;
02027 }
02028
02029 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02030 inline void fixed_array_4d<T, A, P, R>::range_check_(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0) const stlsoft_throw_1(stlsoft_ns_qual_std(out_of_range) )
02031 {
02032 #ifdef STLSOFT_CF_EXCEPTION_SUPPORT
02033 if(!(i0 < m_d0))
02034 {
02035 STLSOFT_THROW_X(stlsoft_ns_qual_std(out_of_range)("fixed array index out of range"));
02036 }
02037 #else
02038 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
02039 #endif
02040 }
02041
02042 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02043 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(T* src, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d3)
02044 : m_data(src)
02045 , m_d0(d0)
02046 , m_d1(d1)
02047 , m_d2(d2)
02048 , m_d3(d3)
02049 {
02050 STLSOFT_STATIC_ASSERT(!R);
02051 }
02052
02053 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02054 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d3)
02055 : m_data(allocate_(d0 * d1 * d2 * d3))
02056 , m_d0(d0)
02057 , m_d1(d1)
02058 , m_d2(d2)
02059 , m_d3(d3)
02060 {
02061 STLSOFT_STATIC_ASSERT(R);
02062 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
02063 }
02064
02065 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02066 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d3, ss_typename_param_k fixed_array_4d<T, A, P, R>::allocator_type const& ator)
02067 : allocator_type(ator)
02068 , m_data(allocate_(d0 * d1 * d2 * d3))
02069 , m_d0(d0)
02070 , m_d1(d1)
02071 , m_d2(d2)
02072 , m_d3(d3)
02073 {
02074 STLSOFT_STATIC_ASSERT(R);
02075 array_range_initialiser<T, A, P>::construct(*this, data_(), size());
02076 }
02077
02078 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02079 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d3, ss_typename_param_k fixed_array_4d<T, A, P, R>::value_type const& t)
02080 : m_data(allocate_(d0 * d1 * d2 * d3))
02081 , m_d0(d0)
02082 , m_d1(d1)
02083 , m_d2(d2)
02084 , m_d3(d3)
02085 {
02086 STLSOFT_STATIC_ASSERT(R);
02087 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
02088 }
02089
02090 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02091 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type d3, ss_typename_param_k fixed_array_4d<T, A, P, R>::value_type const& t, ss_typename_param_k fixed_array_4d<T, A, P, R>::allocator_type const& ator)
02092 : allocator_type(ator)
02093 , m_data(allocate_(d0 * d1 * d2 * d3))
02094 , m_d0(d0)
02095 , m_d1(d1)
02096 , m_d2(d2)
02097 , m_d3(d3)
02098 {
02099 STLSOFT_STATIC_ASSERT(R);
02100 array_range_initialiser<T, A, P>::construct(*this, data_(), size(), t);
02101 }
02102
02103 #ifdef STLSOFT_MULTIDIM_ARRAY_FEATURE_REQUIRES_COPY_CTOR_WITH_RVO
02104
02105 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02106 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(fixed_array_4d<T, A, P, R> const& rhs)
02107 : m_data(R ? allocate_(rhs.dimension0() * rhs.dimension1() * rhs.dimension2() * rhs.dimension3()) : rhs.m_data)
02108 , m_d0(rhs.dimension0())
02109 , m_d1(rhs.dimension1())
02110 , m_d2(rhs.dimension2())
02111 , m_d3(rhs.dimension3())
02112 {
02113 if(R)
02114 {
02115 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
02116 }
02117 }
02118
02119 #else
02120
02121 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02122 inline fixed_array_4d<T, A, P, R>::fixed_array_4d(fixed_array_4d<T, A, P, R> const& rhs)
02123 : m_data(allocate_(rhs.dimension0() * rhs.dimension1() * rhs.dimension2() * rhs.dimension3()))
02124 , m_d0(rhs.dimension0())
02125 , m_d1(rhs.dimension1())
02126 , m_d2(rhs.dimension2())
02127 , m_d3(rhs.dimension3())
02128 {
02129 STLSOFT_STATIC_ASSERT(R);
02130 array_range_initialiser<T, A, P>::copy_construct(*this, data_(), rhs.data(), size());
02131 }
02132
02133 #endif
02134
02135 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02136 inline fixed_array_4d<T, A, P, R>::~fixed_array_4d() stlsoft_throw_0()
02137 {
02138 if(R)
02139 {
02140 array_range_initialiser<T, A, P>::destroy(*this, data_(), size());
02141 deallocate_(m_data, size());
02142 }
02143 }
02144
02145 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02146 inline ss_typename_type_k fixed_array_4d<T, A, P, R>::allocator_type fixed_array_4d<T, A, P, R>::get_allocator() const
02147 {
02148 return *this;
02149 }
02150
02151 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02152 inline void fixed_array_4d<T, A, P, R>::swap(ss_typename_type_k fixed_array_4d<T, A, P, R>::class_type& rhs) stlsoft_throw_0()
02153 {
02154
02155
02156
02157
02158 std_swap(get_allocator_(), rhs.get_allocator_());
02159 std_swap(m_data, rhs.m_data);
02160 std_swap(m_d0, rhs.m_d0);
02161 std_swap(m_d1, rhs.m_d1);
02162 std_swap(m_d2, rhs.m_d2);
02163 std_swap(m_d3, rhs.m_d3);
02164 }
02165
02166 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02167 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reference fixed_array_4d<T, A, P, R>::at(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3)
02168 {
02169 range_check_(i0, i1, i2, i3);
02170
02171 return *(m_data + calc_index_(i0, i1, i2, i3));
02172 }
02173
02174 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02175 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reference fixed_array_4d<T, A, P, R>::at(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3) const
02176 {
02177 range_check_(i0, i1, i2, i3);
02178
02179 return *(m_data + calc_index_(i0, i1, i2, i3));
02180 }
02181
02182 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02183 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reference fixed_array_4d<T, A, P, R>::at_unchecked(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3)
02184 {
02185 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2 && i3 < m_d3));
02186
02187 return *(m_data + calc_index_(i0, i1, i2, i3));
02188 }
02189
02190 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02191 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reference fixed_array_4d<T, A, P, R>::at_unchecked(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3) const
02192 {
02193 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", (i0 < m_d0 && i1 < m_d1 && i2 < m_d2 && i3 < m_d3));
02194
02195 return *(m_data + calc_index_(i0, i1, i2, i3));
02196 }
02197
02198 #ifndef STLSOFT_FIXED_ARRAY_NO_FUNCTION_OP
02199 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02200 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reference fixed_array_4d<T, A, P, R>::operator ()(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3)
02201 {
02202 return at_unchecked(i0, i1, i2, i3);
02203 }
02204
02205 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02206 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reference fixed_array_4d<T, A, P, R>::operator ()(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i1, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i2, ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i3) const
02207 {
02208 return at_unchecked(i0, i1, i2, i3);
02209 }
02210 #endif
02211
02212 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02213 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::dimension_element_type fixed_array_4d<T, A, P, R>::at(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0)
02214 {
02215 range_check_(i0);
02216
02217 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02218 }
02219
02220 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02221 inline ss_typename_type_k fixed_array_4d<T, A, P, R>::const_dimension_element_type fixed_array_4d<T, A, P, R>::at(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0) const
02222 {
02223 range_check_(i0);
02224
02225 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02226 }
02227
02228 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02229 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::dimension_element_type fixed_array_4d<T, A, P, R>::at_unchecked(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0)
02230 {
02231 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
02232
02233 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02234 }
02235
02236 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02237 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_dimension_element_type fixed_array_4d<T, A, P, R>::at_unchecked(ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0) const
02238 {
02239 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
02240
02241 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02242 }
02243
02244 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02245 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::dimension_element_type fixed_array_4d<T, A, P, R>::operator [](ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0)
02246 {
02247 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
02248
02249 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02250 }
02251
02252 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02253 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_dimension_element_type fixed_array_4d<T, A, P, R>::operator [](ss_typename_param_k fixed_array_4d<T, A, P, R>::index_type i0) const
02254 {
02255 STLSOFT_MESSAGE_ASSERT("fixed array index out of range", i0 < m_d0);
02256
02257 return dimension_element_type(m_data + i0 * m_d1 * m_d2 * m_d3, m_d1, m_d2, m_d3);
02258 }
02259
02260 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02261 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reference fixed_array_4d<T, A, P, R>::front()
02262 {
02263 return at(0, 0, 0, 0);
02264 }
02265
02266 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02267 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reference fixed_array_4d<T, A, P, R>::back()
02268 {
02269 return at(m_d0 - 1, m_d1 - 1, m_d2 - 1, m_d3 - 1);
02270 }
02271
02272 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02273 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reference fixed_array_4d<T, A, P, R>::front() const
02274 {
02275 return at(0, 0, 0, 0);
02276 }
02277
02278 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02279 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reference fixed_array_4d<T, A, P, R>::back() const
02280 {
02281 return at(m_d0 - 1, m_d1 - 1, m_d2 - 1, m_d3 - 1);
02282 }
02283
02284 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02285 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::dimension0() const
02286 {
02287 return m_d0;
02288 }
02289
02290 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02291 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::dimension1() const
02292 {
02293 return m_d1;
02294 }
02295
02296 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02297 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::dimension2() const
02298 {
02299 return m_d2;
02300 }
02301
02302 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02303 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::dimension3() const
02304 {
02305 return m_d3;
02306 }
02307
02308 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02309 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::index_type fixed_array_4d<T, A, P, R>::size() const
02310 {
02311 return m_d0 * m_d1 * m_d2 * m_d3;
02312 }
02313
02314 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02315 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::bool_type fixed_array_4d<T, A, P, R>::empty() const
02316 {
02317 return 0 == size();
02318 }
02319
02320 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02321 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::size_type fixed_array_4d<T, A, P, R>::max_size()
02322 {
02323 return static_cast<size_type>(-1) / sizeof(T);
02324 }
02325
02326 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02327 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::iterator fixed_array_4d<T, A, P, R>::begin()
02328 {
02329 return m_data;
02330 }
02331
02332 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02333 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::iterator fixed_array_4d<T, A, P, R>::end()
02334 {
02335 return m_data + size();
02336 }
02337
02338 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02339 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_iterator fixed_array_4d<T, A, P, R>::begin() const
02340 {
02341 return m_data;
02342 }
02343
02344 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02345 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_iterator fixed_array_4d<T, A, P, R>::end() const
02346 {
02347 return m_data + size();
02348 }
02349
02350 #if defined(STLSOFT_LF_BIDIRECTIONAL_ITERATOR_SUPPORT)
02351
02352 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02353 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reverse_iterator fixed_array_4d<T, A, P, R>::rbegin()
02354 {
02355 return reverse_iterator(end());
02356 }
02357
02358 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02359 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::reverse_iterator fixed_array_4d<T, A, P, R>::rend()
02360 {
02361 return reverse_iterator(begin());
02362 }
02363
02364 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02365 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reverse_iterator fixed_array_4d<T, A, P, R>::rbegin() const
02366 {
02367 return const_reverse_iterator(end());
02368 }
02369
02370 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02371 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_reverse_iterator fixed_array_4d<T, A, P, R>::rend() const
02372 {
02373 return const_reverse_iterator(begin());
02374 }
02375
02376 #endif
02377
02378 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02379 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::pointer fixed_array_4d<T, A, P, R>::data()
02380 {
02381 return m_data;
02382 }
02383
02384 template <ss_typename_param_k T, ss_typename_param_k A, ss_typename_param_k P, ss_bool_t R>
02385 inline ss_typename_type_ret_k fixed_array_4d<T, A, P, R>::const_pointer fixed_array_4d<T, A, P, R>::data() const
02386 {
02387 return m_data;
02388 }
02389
02390 #endif
02391
02392
02393
02394
02395
02396 template< ss_typename_param_k T
02397 , ss_typename_param_k A
02398 , ss_typename_param_k P
02399 , ss_bool_t R
02400 >
02401 inline ss_size_t array_size(fixed_array_1d<T, A, P, R> const& ar)
02402 {
02403 return ar.size();
02404 }
02405
02406 template< ss_typename_param_k T
02407 , ss_typename_param_k A
02408 , ss_typename_param_k P
02409 , ss_bool_t R
02410 >
02411 inline ss_size_t array_size(fixed_array_2d<T, A, P, R> const& ar)
02412 {
02413 return ar.size();
02414 }
02415
02416 template< ss_typename_param_k T
02417 , ss_typename_param_k A
02418 , ss_typename_param_k P
02419 , ss_bool_t R
02420 >
02421 inline ss_size_t array_size(fixed_array_3d<T, A, P, R> const& ar)
02422 {
02423 return ar.size();
02424 }
02425
02426 template< ss_typename_param_k T
02427 , ss_typename_param_k A
02428 , ss_typename_param_k P
02429 , ss_bool_t R
02430 >
02431 inline ss_size_t array_size(fixed_array_4d<T, A, P, R> const& ar)
02432 {
02433 return ar.size();
02434 }
02435
02436 #if 0
02437 template< ss_typename_param_k T
02438 , ss_typename_param_k A
02439 , ss_typename_param_k P
02440 , ss_bool_t R
02441 >
02442 inline ss_size_t array_size(fixed_array_5d<T, A, P, R> const& ar)
02443 {
02444 return ar.size();
02445 }
02446 #endif
02447
02448
02449
02450 #ifndef _STLSOFT_NO_NAMESPACE
02451 }
02452 #endif
02453
02454
02455
02456 #endif
02457
02458