source: XIOS/dev/dev_ym/XIOS_COUPLING/src/array_new.hpp @ 1875

Last change on this file since 1875 was 1875, checked in by ymipsl, 4 years ago

XIOS coupling branch
Some updates.

First coupling test is beginning to work...

YM
  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 32.4 KB
Line 
1#ifndef __XIOS_ARRAY_HPP__
2#define __XIOS_ARRAY_HPP__
3
4#define BZ_COLUMN_MAJOR_ARRAY
5#include <blitz/array.h>
6#include "buffer_in.hpp"
7#include "buffer_out.hpp"
8#include "message.hpp"
9#include "tv_data_display.h"
10#ifdef __GNUC__
11#include <typeinfo>
12#include <cxxabi.h>
13#endif
14#include <cmath>
15
16using namespace blitz;
17BZ_DECLARE_FUNCTION(round)
18
19namespace xios
20{
21  template <typename T_numtype,int N_rank>
22  class CArray ;
23
24 template <typename T_numtype,int N_rank>
25 int TV_ttf_display_type ( const CArray<T_numtype, N_rank>* array ) ;
26}
27
28template <typename T_numtype,int N_rank>
29int TV_ttf_display_type ( const xios::CArray<T_numtype, N_rank>* array ) ;
30
31namespace xios
32{
33  template <typename T_numtype,int N_rank>
34  class CArray : public Array<T_numtype,N_rank>, public virtual CBaseType
35  {
36    private:
37      bool initialized;
38      void inc_symbol(void)
39      {
40        TV_ttf_display_type(this);
41      }
42    public:
43      typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage;
44      using Array<T_numtype,N_rank>::operator =;
45
46      template<typename T_expr> explicit CArray(_bz_ArrayExpr<T_expr> expr)
47        : Array<T_numtype,N_rank>(expr)
48        , initialized(true)
49      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); }
50
51      CArray(GeneralArrayStorage<N_rank> storage = T_default_storage())
52        : Array<T_numtype,N_rank>(storage)
53        , initialized(false)
54      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
55
56      explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage())
57        : Array<T_numtype,N_rank>(length0, storage)
58        , initialized(true)
59      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
60
61      CArray(int length0, int length1, GeneralArrayStorage<N_rank> storage = T_default_storage())
62        : Array<T_numtype,N_rank>(length0, length1, storage)
63        , initialized(true)
64      { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
65
66      CArray(int length0, int length1, int length2, GeneralArrayStorage<N_rank> storage = T_default_storage())
67        : Array<T_numtype,N_rank>(length0, length1, length2, storage)
68        , initialized(true)
69      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
70
71      CArray(int length0, int length1, int length2, int length3, GeneralArrayStorage<N_rank> storage = T_default_storage())
72        : Array<T_numtype,N_rank>(length0, length1, length2, length3, storage)
73        , initialized(true)
74      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
75
76      CArray(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage<N_rank> storage = T_default_storage())
77        : Array<T_numtype,N_rank>(length0,length1, length2, length3, length4, storage)
78        , initialized(true)
79      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
80
81      CArray(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage<N_rank> storage = T_default_storage())
82        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, storage)
83        , initialized(true)
84      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
85
86      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage<N_rank> storage = T_default_storage())
87        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, storage)
88        , initialized(true)
89      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
90
91      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7,
92             GeneralArrayStorage<N_rank> storage = T_default_storage())
93        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, storage)
94        , initialized(true)
95      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
96
97      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6,
98             int length7, int length8, GeneralArrayStorage<N_rank> storage = T_default_storage())
99       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, storage)
100       , initialized(true)
101      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
102
103      CArray(int length0, int length1, int length2, int length3, int length4,
104             int length5, int length6, int length7, int length8, int length9, GeneralArrayStorage<N_rank> storage = T_default_storage())
105        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, storage)
106        , initialized(true)
107      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
108
109      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6,
110             int length7, int length8, int length9, int length10, GeneralArrayStorage<N_rank> storage = T_default_storage())
111       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, length10, storage)
112       , initialized(true)
113      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
114
115      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, GeneralArrayStorage<N_rank> storage = T_default_storage())
116        : Array<T_numtype,N_rank>(dataFirst, shape, storage)
117        , initialized(true)
118      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
119
120      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride,
121             GeneralArrayStorage<N_rank> storage = T_default_storage())
122        : Array<T_numtype,N_rank>(dataFirst, shape, stride, storage)
123        , initialized(true)
124      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
125
126      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, preexistingMemoryPolicy deletionPolicy,
127            GeneralArrayStorage<N_rank> storage = T_default_storage())
128        : Array<T_numtype,N_rank>(dataFirst, shape, deletionPolicy, storage)
129        , initialized(true)
130      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
131
132      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride,
133             preexistingMemoryPolicy deletionPolicy, GeneralArrayStorage<N_rank> storage = T_default_storage())
134        : Array<T_numtype,N_rank>(dataFirst, shape, stride, deletionPolicy, storage)
135        , initialized(true)
136      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
137
138      CArray(const TinyVector<int, N_rank>& extent, GeneralArrayStorage<N_rank> storage = T_default_storage())
139        : Array<T_numtype,N_rank>(extent, storage)
140        , initialized(true)
141      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
142
143      CArray(const TinyVector<int, N_rank>& lbounds, const TinyVector<int, N_rank>& extent,
144             const GeneralArrayStorage<N_rank>& storage)
145        : Array<T_numtype,N_rank>(lbounds, extent, storage)
146        , initialized(true)
147      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
148
149      CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage())
150        : Array<T_numtype,N_rank>(r0, storage)
151        , initialized(true)
152      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
153
154      CArray(Range r0, Range r1, GeneralArrayStorage<N_rank> storage = T_default_storage())
155        : Array<T_numtype,N_rank>(r0, r1, storage)
156        , initialized(true)
157      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
158
159      CArray(Range r0, Range r1, Range r2, GeneralArrayStorage<N_rank> storage = T_default_storage())
160        : Array<T_numtype,N_rank>(r0, r1, r2, storage)
161        , initialized(true)
162      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
163
164      CArray(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage<N_rank> storage = T_default_storage())
165        : Array<T_numtype,N_rank>(r0, r1, r2, r3, storage)
166        , initialized(true)
167      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
168
169      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage<N_rank> storage = T_default_storage())
170        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, storage)
171        , initialized(true)
172      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
173
174      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage<N_rank> storage = T_default_storage())
175        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, storage)
176        , initialized(true)
177      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
178
179      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
180             GeneralArrayStorage<N_rank> storage = T_default_storage())
181        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, storage)
182        , initialized(true)
183      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
184
185      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7,
186             GeneralArrayStorage<N_rank> storage = T_default_storage())
187        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, storage)
188        , initialized(true)
189      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
190
191      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
192             Range r6, Range r7, Range r8, GeneralArrayStorage<N_rank> storage = T_default_storage())
193        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, storage)
194        , initialized(true)
195      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
196
197      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
198             Range r6, Range r7, Range r8, Range r9, GeneralArrayStorage<N_rank> storage = T_default_storage())
199        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, storage)
200        , initialized(true)
201      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
202
203      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7,
204             Range r8, Range r9, Range r10, GeneralArrayStorage<N_rank> storage = T_default_storage())
205        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, storage)
206        , initialized(true)
207      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
208
209      CArray(const CArray<T_numtype, N_rank>& array)
210        : Array<T_numtype,N_rank>(array)
211        , initialized(array.initialized)
212      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
213
214      CArray(const Array<T_numtype, N_rank>& array)
215        : Array<T_numtype,N_rank>(array)
216        , initialized(true)
217      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
218
219      CArray(const TinyVector<int,N_rank-1>& shape, int lastExtent, const GeneralArrayStorage<N_rank>& storage)
220        : Array<T_numtype,N_rank>(shape, lastExtent, storage)
221        , initialized(true)
222      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
223
224      CArray(Array<T_numtype, N_rank>& array, Range r0)
225        : Array<T_numtype,N_rank>(array, r0)
226        , initialized(true)
227      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
228
229      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1)
230        : Array<T_numtype,N_rank>(array, r0, r1)
231        , initialized(true)
232      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
233
234      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2)
235        : Array<T_numtype,N_rank>( array, r0, r1, r2)
236        , initialized(true)
237      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
238
239      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3)
240        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3)
241        , initialized(true)
242      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
243
244      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
245             Range r3, Range r4)
246        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3,  r4)
247        , initialized(true)
248      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
249
250      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
251             Range r3, Range r4, Range r5)
252        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5)
253        , initialized(true)
254      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
255
256      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3,
257             Range r4, Range r5, Range r6)
258        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5, r6)
259        , initialized(true)
260      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
261
262      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4,
263             Range r5, Range r6, Range r7)
264        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7)
265        , initialized(true)
266      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
267
268      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
269             Range r6, Range r7, Range r8)
270        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8)
271        , initialized(true)
272      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
273
274      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
275             Range r6, Range r7, Range r8, Range r9)
276        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9)
277        , initialized(true)
278      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
279
280      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
281             Range r7, Range r8, Range r9, Range r10)
282        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10)
283        , initialized(true)
284      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
285
286      CArray(Array<T_numtype, N_rank>& array, const RectDomain<N_rank>& subdomain)
287        : Array<T_numtype,N_rank>(array, subdomain)
288        , initialized(true)
289      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
290
291      CArray(Array<T_numtype, N_rank>& array, const StridedDomain<N_rank>& subdomain)
292        : Array<T_numtype,N_rank>(array, subdomain)
293        , initialized(true)
294      {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();}
295
296      template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, typename R5,
297                            typename R6, typename R7, typename R8, typename R9, typename R10>
298      CArray(Array<T_numtype,N_rank2>& array, R0 r0, R1 r1, R2 r2, R3 r3, R4 r4, R5 r5, R6 r6, R7 r7, R8 r8, R9 r9, R10 r10)
299        : Array<T_numtype,N_rank>(array, r0,r1, r2, r3, r4, r5, r6, r7, r8, r9, r10)
300        , initialized(true)
301      { bool neverTrue ; neverTrue=false ; bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); }
302
303      virtual ~CArray() {}
304
305      CArray<T_numtype, N_rank> copy() const
306      {
307        CArray<T_numtype, N_rank> copy = Array<T_numtype, N_rank>::copy();
308        copy.initialized = initialized;
309        return copy;
310      }
311
312      void reference(const CArray<T_numtype, N_rank>& array)
313      {
314        Array<T_numtype,N_rank>::reference(array);
315        initialized = array.initialized;
316      }
317
318      void reference(const Array<T_numtype,N_rank>& array)
319      {
320        Array<T_numtype,N_rank>::reference(array);
321        initialized = true;
322      }
323
324      bool operator== (const CArray<T_numtype,N_rank>& array)
325      {
326        size_t nbThis = this->numElements();
327        size_t nbArr  = array.numElements();
328        if (nbThis != nbArr) return false;
329        if (nbThis==0 && nbArr==0) return true;
330        typename Array<T_numtype,N_rank>::const_iterator itx=array.begin(), itxe=array.end(), ity=this->begin() ;
331        for(;itx!=itxe;++itx,++ity) if (*itx!=*ity) return false ;
332        return true;
333      }
334
335      bool operator== (const Array<T_numtype,N_rank>& array)
336      {
337        return ((*this) == (dynamic_cast<const CArray<T_numtype,N_rank>& >(array)));
338      }
339
340      void resize(int extent)
341      {
342        Array<T_numtype,N_rank>::resize(extent);
343        initialized = true;
344      }
345      void resize(int extent1, int extent2)
346      {
347        Array<T_numtype,N_rank>::resize(extent1, extent2);
348        initialized = true;
349      }
350      void resize(int extent1, int extent2, int extent3)
351      {
352        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3);
353        initialized = true;
354      }
355      void resize(int extent1, int extent2, int extent3, int extent4)
356      {
357        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4);
358        initialized = true;
359      }
360      void resize(int extent1, int extent2, int extent3, int extent4, int extent5)
361      {
362        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5);
363        initialized = true;
364      }
365      void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6)
366      {
367        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5, extent6);
368        initialized = true;
369      }
370      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
371                  int extent6, int extent7)
372      {
373        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
374                                        extent6, extent7);
375        initialized = true;
376      }
377      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
378                  int extent6, int extent7, int extent8)
379      {
380        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
381                                        extent6, extent7, extent8);
382        initialized = true;
383      }
384      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
385                  int extent6, int extent7, int extent8, int extent9)
386      {
387        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
388                                        extent6, extent7, extent8, extent9);
389        initialized = true;
390      }
391      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
392                  int extent6, int extent7, int extent8, int extent9, int extent10)
393      {
394        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
395                                        extent6, extent7, extent8, extent9, extent10);
396        initialized = true;
397      }
398      void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6,
399                  int extent7, int extent8, int extent9, int extent10, int extent11)
400      {
401        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5, extent6,
402                                        extent7, extent8, extent9, extent10, extent11);
403        initialized = true;
404      }
405
406      void resize(Range r1)
407      {
408        Array<T_numtype,N_rank>::resize(r1);
409        initialized = true;
410      }
411      void resize(Range r1, Range r2)
412      {
413        Array<T_numtype,N_rank>::resize(r1, r2);
414        initialized = true;
415      }
416      void resize(Range r1, Range r2, Range r3)
417      {
418        Array<T_numtype,N_rank>::resize(r1, r2, r3);
419        initialized = true;
420      }
421      void resize(Range r1, Range r2, Range r3, Range r4)
422      {
423        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4);
424        initialized = true;
425      }
426      void resize(Range r1, Range r2, Range r3, Range r4, Range r5)
427      {
428        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5);
429        initialized = true;
430      }
431      void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6)
432      {
433        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5, r6);
434        initialized = true;
435      }
436      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
437                  Range r6, Range r7)
438      {
439        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
440                                        r6, r7);
441        initialized = true;
442      }
443      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
444                  Range r6, Range r7, Range r8)
445      {
446        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
447                                        r6, r7, r8);
448        initialized = true;
449      }
450      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
451                  Range r6, Range r7, Range r8, Range r9)
452      {
453        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
454                                        r6, r7, r8, r9);
455        initialized = true;
456      }
457      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
458                  Range r6, Range r7, Range r8, Range r9, Range r10)
459      {
460        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
461                                        r6, r7, r8, r9, r10);
462        initialized = true;
463      }
464      void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
465                  Range r7, Range r8, Range r9, Range r10, Range r11)
466      {
467        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5, r6,
468                                        r7, r8, r9, r10, r11);
469        initialized = true;
470      }
471
472      void resize(const TinyVector<int,N_rank>& extent)
473      {
474        Array<T_numtype,N_rank>::resize(extent);
475        initialized = true;
476      }
477
478      void resizeAndPreserve(const TinyVector<int,N_rank>& extent)
479      {
480        Array<T_numtype,N_rank>::resizeAndPreserve(extent);
481        initialized = true;
482      }
483
484      void resizeAndPreserve(int extent)
485      {
486        Array<T_numtype,N_rank>::resizeAndPreserve(extent);
487        initialized = true;
488      }
489      void resizeAndPreserve(int extent1, int extent2)
490      {
491        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2);
492        initialized = true;
493      }
494      void resizeAndPreserve(int extent1, int extent2, int extent3)
495      {
496        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3);
497        initialized = true;
498      }
499      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4)
500      {
501        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4);
502        initialized = true;
503      }
504      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5)
505      {
506        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5);
507        initialized = true;
508      }
509      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
510                             int extent5, int extent6)
511      {
512        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
513                                                   extent5, extent6);
514        initialized = true;
515      }
516      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
517                             int extent5, int extent6, int extent7)
518      {
519        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
520                                                   extent5, extent6, extent7);
521        initialized = true;
522      }
523      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
524                             int extent5, int extent6, int extent7, int extent8)
525      {
526        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
527                                                   extent5, extent6, extent7, extent8);
528        initialized = true;
529      }
530      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5,
531                             int extent6, int extent7, int extent8, int extent9)
532      {
533        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5,
534                                                   extent6, extent7, extent8, extent9);
535        initialized = true;
536      }
537      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5,
538                             int extent6, int extent7, int extent8, int extent9, int extent10)
539      {
540        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5,
541                                                   extent6, extent7, extent8, extent9, extent10);
542        initialized = true;
543      }
544      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6,
545                             int extent7, int extent8, int extent9, int extent10, int extent11)
546      {
547        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5, extent6,
548                                                   extent7, extent8, extent9, extent10, extent11);
549        initialized = true;
550      }
551
552      virtual void fromString(const string& str) { istringstream iss(str); iss >> *this; initialized = true; }
553      virtual string toString(void) const { ostringstream oss; oss << *this; return oss.str(); }
554
555      virtual string dump(void) const
556      {
557        ostringstream oss;
558        oss << this->shape()<<" ";
559        if (this->shape().numElements() == 1 && this->shape().dataFirst()[0] == 1)
560          oss << this->dataFirst()[0];
561        else
562          oss << this->dataFirst()[0] <<" ... "<< this->dataFirst()[this->numElements()-1];
563        return oss.str();
564      }
565
566      virtual void reset(void) { this->free(); initialized = false; }
567      virtual bool isEmpty(void) const { return !initialized; }
568      virtual size_t size(void) const { return size(this->numElements()); }
569      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); }
570     
571      static int show_TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array )
572      {
573        int status ;
574        if (array->isEmpty()) 
575        {
576          status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ;
577          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ;
578          else return TV_ttf_format_ok_elide ;
579        }
580        else 
581        {
582          char tname[128] ;
583          char bname[128] = "value_type" ;
584#ifdef __GNUC__
585         size_t size = sizeof(bname) ;
586         abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ;
587         if (status !=0) return TV_ttf_format_raw ;
588#endif
589          int dim = array->dimensions() ;
590          if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0));
591          if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0));
592          if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3));
593          if (dim==4) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d]", bname, array->extent(0), array->extent(1), array->extent(2), array->extent(3));
594          if (dim==5) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d]", bname, array->extent(4), array->extent(3), array->extent(2), array->extent(1)
595                                                                                      ,array->extent(0));
596          if (dim==6) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d]", bname, array->extent(5), array->extent(4), array->extent(3), array->extent(2)
597                                                                                      ,array->extent(1),array->extent(0));
598          if (dim==7) snprintf (tname, sizeof(tname), "%s[%d][%d][%d][%d][%d][%d][%d]", bname, array->extent(6), array->extent(5), array->extent(4), array->extent(3)
599                                                                                      ,array->extent(2),array->extent(1),array->extent(0));
600          status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ;
601          if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ;
602          else return TV_ttf_format_ok ;
603        }
604      }
605     
606
607      static int TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array )
608      {
609        return show_TV_ttf_display_type (array) ;
610      }
611     
612      virtual CBaseType* clone(void) const { return new CArray(*this); }
613
614      virtual bool toBuffer(CBufferOut& buffer) const
615      {
616        bool ret;
617        ret =  buffer.put(this->dimensions());
618        ret &= buffer.put(this->shape().data(), this->dimensions());
619        ret &= buffer.put(this->numElements());
620        ret &= buffer.put(this->dataFirst(), this->numElements());
621        return ret;
622      }
623
624      virtual bool fromBuffer(CBufferIn& buffer)
625      {
626        bool ret;
627        int numDim;
628        TinyVector<int,N_rank> vect;
629        size_t ne;
630
631        ret =  buffer.get(numDim);
632        ret &= buffer.get(vect.data(), N_rank);
633        this->resize(vect);
634        ret &= buffer.get(ne);
635        ret &= buffer.get(this->dataFirst(), ne);
636
637        initialized = true;
638
639        return ret;
640      }
641
642  };
643
644
645#define macrotyperank(_TYPE_,_RANK_)\
646  template<> int CArray<_TYPE_,_RANK_>::TV_ttf_display_type( const CArray<_TYPE_,_RANK_>* array ) \
647  {\
648    return show_TV_ttf_display_type (array) ;\
649  }
650
651#define macrotype(_TYPE_)\
652macrotyperank(_TYPE_,1)\
653macrotyperank(_TYPE_,2)\
654macrotyperank(_TYPE_,3)\
655macrotyperank(_TYPE_,4)\
656macrotyperank(_TYPE_,5)\
657macrotyperank(_TYPE_,6)\
658macrotyperank(_TYPE_,7)
659
660macrotype(double)
661macrotype(int)
662macrotype(bool)
663macrotype(size_t)
664macrotype(float)
665macrotype(string)
666
667#undef macrotyperank
668#undef macrotype
669
670
671
672#define macro(NRANK)\
673\
674  template <>\
675  inline size_t CArray<StdString,NRANK>::size(void) const\
676  {\
677    size_t size=(1 + NRANK) * sizeof(int) ;\
678    Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\
679\
680    for(it=itb;it!=ite;++it)\
681    {\
682      size+= sizeof(size_t) ;\
683      size+= (*it).size();\
684    } \
685    return size ;\
686  }\
687\
688/* for array string this function is an evaluation of maximum size of the array, considering stringArrayLen is the maximum size of the strings*/ \
689  template <>\
690  inline size_t CArray<StdString,NRANK>::size(sizeType numElements)\
691  {\
692    return (NRANK + 1) * sizeof(int) + numElements * stringArrayLen;\
693  }\
694  \
695  template <>\
696  inline bool CArray<StdString,NRANK>::toBuffer(CBufferOut& buffer) const\
697  {\
698    bool ret;\
699    ret =  buffer.put(this->dimensions());\
700    ret &= buffer.put(this->shape().data(), this->dimensions());\
701\
702    Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\
703\
704    for(it=itb;it!=ite;++it)\
705    {\
706      ret &= buffer.put((*it).size()) ;\
707      ret &= buffer.put((*it).data(),(*it).size());\
708    } \
709    return ret;\
710  }\
711\
712  template <>\
713  inline bool CArray<StdString,NRANK>::fromBuffer(CBufferIn& buffer)\
714  {\
715     bool ret;\
716     int numDim;\
717     TinyVector<int,NRANK> vect;\
718     size_t ne;\
719\
720     ret =  buffer.get(numDim);\
721     ret &= buffer.get(vect.data(), NRANK);\
722     this->resize(vect);\
723\
724     Array<StdString,NRANK>::iterator it, itb=this->begin(), ite=this->end() ;\
725     for(it=itb;it!=ite;++it)\
726     {\
727       ret &= buffer.get(ne) ;\
728       char* str = new char[ne] ;\
729       ret &= buffer.get(str, ne);\
730       *it = string(str,ne) ;\
731       delete [] str ;\
732     }\
733     initialized = true;\
734     return ret;\
735  }
736macro(1)
737macro(2)
738macro(3)
739macro(4)
740macro(5)
741macro(6)
742macro(7)
743
744#undef macro
745
746  template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray<T_numtype,N_rank>& array)
747  {
748    if (!array.toBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray& array)",
749                                       << "Not enough free space in buffer to queue the array.");
750    return buffer;
751  }
752
753  template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray<T_numtype, N_rank>& array)
754  {
755    if (!array.fromBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray& array)",
756                                         << "Not enough data in buffer to unqueue the array.");
757    return buffer;
758  }
759
760  template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, const CArray<T_numtype, N_rank>& array)
761  {
762    msg.push(array);
763    return msg;
764  }
765
766  template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, CArray<T_numtype, N_rank>& array)
767  {
768    msg.push(array);
769    return msg;
770  }
771}
772
773#endif
Note: See TracBrowser for help on using the repository browser.