source: XIOS3/trunk/src/array_new.hpp @ 2418

Last change on this file since 2418 was 2120, checked in by ymipsl, 3 years ago

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