[369] | 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" |
---|
[1875] | 9 | #include "tv_data_display.h" |
---|
| 10 | #ifdef __GNUC__ |
---|
| 11 | #include <typeinfo> |
---|
| 12 | #include <cxxabi.h> |
---|
| 13 | #endif |
---|
[464] | 14 | #include <cmath> |
---|
[369] | 15 | |
---|
[677] | 16 | using namespace blitz; |
---|
[464] | 17 | BZ_DECLARE_FUNCTION(round) |
---|
[677] | 18 | |
---|
[369] | 19 | namespace xios |
---|
| 20 | { |
---|
[677] | 21 | template <typename T_numtype,int N_rank> |
---|
[1875] | 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 | |
---|
| 28 | template <typename T_numtype,int N_rank> |
---|
| 29 | int TV_ttf_display_type ( const xios::CArray<T_numtype, N_rank>* array ) ; |
---|
| 30 | |
---|
| 31 | namespace xios |
---|
| 32 | { |
---|
| 33 | template <typename T_numtype,int N_rank> |
---|
[677] | 34 | class CArray : public Array<T_numtype,N_rank>, public virtual CBaseType |
---|
| 35 | { |
---|
| 36 | private: |
---|
| 37 | bool initialized; |
---|
[1875] | 38 | void inc_symbol(void) |
---|
| 39 | { |
---|
| 40 | TV_ttf_display_type(this); |
---|
| 41 | } |
---|
[677] | 42 | public: |
---|
| 43 | typedef typename Array<T_numtype,N_rank>::T_default_storage T_default_storage; |
---|
| 44 | using Array<T_numtype,N_rank>::operator =; |
---|
[369] | 45 | |
---|
[677] | 46 | template<typename T_expr> explicit CArray(_bz_ArrayExpr<T_expr> expr) |
---|
| 47 | : Array<T_numtype,N_rank>(expr) |
---|
| 48 | , initialized(true) |
---|
[1875] | 49 | { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } |
---|
[369] | 50 | |
---|
[677] | 51 | CArray(GeneralArrayStorage<N_rank> storage = T_default_storage()) |
---|
| 52 | : Array<T_numtype,N_rank>(storage) |
---|
| 53 | , initialized(false) |
---|
[1875] | 54 | { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 55 | |
---|
[677] | 56 | explicit CArray(int length0, GeneralArrayStorage<N_rank> storage = T_default_storage()) |
---|
| 57 | : Array<T_numtype,N_rank>(length0, storage) |
---|
| 58 | , initialized(true) |
---|
[1875] | 59 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 60 | |
---|
[677] | 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) |
---|
[1875] | 64 | { bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 65 | |
---|
[677] | 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) |
---|
[1875] | 69 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 70 | |
---|
[677] | 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) |
---|
[1875] | 74 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 75 | |
---|
[677] | 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) |
---|
[1875] | 79 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 80 | |
---|
[677] | 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) |
---|
[1875] | 84 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 85 | |
---|
[677] | 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) |
---|
[1875] | 89 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 90 | |
---|
[677] | 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) |
---|
[1875] | 95 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 96 | |
---|
[677] | 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) |
---|
[1875] | 101 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 102 | |
---|
[677] | 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) |
---|
[1875] | 107 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 108 | |
---|
[677] | 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) |
---|
[1875] | 113 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 114 | |
---|
[677] | 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) |
---|
[1875] | 118 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 119 | |
---|
[677] | 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) |
---|
[1875] | 124 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 125 | |
---|
[677] | 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) |
---|
[1875] | 130 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 131 | |
---|
[677] | 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) |
---|
[1875] | 136 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 137 | |
---|
[677] | 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) |
---|
[1875] | 141 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 142 | |
---|
[677] | 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) |
---|
[1875] | 147 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 148 | |
---|
[677] | 149 | CArray(Range r0, GeneralArrayStorage<N_rank> storage = T_default_storage()) |
---|
| 150 | : Array<T_numtype,N_rank>(r0, storage) |
---|
| 151 | , initialized(true) |
---|
[1875] | 152 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 153 | |
---|
[677] | 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) |
---|
[1875] | 157 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 158 | |
---|
[677] | 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) |
---|
[1875] | 162 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 163 | |
---|
[677] | 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) |
---|
[1875] | 167 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 168 | |
---|
[677] | 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) |
---|
[1875] | 172 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 173 | |
---|
[677] | 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) |
---|
[1875] | 177 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 178 | |
---|
[677] | 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) |
---|
[1875] | 183 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 184 | |
---|
[677] | 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) |
---|
[1875] | 189 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 190 | |
---|
[677] | 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) |
---|
[1875] | 195 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 196 | |
---|
[677] | 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) |
---|
[1875] | 201 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 202 | |
---|
[677] | 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) |
---|
[1875] | 207 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 208 | |
---|
[677] | 209 | CArray(const CArray<T_numtype, N_rank>& array) |
---|
| 210 | : Array<T_numtype,N_rank>(array) |
---|
| 211 | , initialized(array.initialized) |
---|
[1875] | 212 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 213 | |
---|
[677] | 214 | CArray(const Array<T_numtype, N_rank>& array) |
---|
| 215 | : Array<T_numtype,N_rank>(array) |
---|
| 216 | , initialized(true) |
---|
[1875] | 217 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 218 | |
---|
[677] | 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) |
---|
[1875] | 222 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 223 | |
---|
[677] | 224 | CArray(Array<T_numtype, N_rank>& array, Range r0) |
---|
| 225 | : Array<T_numtype,N_rank>(array, r0) |
---|
| 226 | , initialized(true) |
---|
[1875] | 227 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 228 | |
---|
[677] | 229 | CArray(Array<T_numtype, N_rank>& array, Range r0, Range r1) |
---|
| 230 | : Array<T_numtype,N_rank>(array, r0, r1) |
---|
| 231 | , initialized(true) |
---|
[1875] | 232 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 233 | |
---|
[677] | 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) |
---|
[1875] | 237 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 238 | |
---|
[677] | 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) |
---|
[1875] | 242 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 243 | |
---|
[677] | 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) |
---|
[1875] | 248 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 249 | |
---|
[677] | 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) |
---|
[1875] | 254 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 255 | |
---|
[677] | 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) |
---|
[1875] | 260 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 261 | |
---|
[677] | 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) |
---|
[1875] | 266 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 267 | |
---|
[677] | 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) |
---|
[1875] | 272 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 273 | |
---|
[677] | 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) |
---|
[1875] | 278 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[369] | 279 | |
---|
[677] | 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) |
---|
[1875] | 284 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[677] | 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) |
---|
[1875] | 289 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[677] | 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) |
---|
[1875] | 294 | {bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol();} |
---|
[677] | 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) |
---|
[1875] | 301 | { bool neverTrue ; neverTrue=false ; bool neverTrue ; neverTrue=false ; if(neverTrue) inc_symbol(); } |
---|
[677] | 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 | |
---|
[1158] | 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; |
---|
[1290] | 329 | if (nbThis==0 && nbArr==0) return true; |
---|
[1158] | 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 | |
---|
[677] | 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(); } |
---|
[1622] | 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 | |
---|
[677] | 566 | virtual void reset(void) { this->free(); initialized = false; } |
---|
| 567 | virtual bool isEmpty(void) const { return !initialized; } |
---|
[731] | 568 | virtual size_t size(void) const { return size(this->numElements()); } |
---|
[1918] | 569 | virtual std::vector<T_numtype> getVector(void) { return vector<T_numtype>(this->dataFirst(),this->dataFirst()+this->numElements()) ;} |
---|
[731] | 570 | static size_t size(sizeType numElements) { return (N_rank + 1) * sizeof(int) + sizeof(size_t) + numElements * sizeof(T_numtype); } |
---|
[1875] | 571 | |
---|
| 572 | static int show_TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) |
---|
| 573 | { |
---|
| 574 | int status ; |
---|
| 575 | if (array->isEmpty()) |
---|
| 576 | { |
---|
| 577 | status = TV_ttf_add_row("State", TV_ttf_type_ascii_string,"(empty)") ; |
---|
| 578 | if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; |
---|
| 579 | else return TV_ttf_format_ok_elide ; |
---|
| 580 | } |
---|
| 581 | else |
---|
| 582 | { |
---|
| 583 | char tname[128] ; |
---|
| 584 | char bname[128] = "value_type" ; |
---|
| 585 | #ifdef __GNUC__ |
---|
| 586 | size_t size = sizeof(bname) ; |
---|
| 587 | abi::__cxa_demangle(typeid(T_numtype).name(), bname, &size, &status) ; |
---|
| 588 | if (status !=0) return TV_ttf_format_raw ; |
---|
| 589 | #endif |
---|
| 590 | int dim = array->dimensions() ; |
---|
| 591 | if (dim==1) snprintf (tname, sizeof(tname), "%s[%d]", bname, array->extent(0)); |
---|
| 592 | if (dim==2) snprintf (tname, sizeof(tname), "%s[%d][%d]", bname, array->extent(1), array->extent(0)); |
---|
| 593 | if (dim==3) snprintf (tname, sizeof(tname), "%s[%d][%d][%d]", bname, array->extent(2), array->extent(1), array->extent(3)); |
---|
| 594 | 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)); |
---|
| 595 | 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) |
---|
| 596 | ,array->extent(0)); |
---|
| 597 | 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) |
---|
| 598 | ,array->extent(1),array->extent(0)); |
---|
| 599 | 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) |
---|
| 600 | ,array->extent(2),array->extent(1),array->extent(0)); |
---|
| 601 | status = TV_ttf_add_row("array_values", tname, array->dataFirst()) ; |
---|
| 602 | if (status != TV_ttf_ec_ok) return TV_ttf_format_raw ; |
---|
| 603 | else return TV_ttf_format_ok ; |
---|
| 604 | } |
---|
| 605 | } |
---|
| 606 | |
---|
[677] | 607 | |
---|
[1875] | 608 | static int TV_ttf_display_type ( const CArray<T_numtype,N_rank>* array ) |
---|
| 609 | { |
---|
| 610 | return show_TV_ttf_display_type (array) ; |
---|
| 611 | } |
---|
| 612 | |
---|
[677] | 613 | virtual CBaseType* clone(void) const { return new CArray(*this); } |
---|
| 614 | |
---|
| 615 | virtual bool toBuffer(CBufferOut& buffer) const |
---|
| 616 | { |
---|
| 617 | bool ret; |
---|
| 618 | ret = buffer.put(this->dimensions()); |
---|
| 619 | ret &= buffer.put(this->shape().data(), this->dimensions()); |
---|
| 620 | ret &= buffer.put(this->numElements()); |
---|
| 621 | ret &= buffer.put(this->dataFirst(), this->numElements()); |
---|
| 622 | return ret; |
---|
| 623 | } |
---|
| 624 | |
---|
| 625 | virtual bool fromBuffer(CBufferIn& buffer) |
---|
| 626 | { |
---|
| 627 | bool ret; |
---|
| 628 | int numDim; |
---|
| 629 | TinyVector<int,N_rank> vect; |
---|
| 630 | size_t ne; |
---|
| 631 | |
---|
| 632 | ret = buffer.get(numDim); |
---|
| 633 | ret &= buffer.get(vect.data(), N_rank); |
---|
| 634 | this->resize(vect); |
---|
| 635 | ret &= buffer.get(ne); |
---|
| 636 | ret &= buffer.get(this->dataFirst(), ne); |
---|
| 637 | |
---|
| 638 | initialized = true; |
---|
| 639 | |
---|
| 640 | return ret; |
---|
| 641 | } |
---|
[1875] | 642 | |
---|
[677] | 643 | }; |
---|
| 644 | |
---|
[1158] | 645 | |
---|
[1875] | 646 | #define macrotyperank(_TYPE_,_RANK_)\ |
---|
| 647 | template<> int CArray<_TYPE_,_RANK_>::TV_ttf_display_type( const CArray<_TYPE_,_RANK_>* array ) \ |
---|
| 648 | {\ |
---|
| 649 | return show_TV_ttf_display_type (array) ;\ |
---|
| 650 | } |
---|
| 651 | |
---|
| 652 | #define macrotype(_TYPE_)\ |
---|
| 653 | macrotyperank(_TYPE_,1)\ |
---|
| 654 | macrotyperank(_TYPE_,2)\ |
---|
| 655 | macrotyperank(_TYPE_,3)\ |
---|
| 656 | macrotyperank(_TYPE_,4)\ |
---|
| 657 | macrotyperank(_TYPE_,5)\ |
---|
| 658 | macrotyperank(_TYPE_,6)\ |
---|
| 659 | macrotyperank(_TYPE_,7) |
---|
| 660 | |
---|
| 661 | macrotype(double) |
---|
| 662 | macrotype(int) |
---|
| 663 | macrotype(bool) |
---|
| 664 | macrotype(size_t) |
---|
| 665 | macrotype(float) |
---|
| 666 | macrotype(string) |
---|
| 667 | |
---|
| 668 | #undef macrotyperank |
---|
| 669 | #undef macrotype |
---|
| 670 | |
---|
| 671 | |
---|
| 672 | |
---|
[1158] | 673 | #define macro(NRANK)\ |
---|
| 674 | \ |
---|
| 675 | template <>\ |
---|
| 676 | inline size_t CArray<StdString,NRANK>::size(void) const\ |
---|
| 677 | {\ |
---|
| 678 | size_t size=(1 + NRANK) * sizeof(int) ;\ |
---|
| 679 | Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\ |
---|
| 680 | \ |
---|
| 681 | for(it=itb;it!=ite;++it)\ |
---|
| 682 | {\ |
---|
| 683 | size+= sizeof(size_t) ;\ |
---|
| 684 | size+= (*it).size();\ |
---|
| 685 | } \ |
---|
| 686 | return size ;\ |
---|
| 687 | }\ |
---|
| 688 | \ |
---|
| 689 | /* for array string this function is an evaluation of maximum size of the array, considering stringArrayLen is the maximum size of the strings*/ \ |
---|
| 690 | template <>\ |
---|
| 691 | inline size_t CArray<StdString,NRANK>::size(sizeType numElements)\ |
---|
| 692 | {\ |
---|
| 693 | return (NRANK + 1) * sizeof(int) + numElements * stringArrayLen;\ |
---|
| 694 | }\ |
---|
| 695 | \ |
---|
| 696 | template <>\ |
---|
| 697 | inline bool CArray<StdString,NRANK>::toBuffer(CBufferOut& buffer) const\ |
---|
| 698 | {\ |
---|
| 699 | bool ret;\ |
---|
| 700 | ret = buffer.put(this->dimensions());\ |
---|
| 701 | ret &= buffer.put(this->shape().data(), this->dimensions());\ |
---|
| 702 | \ |
---|
| 703 | Array<StdString,NRANK>::const_iterator it, itb=this->begin(), ite=this->end() ;\ |
---|
| 704 | \ |
---|
| 705 | for(it=itb;it!=ite;++it)\ |
---|
| 706 | {\ |
---|
| 707 | ret &= buffer.put((*it).size()) ;\ |
---|
| 708 | ret &= buffer.put((*it).data(),(*it).size());\ |
---|
| 709 | } \ |
---|
| 710 | return ret;\ |
---|
| 711 | }\ |
---|
| 712 | \ |
---|
| 713 | template <>\ |
---|
| 714 | inline bool CArray<StdString,NRANK>::fromBuffer(CBufferIn& buffer)\ |
---|
| 715 | {\ |
---|
| 716 | bool ret;\ |
---|
| 717 | int numDim;\ |
---|
| 718 | TinyVector<int,NRANK> vect;\ |
---|
| 719 | size_t ne;\ |
---|
| 720 | \ |
---|
| 721 | ret = buffer.get(numDim);\ |
---|
| 722 | ret &= buffer.get(vect.data(), NRANK);\ |
---|
| 723 | this->resize(vect);\ |
---|
| 724 | \ |
---|
| 725 | Array<StdString,NRANK>::iterator it, itb=this->begin(), ite=this->end() ;\ |
---|
| 726 | for(it=itb;it!=ite;++it)\ |
---|
| 727 | {\ |
---|
| 728 | ret &= buffer.get(ne) ;\ |
---|
| 729 | char* str = new char[ne] ;\ |
---|
| 730 | ret &= buffer.get(str, ne);\ |
---|
| 731 | *it = string(str,ne) ;\ |
---|
| 732 | delete [] str ;\ |
---|
| 733 | }\ |
---|
| 734 | initialized = true;\ |
---|
| 735 | return ret;\ |
---|
| 736 | } |
---|
| 737 | macro(1) |
---|
| 738 | macro(2) |
---|
| 739 | macro(3) |
---|
| 740 | macro(4) |
---|
| 741 | macro(5) |
---|
| 742 | macro(6) |
---|
| 743 | macro(7) |
---|
| 744 | |
---|
| 745 | #undef macro |
---|
| 746 | |
---|
[369] | 747 | template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray<T_numtype,N_rank>& array) |
---|
| 748 | { |
---|
[677] | 749 | if (!array.toBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferOut& operator<<(CBufferOut& buffer, const CArray& array)", |
---|
[680] | 750 | << "Not enough free space in buffer to queue the array."); |
---|
[677] | 751 | return buffer; |
---|
[369] | 752 | } |
---|
| 753 | |
---|
| 754 | template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray<T_numtype, N_rank>& array) |
---|
| 755 | { |
---|
| 756 | if (!array.fromBuffer(buffer)) ERROR("template <typename T_numtype,int N_rank> inline CBufferIn& operator>>(CBufferIn& buffer, CArray& array)", |
---|
[680] | 757 | << "Not enough data in buffer to unqueue the array."); |
---|
[677] | 758 | return buffer; |
---|
[369] | 759 | } |
---|
[677] | 760 | |
---|
[369] | 761 | template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, const CArray<T_numtype, N_rank>& array) |
---|
| 762 | { |
---|
[677] | 763 | msg.push(array); |
---|
| 764 | return msg; |
---|
[369] | 765 | } |
---|
| 766 | |
---|
| 767 | template <typename T_numtype,int N_rank> inline CMessage& operator<<(CMessage& msg, CArray<T_numtype, N_rank>& array) |
---|
| 768 | { |
---|
[677] | 769 | msg.push(array); |
---|
| 770 | return msg; |
---|
[369] | 771 | } |
---|
| 772 | } |
---|
| 773 | |
---|
| 774 | #endif |
---|