source: XIOS/trunk/src/array_new.hpp @ 1314

Last change on this file since 1314 was 1111, checked in by ymipsl, 7 years ago

Bug fix on "== operator" method for CArray

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: 25.8 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 <cmath>
10
11using namespace blitz;
12BZ_DECLARE_FUNCTION(round)
13
14namespace xios
15{
16  template <typename T_numtype,int N_rank>
17  class CArray : public Array<T_numtype,N_rank>, public virtual CBaseType
18  {
19    private:
20      bool initialized;
21
22    public:
23      typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage;
24      using Array<T_numtype,N_rank>::operator =;
25
26      template<typename T_expr> explicit CArray(_bz_ArrayExpr<T_expr> expr)
27        : Array<T_numtype,N_rank>(expr)
28        , initialized(true)
29      {}
30
31      CArray(GeneralArrayStorage<N_rank> storage = T_default_storage())
32        : Array<T_numtype,N_rank>(storage)
33        , initialized(false)
34      {}
35
36      explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage())
37        : Array<T_numtype,N_rank>(length0, storage)
38        , initialized(true)
39      {}
40
41      CArray(int length0, int length1, GeneralArrayStorage<N_rank> storage = T_default_storage())
42        : Array<T_numtype,N_rank>(length0, length1, storage)
43        , initialized(true)
44      {}
45
46      CArray(int length0, int length1, int length2, GeneralArrayStorage<N_rank> storage = T_default_storage())
47        : Array<T_numtype,N_rank>(length0, length1, length2, storage)
48        , initialized(true)
49      {}
50
51      CArray(int length0, int length1, int length2, int length3, GeneralArrayStorage<N_rank> storage = T_default_storage())
52        : Array<T_numtype,N_rank>(length0, length1, length2, length3, storage)
53        , initialized(true)
54      {}
55
56      CArray(int length0, int length1, int length2, int length3, int length4, GeneralArrayStorage<N_rank> storage = T_default_storage())
57        : Array<T_numtype,N_rank>(length0,length1, length2, length3, length4, storage)
58        , initialized(true)
59      {}
60
61      CArray(int length0, int length1, int length2, int length3, int length4, int length5, GeneralArrayStorage<N_rank> storage = T_default_storage())
62        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, storage)
63        , initialized(true)
64      {}
65
66      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, GeneralArrayStorage<N_rank> storage = T_default_storage())
67        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, storage)
68        , initialized(true)
69      {}
70
71      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6, int length7,
72             GeneralArrayStorage<N_rank> storage = T_default_storage())
73        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, storage)
74        , initialized(true)
75      {}
76
77      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6,
78             int length7, int length8, GeneralArrayStorage<N_rank> storage = T_default_storage())
79       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, storage)
80       , initialized(true)
81      {}
82
83      CArray(int length0, int length1, int length2, int length3, int length4,
84             int length5, int length6, int length7, int length8, int length9, GeneralArrayStorage<N_rank> storage = T_default_storage())
85        : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, storage)
86        , initialized(true)
87      {}
88
89      CArray(int length0, int length1, int length2, int length3, int length4, int length5, int length6,
90             int length7, int length8, int length9, int length10, GeneralArrayStorage<N_rank> storage = T_default_storage())
91       : Array<T_numtype,N_rank>(length0, length1, length2, length3, length4, length5, length6, length7, length8, length9, length10, storage)
92       , initialized(true)
93      {}
94
95      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, GeneralArrayStorage<N_rank> storage = T_default_storage())
96        : Array<T_numtype,N_rank>(dataFirst, shape, storage)
97        , initialized(true)
98      {}
99
100      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride,
101             GeneralArrayStorage<N_rank> storage = T_default_storage())
102        : Array<T_numtype,N_rank>(dataFirst, shape, stride, storage)
103        , initialized(true)
104      {}
105
106      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, preexistingMemoryPolicy deletionPolicy,
107            GeneralArrayStorage<N_rank> storage = T_default_storage())
108        : Array<T_numtype,N_rank>(dataFirst, shape, deletionPolicy, storage)
109        , initialized(true)
110      {}
111
112      CArray(T_numtype* restrict dataFirst, TinyVector<int, N_rank> shape, TinyVector<diffType, N_rank> stride,
113             preexistingMemoryPolicy deletionPolicy, GeneralArrayStorage<N_rank> storage = T_default_storage())
114        : Array<T_numtype,N_rank>(dataFirst, shape, stride, deletionPolicy, storage)
115        , initialized(true)
116      {}
117
118      CArray(const TinyVector<int, N_rank>& extent, GeneralArrayStorage<N_rank> storage = T_default_storage())
119        : Array<T_numtype,N_rank>(extent, storage)
120        , initialized(true)
121      {}
122
123      CArray(const TinyVector<int, N_rank>& lbounds, const TinyVector<int, N_rank>& extent,
124             const GeneralArrayStorage<N_rank>& storage)
125        : Array<T_numtype,N_rank>(lbounds, extent, storage)
126        , initialized(true)
127      {}
128
129      CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage())
130        : Array<T_numtype,N_rank>(r0, storage)
131        , initialized(true)
132      {}
133
134      CArray(Range r0, Range r1, GeneralArrayStorage<N_rank> storage = T_default_storage())
135        : Array<T_numtype,N_rank>(r0, r1, storage)
136        , initialized(true)
137      {}
138
139      CArray(Range r0, Range r1, Range r2, GeneralArrayStorage<N_rank> storage = T_default_storage())
140        : Array<T_numtype,N_rank>(r0, r1, r2, storage)
141        , initialized(true)
142      {}
143
144      CArray(Range r0, Range r1, Range r2, Range r3, GeneralArrayStorage<N_rank> storage = T_default_storage())
145        : Array<T_numtype,N_rank>(r0, r1, r2, r3, storage)
146        , initialized(true)
147      {}
148
149      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, GeneralArrayStorage<N_rank> storage = T_default_storage())
150        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, storage)
151        , initialized(true)
152      {}
153
154      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, GeneralArrayStorage<N_rank> storage = T_default_storage())
155        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, storage)
156        , initialized(true)
157      {}
158
159      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
160             GeneralArrayStorage<N_rank> storage = T_default_storage())
161        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, storage)
162        , initialized(true)
163      {}
164
165      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7,
166             GeneralArrayStorage<N_rank> storage = T_default_storage())
167        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, storage)
168        , initialized(true)
169      {}
170
171      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
172             Range r6, Range r7, Range r8, GeneralArrayStorage<N_rank> storage = T_default_storage())
173        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, storage)
174        , initialized(true)
175      {}
176
177      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
178             Range r6, Range r7, Range r8, Range r9, GeneralArrayStorage<N_rank> storage = T_default_storage())
179        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, storage)
180        , initialized(true)
181      {}
182
183      CArray(Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6, Range r7,
184             Range r8, Range r9, Range r10, GeneralArrayStorage<N_rank> storage = T_default_storage())
185        : Array<T_numtype,N_rank>(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, storage)
186        , initialized(true)
187      {}
188
189      CArray(const CArray<T_numtype, N_rank>& array)
190        : Array<T_numtype,N_rank>(array)
191        , initialized(array.initialized)
192      {}
193
194      CArray(const Array<T_numtype, N_rank>& array)
195        : Array<T_numtype,N_rank>(array)
196        , initialized(true)
197      {}
198
199      CArray(const TinyVector<int,N_rank-1>& shape, int lastExtent, const GeneralArrayStorage<N_rank>& storage)
200        : Array<T_numtype,N_rank>(shape, lastExtent, storage)
201        , initialized(true)
202      {}
203
204      CArray(Array<T_numtype, N_rank>& array, Range r0)
205        : Array<T_numtype,N_rank>(array, r0)
206        , initialized(true)
207      {}
208
209      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1)
210        : Array<T_numtype,N_rank>(array, r0, r1)
211        , initialized(true)
212      {}
213
214      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2)
215        : Array<T_numtype,N_rank>( array, r0, r1, r2)
216        , initialized(true)
217      {}
218
219      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3)
220        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3)
221        , initialized(true)
222      {}
223
224      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
225             Range r3, Range r4)
226        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3,  r4)
227        , initialized(true)
228      {}
229
230      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2,
231             Range r3, Range r4, Range r5)
232        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5)
233        , initialized(true)
234      {}
235
236      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3,
237             Range r4, Range r5, Range r6)
238        : Array<T_numtype,N_rank>( array, r0, r1, r2, r3, r4, r5, r6)
239        , initialized(true)
240      {}
241
242      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4,
243             Range r5, Range r6, Range r7)
244        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7)
245        , initialized(true)
246      {}
247
248      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
249             Range r6, Range r7, Range r8)
250        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8)
251        , initialized(true)
252      {}
253
254      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5,
255             Range r6, Range r7, Range r8, Range r9)
256        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9)
257        , initialized(true)
258      {}
259
260      CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
261             Range r7, Range r8, Range r9, Range r10)
262        : Array<T_numtype,N_rank>(array, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10)
263        , initialized(true)
264      {}
265
266      CArray(Array<T_numtype, N_rank>& array, const RectDomain<N_rank>& subdomain)
267        : Array<T_numtype,N_rank>(array, subdomain)
268        , initialized(true)
269      {}
270
271      CArray(Array<T_numtype, N_rank>& array, const StridedDomain<N_rank>& subdomain)
272        : Array<T_numtype,N_rank>(array, subdomain)
273        , initialized(true)
274      {}
275
276      template<int N_rank2, typename R0, typename R1, typename R2, typename R3, typename R4, typename R5,
277                            typename R6, typename R7, typename R8, typename R9, typename R10>
278      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)
279        : Array<T_numtype,N_rank>(array, r0,r1, r2, r3, r4, r5, r6, r7, r8, r9, r10)
280        , initialized(true)
281      {}
282
283      virtual ~CArray() {}
284
285      CArray<T_numtype, N_rank> copy() const
286      {
287        CArray<T_numtype, N_rank> copy = Array<T_numtype, N_rank>::copy();
288        copy.initialized = initialized;
289        return copy;
290      }
291
292      void reference(const CArray<T_numtype, N_rank>& array)
293      {
294        Array<T_numtype,N_rank>::reference(array);
295        initialized = array.initialized;
296      }
297
298      void reference(const Array<T_numtype,N_rank>& array)
299      {
300        Array<T_numtype,N_rank>::reference(array);
301        initialized = true;
302      }
303
304      bool operator== (const CArray<T_numtype,N_rank>& array)
305      {
306        size_t nbThis = this->numElements();
307        size_t nbArr  = array.numElements();
308        if (nbThis != nbArr) return false;
309        typename Array<T_numtype,N_rank>::const_iterator itx=array.begin(), itxe=array.end(), ity=this->begin() ;
310        for(;itx!=itxe;++itx,++ity) if (*itx!=*ity) return false ;
311        return true;
312      }
313
314      bool operator== (const Array<T_numtype,N_rank>& array)
315      {
316        return ((*this) == (dynamic_cast<const CArray<T_numtype,N_rank>& >(array)));
317      }
318
319      void resize(int extent)
320      {
321        Array<T_numtype,N_rank>::resize(extent);
322        initialized = true;
323      }
324      void resize(int extent1, int extent2)
325      {
326        Array<T_numtype,N_rank>::resize(extent1, extent2);
327        initialized = true;
328      }
329      void resize(int extent1, int extent2, int extent3)
330      {
331        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3);
332        initialized = true;
333      }
334      void resize(int extent1, int extent2, int extent3, int extent4)
335      {
336        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4);
337        initialized = true;
338      }
339      void resize(int extent1, int extent2, int extent3, int extent4, int extent5)
340      {
341        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5);
342        initialized = true;
343      }
344      void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6)
345      {
346        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5, extent6);
347        initialized = true;
348      }
349      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
350                  int extent6, int extent7)
351      {
352        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
353                                        extent6, extent7);
354        initialized = true;
355      }
356      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
357                  int extent6, int extent7, int extent8)
358      {
359        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
360                                        extent6, extent7, extent8);
361        initialized = true;
362      }
363      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
364                  int extent6, int extent7, int extent8, int extent9)
365      {
366        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
367                                        extent6, extent7, extent8, extent9);
368        initialized = true;
369      }
370      void resize(int extent1, int extent2, int extent3, int extent4, int extent5,
371                  int extent6, int extent7, int extent8, int extent9, int extent10)
372      {
373        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5,
374                                        extent6, extent7, extent8, extent9, extent10);
375        initialized = true;
376      }
377      void resize(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6,
378                  int extent7, int extent8, int extent9, int extent10, int extent11)
379      {
380        Array<T_numtype,N_rank>::resize(extent1, extent2, extent3, extent4, extent5, extent6,
381                                        extent7, extent8, extent9, extent10, extent11);
382        initialized = true;
383      }
384
385      void resize(Range r1)
386      {
387        Array<T_numtype,N_rank>::resize(r1);
388        initialized = true;
389      }
390      void resize(Range r1, Range r2)
391      {
392        Array<T_numtype,N_rank>::resize(r1, r2);
393        initialized = true;
394      }
395      void resize(Range r1, Range r2, Range r3)
396      {
397        Array<T_numtype,N_rank>::resize(r1, r2, r3);
398        initialized = true;
399      }
400      void resize(Range r1, Range r2, Range r3, Range r4)
401      {
402        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4);
403        initialized = true;
404      }
405      void resize(Range r1, Range r2, Range r3, Range r4, Range r5)
406      {
407        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5);
408        initialized = true;
409      }
410      void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6)
411      {
412        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5, r6);
413        initialized = true;
414      }
415      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
416                  Range r6, Range r7)
417      {
418        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
419                                        r6, r7);
420        initialized = true;
421      }
422      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
423                  Range r6, Range r7, Range r8)
424      {
425        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
426                                        r6, r7, r8);
427        initialized = true;
428      }
429      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
430                  Range r6, Range r7, Range r8, Range r9)
431      {
432        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
433                                        r6, r7, r8, r9);
434        initialized = true;
435      }
436      void resize(Range r1, Range r2, Range r3, Range r4, Range r5,
437                  Range r6, Range r7, Range r8, Range r9, Range r10)
438      {
439        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5,
440                                        r6, r7, r8, r9, r10);
441        initialized = true;
442      }
443      void resize(Range r1, Range r2, Range r3, Range r4, Range r5, Range r6,
444                  Range r7, Range r8, Range r9, Range r10, Range r11)
445      {
446        Array<T_numtype,N_rank>::resize(r1, r2, r3, r4, r5, r6,
447                                        r7, r8, r9, r10, r11);
448        initialized = true;
449      }
450
451      void resize(const TinyVector<int,N_rank>& extent)
452      {
453        Array<T_numtype,N_rank>::resize(extent);
454        initialized = true;
455      }
456
457      void resizeAndPreserve(const TinyVector<int,N_rank>& extent)
458      {
459        Array<T_numtype,N_rank>::resizeAndPreserve(extent);
460        initialized = true;
461      }
462
463      void resizeAndPreserve(int extent)
464      {
465        Array<T_numtype,N_rank>::resizeAndPreserve(extent);
466        initialized = true;
467      }
468      void resizeAndPreserve(int extent1, int extent2)
469      {
470        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2);
471        initialized = true;
472      }
473      void resizeAndPreserve(int extent1, int extent2, int extent3)
474      {
475        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3);
476        initialized = true;
477      }
478      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4)
479      {
480        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4);
481        initialized = true;
482      }
483      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5)
484      {
485        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5);
486        initialized = true;
487      }
488      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
489                             int extent5, int extent6)
490      {
491        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
492                                                   extent5, extent6);
493        initialized = true;
494      }
495      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
496                             int extent5, int extent6, int extent7)
497      {
498        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
499                                                   extent5, extent6, extent7);
500        initialized = true;
501      }
502      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4,
503                             int extent5, int extent6, int extent7, int extent8)
504      {
505        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4,
506                                                   extent5, extent6, extent7, extent8);
507        initialized = true;
508      }
509      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5,
510                             int extent6, int extent7, int extent8, int extent9)
511      {
512        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5,
513                                                   extent6, extent7, extent8, extent9);
514        initialized = true;
515      }
516      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5,
517                             int extent6, int extent7, int extent8, int extent9, int extent10)
518      {
519        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5,
520                                                   extent6, extent7, extent8, extent9, extent10);
521        initialized = true;
522      }
523      void resizeAndPreserve(int extent1, int extent2, int extent3, int extent4, int extent5, int extent6,
524                             int extent7, int extent8, int extent9, int extent10, int extent11)
525      {
526        Array<T_numtype,N_rank>::resizeAndPreserve(extent1, extent2, extent3, extent4, extent5, extent6,
527                                                   extent7, extent8, extent9, extent10, extent11);
528        initialized = true;
529      }
530
531      virtual void fromString(const string& str) { istringstream iss(str); iss >> *this; initialized = true; }
532      virtual string toString(void) const { ostringstream oss; oss << *this; return oss.str(); }
533      virtual void reset(void) { this->free(); initialized = false; }
534      virtual bool isEmpty(void) const { return !initialized; }
535      virtual size_t size(void) const { return size(this->numElements()); }
536      static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); }
537
538      virtual CBaseType* clone(void) const { return new CArray(*this); }
539
540      virtual bool toBuffer(CBufferOut& buffer) const
541      {
542        bool ret;
543        ret =  buffer.put(this->dimensions());
544        ret &= buffer.put(this->shape().data(), this->dimensions());
545        ret &= buffer.put(this->numElements());
546        ret &= buffer.put(this->dataFirst(), this->numElements());
547        return ret;
548      }
549
550      virtual bool fromBuffer(CBufferIn& buffer)
551      {
552        bool ret;
553        int numDim;
554        TinyVector<int,N_rank> vect;
555        size_t ne;
556       
557        ret =  buffer.get(numDim);
558        ret &= buffer.get(vect.data(), N_rank);
559        this->resize(vect);
560        ret &= buffer.get(ne);
561        ret &= buffer.get(this->dataFirst(), ne);
562
563        initialized = true;
564
565        return ret;
566      }
567  };
568
569
570#define macro(NRANK)\
571\
572  template <>\
573  inline size_t CArray<StdString,NRANK>::size(void) const\
574  {\
575    size_t size=(1 + NRANK) * sizeof(int) ;\
576    Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\
577\
578    for(it=itb;it!=ite;++it)\
579    {\
580      size+= sizeof(size_t) ;\
581      size+= (*it).size();\
582    } \
583    return size ;\
584  }\
585\
586/* for array string this function is an evaluation of maximum size of the array, considering stringArrayLen is the maximum size of the strings*/ \
587  template <>\
588  inline size_t CArray<StdString,NRANK>::size(sizeType numElements)\
589  {\
590    return (NRANK + 1) * sizeof(int) + numElements * stringArrayLen;\
591  }\
592  \
593  template <>\
594  inline bool CArray<StdString,NRANK>::toBuffer(CBufferOut& buffer) const\
595  {\
596    bool ret;\
597    ret =  buffer.put(this->dimensions());\
598    ret &= buffer.put(this->shape().data(), this->dimensions());\
599\
600    Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\
601\
602    for(it=itb;it!=ite;++it)\
603    {\
604      ret &= buffer.put((*it).size()) ;\
605      ret &= buffer.put((*it).data(),(*it).size());\
606    } \
607    return ret;\
608  }\
609\
610  template <>\
611  inline bool CArray<StdString,NRANK>::fromBuffer(CBufferIn& buffer)\
612  {\
613     bool ret;\
614     int numDim;\
615     TinyVector<int,NRANK> vect;\
616     size_t ne;\
617\
618     ret =  buffer.get(numDim);\
619     ret &= buffer.get(vect.data(), NRANK);\
620     this->resize(vect);\
621\
622     Array<StdString,NRANK>::iterator it, itb=this->begin(), ite=this->end() ;\
623     for(it=itb;it!=ite;++it)\
624     {\
625       ret &= buffer.get(ne) ;\
626       char* str = new char[ne] ;\
627       ret &= buffer.get(str, ne);\
628       *it = string(str,ne) ;\
629       delete [] str ;\
630     }\
631     initialized = true;\
632     return ret;\
633  }
634macro(1)
635macro(2)
636macro(3)
637macro(4)
638macro(5)
639macro(6)
640macro(7)
641
642#undef macro
643
644  template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray<T_numtype,N_rank>& array)
645  {
646    if (!array.toBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray& array)",
647                                       << "Not enough free space in buffer to queue the array.");
648    return buffer;
649  }
650
651  template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray<T_numtype, N_rank>& array)
652  {
653    if (!array.fromBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray& array)",
654                                         << "Not enough data in buffer to unqueue the array.");
655    return buffer;
656  }
657
658  template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, const CArray<T_numtype, N_rank>& array)
659  {
660    msg.push(array);
661    return msg;
662  }
663
664  template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, CArray<T_numtype, N_rank>& array)
665  {
666    msg.push(array);
667    return msg;
668  }
669}
670
671#endif
Note: See TracBrowser for help on using the repository browser.