shards  Version of the Day
 All Classes Functions Variables Typedefs Enumerations Enumerator Groups
Shards_ArrayVector.hpp
1 // @HEADER
2 // *****************************************************************************
3 // Shards : Shared Discretization Tools
4 //
5 // Copyright 2008-2011 NTESS and the Shards contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 #ifndef Shards_ArrayVector_hpp
11 #define Shards_ArrayVector_hpp
12 
13 //----------------------------------------------------------------------
14 
15 #include <Shards_Array.hpp>
16 
17 //----------------------------------------------------------------------
18 
19 namespace shards {
20 
25 template< typename Scalar , ArrayOrder Order ,
26  class Tag1 = void , class Tag2 = void ,
27  class Tag3 = void , class Tag4 = void ,
28  class Tag5 = void , class Tag6 = void ,
29  class Tag7 = void , class Tag8 = void >
30 class ArrayVector ;
31 
32 //----------------------------------------------------------------------
33 
34 template< typename Scalar , ArrayOrder Order >
35 class ArrayVector<Scalar,Order,void,void,void,void, void,void,void,void>
36  : public Array<Scalar,Order,void,void,void,void, void,void,void,void>
37 {
38 private:
39  std::vector<Scalar> m_storage ;
40 
41  typedef
42  Array<Scalar,Order,void,void,void,void, void,void,void,void>
43  BaseType ;
44 
45  ArrayVector( const ArrayVector & );
46  ArrayVector & operator = ( const ArrayVector & );
47 
48  Scalar * get_ptr() { return m_storage.empty() ? NULL : & m_storage[0] ; }
49 
50 public:
51 
52  typedef array_traits::int_t size_type ;
53 
54  ArrayVector()
55  : BaseType() , m_storage() {}
56 
57  ~ArrayVector() {}
58 
59  template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
60  class Tag5 , class Tag6 , class Tag7 , class Tag8 >
61  void resize( const size_type n1 , const size_type n2 ,
62  const size_type n3 , const size_type n4 ,
63  const size_type n5 , const size_type n6 ,
64  const size_type n7 , const size_type n8 )
65  {
66  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 * n8 );
67  BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
68  ( get_ptr() ,n1,n2,n3,n4,n5,n6,n7,n8);
69  }
70 
71  template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
72  class Tag5 , class Tag6 , class Tag7 >
73  void resize( const size_type n1 , const size_type n2 ,
74  const size_type n3 , const size_type n4 ,
75  const size_type n5 , const size_type n6 ,
76  const size_type n7 )
77  {
78  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 );
79  BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7>
80  ( get_ptr() ,n1,n2,n3,n4,n5,n6,n7);
81  }
82 
83  template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
84  class Tag5 , class Tag6 >
85  void resize( const size_type n1 , const size_type n2 ,
86  const size_type n3 , const size_type n4 ,
87  const size_type n5 , const size_type n6 )
88  {
89  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 );
90  BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6>
91  ( get_ptr() ,n1,n2,n3,n4,n5,n6);
92  }
93 
94  template< class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
95  class Tag5 >
96  void resize( const size_type n1 , const size_type n2 ,
97  const size_type n3 , const size_type n4 ,
98  const size_type n5 )
99  {
100  m_storage.resize( n1 * n2 * n3 * n4 * n5 );
101  BaseType::template assign<Tag1,Tag2,Tag3,Tag4,Tag5>
102  ( get_ptr(),n1,n2,n3,n4,n5);
103  }
104 
105  template< class Tag1 , class Tag2 , class Tag3 , class Tag4 >
106  void resize( const size_type n1 , const size_type n2 ,
107  const size_type n3 , const size_type n4 )
108  {
109  m_storage.resize( n1 * n2 * n3 * n4 );
110  BaseType::template assign<Tag1,Tag2,Tag3,Tag4>
111  ( get_ptr(),n1,n2,n3,n4);
112  }
113 
114  template< class Tag1 , class Tag2 , class Tag3 >
115  void resize( const size_type n1 , const size_type n2 ,
116  const size_type n3 )
117  {
118  m_storage.resize( n1 * n2 * n3 );
119  BaseType::template assign<Tag1,Tag2,Tag3>
120  ( get_ptr(),n1,n2,n3);
121  }
122 
123  template< class Tag1 , class Tag2 >
124  void resize( const size_type n1 , const size_type n2 )
125  {
126  m_storage.resize( n1 * n2 );
127  BaseType::template assign<Tag1,Tag2>( get_ptr(),n1,n2);
128  }
129 
130  template< class Tag1 >
131  void resize( const size_type n1 )
132  {
133  m_storage.resize( n1 );
134  BaseType::template assign<Tag1>( get_ptr(),n1);
135  }
136 };
137 
138 //----------------------------------------------------------------------
139 
140 template< typename Scalar , ArrayOrder Order ,
141  class Tag1 , class Tag2 , class Tag3 , class Tag4 ,
142  class Tag5 , class Tag6 , class Tag7 , class Tag8 >
143 class ArrayVector
144  : public Array<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
145 {
146 private:
147  std::vector<Scalar> m_storage ;
148 
149  typedef
150  array_traits::Helper<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
151  help_type ;
152 
153  typedef
154  Array<Scalar,Order,Tag1,Tag2,Tag3,Tag4,Tag5,Tag6,Tag7,Tag8>
155  BaseType ;
156 
157  ArrayVector( const ArrayVector & );
158  ArrayVector & operator = ( const ArrayVector & );
159 
160  Scalar * get_ptr() { return m_storage.empty() ? NULL : & m_storage[0] ; }
161 
162 public:
163 
164  typedef array_traits::int_t size_type ;
165 
166  ArrayVector()
167  : BaseType() , m_storage() {}
168 
169  ~ArrayVector() {}
170 
171  void resize( const size_type * const dims )
172  {
173  help_type::assign( BaseType::m_stride , dims );
174  const typename BaseType::size_type n = BaseType::size();
175  m_storage.resize( n );
176  BaseType::m_ptr = get_ptr();
177  }
178 
179  void resize( const size_type n1 , const size_type n2 ,
180  const size_type n3 , const size_type n4 ,
181  const size_type n5 , const size_type n6 ,
182  const size_type n7 , const size_type n8 )
183  {
184  array_traits::CheckRank<8,BaseType::Rank>::ok();
185  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 * n8 );
186  BaseType::assign( get_ptr() ,n1,n2,n3,n4,n5,n6,n7,n8);
187  }
188 
189  void resize( const size_type n1 , const size_type n2 ,
190  const size_type n3 , const size_type n4 ,
191  const size_type n5 , const size_type n6 ,
192  const size_type n7 )
193  {
194  array_traits::CheckRank<7,BaseType::Rank>::ok();
195  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 * n7 );
196  BaseType::assign( get_ptr(),n1,n2,n3,n4,n5,n6,n7);
197  }
198 
199  void resize( const size_type n1 , const size_type n2 ,
200  const size_type n3 , const size_type n4 ,
201  const size_type n5 , const size_type n6 )
202  {
203  array_traits::CheckRank<6,BaseType::Rank>::ok();
204  m_storage.resize( n1 * n2 * n3 * n4 * n5 * n6 );
205  BaseType::assign( get_ptr(),n1,n2,n3,n4,n5,n6);
206  }
207 
208  void resize( const size_type n1 , const size_type n2 ,
209  const size_type n3 , const size_type n4 ,
210  const size_type n5 )
211  {
212  array_traits::CheckRank<5,BaseType::Rank>::ok();
213  m_storage.resize( n1 * n2 * n3 * n4 * n5 );
214  BaseType::assign( get_ptr(),n1,n2,n3,n4,n5);
215  }
216 
217  void resize( const size_type n1 , const size_type n2 ,
218  const size_type n3 , const size_type n4 )
219  {
220  array_traits::CheckRank<4,BaseType::Rank>::ok();
221  m_storage.resize( n1 * n2 * n3 * n4 );
222  BaseType::assign( get_ptr(),n1,n2,n3,n4);
223  }
224 
225  void resize( const size_type n1 , const size_type n2 ,
226  const size_type n3 )
227  {
228  array_traits::CheckRank<3,BaseType::Rank>::ok();
229  m_storage.resize( n1 * n2 * n3 );
230  BaseType::assign( get_ptr(),n1,n2,n3);
231  }
232 
233  void resize( const size_type n1 , const size_type n2 )
234  {
235  array_traits::CheckRank<2,BaseType::Rank>::ok();
236  m_storage.resize( n1 * n2 );
237  BaseType::assign( get_ptr(),n1,n2);
238  }
239 
240  void resize( const size_type n1 )
241  {
242  array_traits::CheckRank<1,BaseType::Rank>::ok();
243  m_storage.resize( n1 );
244  BaseType::assign( get_ptr(),n1);
245  }
246 
247 
248  ArrayVector( const size_type * const dims )
249  : BaseType(), m_storage() { resize( dims ); }
250 
251  ArrayVector( const size_type n1 , const size_type n2 ,
252  const size_type n3 , const size_type n4 ,
253  const size_type n5 , const size_type n6 ,
254  const size_type n7 , const size_type n8 )
255  : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6,n7,n8); }
256 
257  ArrayVector( const size_type n1 , const size_type n2 ,
258  const size_type n3 , const size_type n4 ,
259  const size_type n5 , const size_type n6 ,
260  const size_type n7 )
261  : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6,n7); }
262 
263  ArrayVector( const size_type n1 , const size_type n2 ,
264  const size_type n3 , const size_type n4 ,
265  const size_type n5 , const size_type n6 )
266  : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5,n6); }
267 
268  ArrayVector( const size_type n1 , const size_type n2 ,
269  const size_type n3 , const size_type n4 ,
270  const size_type n5 )
271  : BaseType(), m_storage() { resize(n1,n2,n3,n4,n5); }
272 
273  ArrayVector( const size_type n1 , const size_type n2 ,
274  const size_type n3 , const size_type n4 )
275  : BaseType(), m_storage() { resize(n1,n2,n3,n4); }
276 
277  ArrayVector( const size_type n1 , const size_type n2 ,
278  const size_type n3 )
279  : BaseType(), m_storage() { resize(n1,n2,n3); }
280 
281  ArrayVector( const size_type n1 , const size_type n2 )
282  : BaseType(), m_storage() { resize(n1,n2); }
283 
284  ArrayVector( const size_type n1 )
285  : BaseType(), m_storage() { resize(n1); }
286 
287 };
288 
291 }
292 
293 #endif /* Shards_ArrayVector_hpp */
294 
shards::ArrayOrder
ArrayOrder
Define Natural (C-language) or Fortran ordering of array dimensions. A RankZero array does not ha...
Definition: Shards_Array.hpp:46
shards::Array::size
size_type size() const
Total number of member data items.
Definition: Shards_Array.hpp:3665
shards::Array::assign
Array & assign(value_type *arg_ptr, const size_type *const dims)
Assign pointer and dimensions.
Definition: Shards_Array.hpp:3801
shards::Array::size_type
array_traits::int_t size_type
Type for sizes.
Definition: Shards_Array.hpp:3599