1 /*
2 Copyright 2010 University Corporation for Atmospheric
3 Research/Unidata. See COPYRIGHT file for more info.
4
5 This file defines the variable functions.
6 */
7
8 #include "ncdispatch.h"
9 #include "netcdf_f.h"
10
11 #if defined(__cplusplus)
12 /* C++ consts default to internal linkage and must be initialized */
13 const size_t coord_zero[NC_MAX_VAR_DIMS] = {0};
14 const size_t coord_one[NC_MAX_VAR_DIMS] = {1};
15 #else
16 static const size_t coord_zero[NC_MAX_VAR_DIMS];
17 /* initialized int put/get_var1 below */
18 static size_t coord_one[NC_MAX_VAR_DIMS];
19 #endif
20
21 #define INITCOORD1 if(coord_one[0] != 1) {int i; for(i=0;i<NC_MAX_VAR_DIMS;i++) coord_one[i] = 1;}
22
23 static nc_type longtype = (sizeof(long) == sizeof(int) ? NC_INT : NC_INT64);
24
25 #define MINVARSSPACE 1024;
26
27 static int
getshape(int ncid,int varid,int ndims,size_t * shape)28 getshape(int ncid, int varid, int ndims, size_t* shape)
29 {
30 int dimids[NC_MAX_VAR_DIMS];
31 int i;
32 int status;
33
34 if ((status = nc_inq_vardimid(ncid, varid, dimids)))
35 return status;
36 for(i = 0; i < ndims; i++)
37 if ((status = nc_inq_dimlen(ncid, dimids[i], &shape[i])))
38 break;
39
40 return status;
41 }
42
43 int
nc_def_var(int ncid,const char * name,nc_type xtype,int ndims,const int * dimidsp,int * varidp)44 nc_def_var(int ncid, const char *name, nc_type xtype,
45 int ndims, const int *dimidsp, int *varidp)
46 {
47 NC* ncp;
48 int stat;
49
50 if ((stat = NC_check_id(ncid, &ncp)))
51 return stat;
52 return ncp->dispatch->def_var(ncid, name, xtype, ndims,
53 dimidsp, varidp);
54 }
55
56 int
nc_inq_varid(int ncid,const char * name,int * varidp)57 nc_inq_varid(int ncid, const char *name, int *varidp)
58 {
59 NC* ncp;
60 int stat = NC_check_id(ncid, &ncp);
61 if(stat != NC_NOERR) return stat;
62 return ncp->dispatch->inq_varid(ncid, name, varidp);
63 }
64
65 int
nc_rename_var(int ncid,int varid,const char * name)66 nc_rename_var(int ncid, int varid, const char *name)
67 {
68 NC* ncp;
69 int stat = NC_check_id(ncid, &ncp);
70 if(stat != NC_NOERR) return stat;
71 return ncp->dispatch->rename_var(ncid, varid, name);
72 }
73
74 int
nc_inq_varname(int ncid,int varid,char * name)75 nc_inq_varname(int ncid, int varid, char *name)
76 {
77 return nc_inq_var(ncid, varid, name, NULL, NULL,
78 NULL, NULL);
79 }
80
81 int
nc_inq_vartype(int ncid,int varid,nc_type * typep)82 nc_inq_vartype(int ncid, int varid, nc_type *typep)
83 {
84 return nc_inq_var(ncid, varid, NULL, typep, NULL,
85 NULL, NULL);
86 }
87
88 int
nc_inq_varndims(int ncid,int varid,int * ndimsp)89 nc_inq_varndims(int ncid, int varid, int *ndimsp)
90 {
91 return nc_inq_var(ncid, varid, NULL, NULL, ndimsp, NULL, NULL);
92 }
93
94 int
nc_inq_vardimid(int ncid,int varid,int * dimids)95 nc_inq_vardimid(int ncid, int varid, int *dimids)
96 {
97 return nc_inq_var(ncid, varid, NULL, NULL, NULL,
98 dimids, NULL);
99 }
100
101 int
nc_inq_varnatts(int ncid,int varid,int * nattsp)102 nc_inq_varnatts(int ncid, int varid, int *nattsp)
103 {
104 if (varid == NC_GLOBAL)
105 return nc_inq_natts(ncid,nattsp);
106 /*else*/
107 return nc_inq_var(ncid, varid, NULL, NULL, NULL, NULL,
108 nattsp);
109 }
110
111 int
nc_inq_nvars(int ncid,int * nvarsp)112 nc_inq_nvars(int ncid, int *nvarsp)
113 {
114 NC* ncp;
115 int stat = NC_check_id(ncid, &ncp);
116 if(stat != NC_NOERR) return stat;
117 return ncp->dispatch->inq(ncid, NULL, nvarsp, NULL, NULL);
118 }
119
120
121 int
nc_inq_var(int ncid,int varid,char * name,nc_type * xtypep,int * ndimsp,int * dimidsp,int * nattsp)122 nc_inq_var(int ncid, int varid, char *name, nc_type *xtypep,
123 int *ndimsp, int *dimidsp, int *nattsp)
124 {
125 NC* ncp;
126 int stat = NC_check_id(ncid, &ncp);
127 if(stat != NC_NOERR) return stat;
128 return ncp->dispatch->inq_var_all(ncid, varid, name, xtypep, ndimsp,
129 dimidsp, nattsp, NULL, NULL, NULL,
130 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
131 }
132
133 static int
NC_put_vara(int ncid,int varid,const size_t * start,const size_t * edges,const void * value,nc_type memtype)134 NC_put_vara(int ncid, int varid, const size_t *start,
135 const size_t *edges, const void *value, nc_type memtype)
136 {
137 NC* ncp;
138 int stat = NC_check_id(ncid, &ncp);
139 if(stat != NC_NOERR) return stat;
140 if(edges == NULL) {
141 size_t shape[NC_MAX_VAR_DIMS];
142 int ndims;
143 stat = nc_inq_varndims(ncid, varid, &ndims);
144 if(stat != NC_NOERR) return stat;
145 stat = getshape(ncid,varid,ndims,shape);
146 if(stat != NC_NOERR) return stat;
147 return ncp->dispatch->put_vara(ncid,varid,start,shape,value,memtype);
148 } else
149 return ncp->dispatch->put_vara(ncid,varid,start,edges,value,memtype);
150 }
151
152 int
NC_get_vara(int ncid,int varid,const size_t * start,const size_t * edges,void * value,nc_type memtype)153 NC_get_vara(int ncid, int varid,
154 const size_t *start, const size_t *edges,
155 void *value, nc_type memtype)
156 {
157 NC* ncp;
158 int stat = NC_check_id(ncid, &ncp);
159 if(stat != NC_NOERR) return stat;
160 #ifdef USE_NETCDF4
161 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
162 #endif
163 if(edges == NULL) {
164 size_t shape[NC_MAX_VAR_DIMS];
165 int ndims;
166 stat = nc_inq_varndims(ncid, varid, &ndims);
167 if(stat != NC_NOERR) return stat;
168 stat = getshape(ncid,varid,ndims,shape);
169 if(stat != NC_NOERR) return stat;
170 return ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
171 } else
172 return ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
173 }
174
175 static int
NC_get_var(int ncid,int varid,void * value,nc_type memtype)176 NC_get_var(int ncid, int varid, void *value, nc_type memtype)
177 {
178 int ndims;
179 size_t shape[NC_MAX_VAR_DIMS];
180 int stat = nc_inq_varndims(ncid,varid, &ndims);
181 if(stat) return stat;
182 stat = getshape(ncid,varid, ndims, shape);
183 if(stat) return stat;
184 return NC_get_vara(ncid, varid, coord_zero, shape, value, memtype);
185 }
186
187 static int
NC_put_var(int ncid,int varid,const void * value,nc_type memtype)188 NC_put_var(int ncid, int varid, const void *value, nc_type memtype)
189 {
190 int ndims;
191 size_t shape[NC_MAX_VAR_DIMS];
192 int stat = nc_inq_varndims(ncid,varid, &ndims);
193 if(stat) return stat;
194 stat = getshape(ncid,varid, ndims, shape);
195 if(stat) return stat;
196 return NC_put_vara(ncid, varid, coord_zero, shape, value, memtype);
197 }
198
199 static int
NC_get_var1(int ncid,int varid,const size_t * coord,void * value,nc_type memtype)200 NC_get_var1(int ncid, int varid, const size_t *coord, void* value,
201 nc_type memtype)
202 {
203 INITCOORD1;
204 return NC_get_vara(ncid, varid, coord, coord_one, value, memtype);
205 }
206
207 static int
NC_put_var1(int ncid,int varid,const size_t * coord,const void * value,nc_type memtype)208 NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
209 nc_type memtype)
210 {
211 INITCOORD1;
212 return NC_put_vara(ncid, varid, coord, coord_one, value, memtype);
213 }
214
215 static int
is_recvar(int ncid,int varid,size_t * nrecs)216 is_recvar(int ncid, int varid, size_t* nrecs)
217 {
218 int status;
219 int unlimid;
220 int ndims;
221 int dimset[NC_MAX_VAR_DIMS];
222
223 status = nc_inq_unlimdim(ncid,&unlimid);
224 if(status != NC_NOERR) return 0; /* no unlimited defined */
225 status = nc_inq_varndims(ncid,varid,&ndims);
226 if(status != NC_NOERR) return 0; /* no unlimited defined */
227 if(ndims == 0) return 0; /* scalar */
228 status = nc_inq_vardimid(ncid,varid,dimset);
229 if(status != NC_NOERR) return 0; /* no unlimited defined */
230 status = nc_inq_dim(ncid,dimset[0],NULL,nrecs);
231 if(status != NC_NOERR) return 0;
232 return (dimset[0] == unlimid ? 1: 0);
233 }
234
235 /* Most dispatch tables will use the default procedures */
236 int
NCDEFAULT_get_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,void * value,nc_type memtype)237 NCDEFAULT_get_vars(int ncid, int varid, const size_t * start,
238 const size_t * edges, const ptrdiff_t * stride,
239 void *value, nc_type memtype)
240 {
241 NC* ncp;
242 int stat = NC_check_id(ncid, &ncp);
243
244 if(stat != NC_NOERR) return stat;
245 return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,NULL,value,memtype);
246 }
247
248 int
NCDEFAULT_put_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const void * value,nc_type memtype)249 NCDEFAULT_put_vars(int ncid, int varid, const size_t * start,
250 const size_t * edges, const ptrdiff_t * stride,
251 const void *value, nc_type memtype)
252 {
253 NC* ncp;
254 int stat = NC_check_id(ncid, &ncp);
255
256 if(stat != NC_NOERR) return stat;
257 return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value,memtype);
258 }
259
260 int
NCDEFAULT_get_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,void * value0,nc_type memtype)261 NCDEFAULT_get_varm(int ncid, int varid, const size_t *start,
262 const size_t *edges, const ptrdiff_t *stride,
263 const ptrdiff_t *imapp, void *value0, nc_type memtype)
264 {
265 int status;
266 nc_type vartype;
267 int varndims,maxidim;
268 NC* ncp;
269 size_t memtypelen;
270 ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
271 char* value = (char*)value0;
272
273 status = NC_check_id (ncid, &ncp);
274 if(status != NC_NOERR) return status;
275
276 /*
277 if(NC_indef(ncp)) return NC_EINDEFINE;
278 */
279
280 status = nc_inq_vartype(ncid, varid, &vartype);
281 if(status != NC_NOERR) return status;
282 /* Check that this is an atomic type */
283 if(vartype >= NC_MAX_ATOMIC_TYPE)
284 return NC_EMAPTYPE;
285
286 status = nc_inq_varndims(ncid, varid, &varndims);
287 if(status != NC_NOERR) return status;
288
289 if(memtype == NC_NAT) {
290 if(imapp != NULL && varndims != 0) {
291 /*
292 * convert map units from bytes to units of sizeof(type)
293 */
294 size_t ii;
295 const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
296 for(ii = 0; ii < varndims; ii++) {
297 if(imapp[ii] % szof != 0) {
298 /*free(cvtmap);*/
299 return NC_EINVAL;
300 }
301 cvtmap[ii] = imapp[ii] / szof;
302 }
303 imapp = cvtmap;
304 }
305 memtype = vartype;
306 }
307
308 if(memtype == NC_CHAR && vartype != NC_CHAR)
309 return NC_ECHAR;
310 else if(memtype != NC_CHAR && vartype == NC_CHAR)
311 return NC_ECHAR;
312
313 memtypelen = nctypelen(memtype);
314
315 maxidim = (int) varndims - 1;
316
317 if (maxidim < 0)
318 {
319 /*
320 * The variable is a scalar; consequently,
321 * there s only one thing to get and only one place to put it.
322 * (Why was I called?)
323 */
324 size_t edge1[1] = {1};
325 return NC_get_vara(ncid, varid, start, edge1, value, memtype);
326 }
327
328 /*
329 * else
330 * The variable is an array.
331 */
332 {
333 int idim;
334 size_t *mystart = NULL;
335 size_t *myedges;
336 size_t *iocount; /* count vector */
337 size_t *stop; /* stop indexes */
338 size_t *length; /* edge lengths in bytes */
339 ptrdiff_t *mystride;
340 ptrdiff_t *mymap;
341 size_t varshape[NC_MAX_VAR_DIMS];
342 int isrecvar;
343 size_t numrecs;
344
345 /* Compute some dimension related values */
346 isrecvar = is_recvar(ncid,varid,&numrecs);
347 getshape(ncid,varid,varndims,varshape);
348
349 /*
350 * Verify stride argument; also see if stride is all ones
351 */
352 if(stride != NULL) {
353 int stride1 = 1;
354 for (idim = 0; idim <= maxidim; ++idim)
355 {
356 if (stride[idim] == 0
357 /* cast needed for braindead systems with signed size_t */
358 || ((unsigned long) stride[idim] >= X_INT_MAX))
359 {
360 return NC_ESTRIDE;
361 }
362 if(stride[idim] != 1) stride1 = 0;
363 }
364 /* If stride1 is true, and there is no imap
365 then call get_vara directly.
366 */
367 if(stride1 && imapp == NULL) {
368 return NC_get_vara(ncid, varid, start, edges, value, memtype);
369 }
370 }
371
372 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
373 /* Allocate space for mystart,mystride,mymap etc.all at once */
374 mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t));
375 if(mystart == NULL) return NC_ENOMEM;
376 myedges = mystart + varndims;
377 iocount = myedges + varndims;
378 stop = iocount + varndims;
379 length = stop + varndims;
380 mystride = (ptrdiff_t *)(length + varndims);
381 mymap = mystride + varndims;
382
383 /*
384 * Initialize I/O parameters.
385 */
386 for (idim = maxidim; idim >= 0; --idim)
387 {
388 mystart[idim] = start != NULL
389 ? start[idim]
390 : 0;
391
392 if (edges != NULL && edges[idim] == 0)
393 {
394 status = NC_NOERR; /* read/write no data */
395 goto done;
396 }
397
398 #ifdef COMPLEX
399 myedges[idim] = edges != NULL
400 ? edges[idim]
401 : idim == 0 && isrecvar
402 ? numrecs - mystart[idim]
403 : varshape[idim] - mystart[idim];
404 #else
405 if(edges != NULL)
406 myedges[idim] = edges[idim];
407 else if (idim == 0 && isrecvar)
408 myedges[idim] = numrecs - mystart[idim];
409 else
410 myedges[idim] = varshape[idim] - mystart[idim];
411 #endif
412
413 mystride[idim] = stride != NULL
414 ? stride[idim]
415 : 1;
416
417 /* Remember: imapp is byte oriented, not index oriented */
418 #ifdef COMPLEX
419 mymap[idim] = (imapp != NULL
420 ? imapp[idim]
421 : (idim == maxidim ? 1
422 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]));
423 #else
424 if(imapp != NULL)
425 mymap[idim] = imapp[idim];
426 else if (idim == maxidim)
427 mymap[idim] = 1;
428 else
429 mymap[idim] =
430 mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
431 #endif
432 iocount[idim] = 1;
433 length[idim] = mymap[idim] * myedges[idim];
434 stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
435 }
436
437 /*
438 * Check start, edges
439 */
440 for (idim = maxidim; idim >= 0; --idim)
441 {
442 size_t dimlen =
443 idim == 0 && isrecvar
444 ? numrecs
445 : varshape[idim];
446 if (mystart[idim] >= dimlen)
447 {
448 status = NC_EINVALCOORDS;
449 goto done;
450 }
451
452 if (mystart[idim] + myedges[idim] > dimlen)
453 {
454 status = NC_EEDGE;
455 goto done;
456 }
457
458 }
459
460
461 /* Lower body */
462 /*
463 * As an optimization, adjust I/O parameters when the fastest
464 * dimension has unity stride both externally and internally.
465 * In this case, the user could have called a simpler routine
466 * (i.e. ncvar$1()
467 */
468 if (mystride[maxidim] == 1
469 && mymap[maxidim] == 1)
470 {
471 iocount[maxidim] = myedges[maxidim];
472 mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
473 mymap[maxidim] = (ptrdiff_t) length[maxidim];
474 }
475
476 /*
477 * Perform I/O. Exit when done.
478 */
479 for (;;)
480 {
481 /* TODO: */
482 int lstatus = NC_get_vara(ncid, varid, mystart, iocount,
483 value, memtype);
484 if (lstatus != NC_NOERR) {
485 if(status == NC_NOERR || lstatus != NC_ERANGE)
486 status = lstatus;
487 }
488 /*
489 * The following code permutes through the variable s
490 * external start-index space and it s internal address
491 * space. At the UPC, this algorithm is commonly
492 * called "odometer code".
493 */
494 idim = maxidim;
495 carry:
496 value += (mymap[idim] * memtypelen);
497 mystart[idim] += mystride[idim];
498 if (mystart[idim] == stop[idim])
499 {
500 mystart[idim] = start[idim];
501 value -= (length[idim] * memtypelen);
502 if (--idim < 0)
503 break; /* normal return */
504 goto carry;
505 }
506 } /* I/O loop */
507 done:
508 free(mystart);
509 } /* variable is array */
510 return status;
511 }
512
513
514 int
NCDEFAULT_put_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const void * value0,nc_type memtype)515 NCDEFAULT_put_varm(
516 int ncid,
517 int varid,
518 const size_t * start,
519 const size_t * edges,
520 const ptrdiff_t * stride,
521 const ptrdiff_t * imapp,
522 const void *value0,
523 nc_type memtype)
524 {
525 int status;
526 nc_type vartype;
527 int varndims,maxidim;
528 NC* ncp;
529 size_t memtypelen;
530 ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
531 const char* value = (char*)value0;
532
533 status = NC_check_id (ncid, &ncp);
534 if(status != NC_NOERR) return status;
535
536 /*
537 if(NC_indef(ncp)) return NC_EINDEFINE;
538 if(NC_readonly (ncp)) return NC_EPERM;
539 */
540
541 /* mid body */
542 status = nc_inq_vartype(ncid, varid, &vartype);
543 if(status != NC_NOERR) return status;
544 /* Check that this is an atomic type */
545 if(vartype >= NC_MAX_ATOMIC_TYPE)
546 return NC_EMAPTYPE;
547
548 status = nc_inq_varndims(ncid, varid, &varndims);
549 if(status != NC_NOERR) return status;
550
551 if(memtype == NC_NAT) {
552 if(imapp != NULL && varndims != 0) {
553 /*
554 * convert map units from bytes to units of sizeof(type)
555 */
556 size_t ii;
557 const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
558 for(ii = 0; ii < varndims; ii++) {
559 if(imapp[ii] % szof != 0) {
560 /*free(cvtmap);*/
561 return NC_EINVAL;
562 }
563 cvtmap[ii] = imapp[ii] / szof;
564 }
565 imapp = cvtmap;
566 }
567 memtype = vartype;
568 }
569
570 if(memtype == NC_CHAR && vartype != NC_CHAR)
571 return NC_ECHAR;
572 else if(memtype != NC_CHAR && vartype == NC_CHAR)
573 return NC_ECHAR;
574
575 memtypelen = nctypelen(memtype);
576
577 maxidim = (int) varndims - 1;
578
579 if (maxidim < 0)
580 {
581 /*
582 * The variable is a scalar; consequently,
583 * there s only one thing to get and only one place to put it.
584 * (Why was I called?)
585 */
586 size_t edge1[1] = {1};
587 return NC_put_vara(ncid, varid, start, edge1, value, memtype);
588 }
589
590 /*
591 * else
592 * The variable is an array.
593 */
594 {
595 int idim;
596 size_t *mystart = NULL;
597 size_t *myedges;
598 size_t *iocount; /* count vector */
599 size_t *stop; /* stop indexes */
600 size_t *length; /* edge lengths in bytes */
601 ptrdiff_t *mystride;
602 ptrdiff_t *mymap;
603 size_t varshape[NC_MAX_VAR_DIMS];
604 int isrecvar;
605 size_t numrecs;
606 int stride1; /* is stride all ones? */
607
608 /*
609 * Verify stride argument.
610 */
611 if(stride != NULL)
612 stride1 = 1;
613 for (idim = 0; idim <= maxidim; ++idim)
614 {
615 if ((stride[idim] == 0)
616 /* cast needed for braindead systems with signed size_t */
617 || ((unsigned long) stride[idim] >= X_INT_MAX))
618 {
619 return NC_ESTRIDE;
620 }
621 if(stride[idim] != 1) stride1 = 0;
622 }
623
624 /* If stride1 is true, and there is no imap, then call get_vara
625 directly
626 */
627 if(stride1 && imapp == NULL) {
628 return NC_put_vara(ncid, varid, start, edges, value, memtype);
629 }
630
631 /* Compute some dimension related values */
632 isrecvar = is_recvar(ncid,varid,&numrecs);
633 getshape(ncid,varid,varndims,varshape);
634
635 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
636 mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t));
637 if(mystart == NULL) return NC_ENOMEM;
638 myedges = mystart + varndims;
639 iocount = myedges + varndims;
640 stop = iocount + varndims;
641 length = stop + varndims;
642 mystride = (ptrdiff_t *)(length + varndims);
643 mymap = mystride + varndims;
644
645 /*
646 * Initialize I/O parameters.
647 */
648 for (idim = maxidim; idim >= 0; --idim)
649 {
650 mystart[idim] = start != NULL
651 ? start[idim]
652 : 0;
653
654 if (edges != NULL && edges[idim] == 0)
655 {
656 status = NC_NOERR; /* read/write no data */
657 goto done;
658 }
659
660 myedges[idim] = edges != NULL
661 ? edges[idim]
662 : idim == 0 && isrecvar
663 ? numrecs - mystart[idim]
664 : varshape[idim] - mystart[idim];
665 mystride[idim] = stride != NULL
666 ? stride[idim]
667 : 1;
668 mymap[idim] = imapp != NULL
669 ? imapp[idim]
670 : idim == maxidim
671 ? 1
672 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
673
674 iocount[idim] = 1;
675 length[idim] = mymap[idim] * myedges[idim];
676 stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
677 }
678
679 /*
680 * Check start, edges
681 */
682 for (idim = isrecvar; idim < maxidim; ++idim)
683 {
684 if (mystart[idim] > varshape[idim])
685 {
686 status = NC_EINVALCOORDS;
687 goto done;
688 }
689 if (mystart[idim] + myedges[idim] > varshape[idim])
690 {
691 status = NC_EEDGE;
692 goto done;
693 }
694 }
695
696 /* Lower body */
697 /*
698 * As an optimization, adjust I/O parameters when the fastest
699 * dimension has unity stride both externally and internally.
700 * In this case, the user could have called a simpler routine
701 * (i.e. ncvar$1()
702 */
703 if (mystride[maxidim] == 1
704 && mymap[maxidim] == 1)
705 {
706 iocount[maxidim] = myedges[maxidim];
707 mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
708 mymap[maxidim] = (ptrdiff_t) length[maxidim];
709 }
710
711 /*
712 * Perform I/O. Exit when done.
713 */
714 for (;;)
715 {
716 /* TODO: */
717 int lstatus = NC_put_vara(ncid, varid, mystart, iocount,
718 value, memtype);
719 if (lstatus != NC_NOERR) {
720 if(status == NC_NOERR || lstatus != NC_ERANGE)
721 status = lstatus;
722 }
723
724 /*
725 * The following code permutes through the variable s
726 * external start-index space and it s internal address
727 * space. At the UPC, this algorithm is commonly
728 * called "odometer code".
729 */
730 idim = maxidim;
731 carry:
732 value += (mymap[idim] * memtypelen);
733 mystart[idim] += mystride[idim];
734 if (mystart[idim] == stop[idim])
735 {
736 mystart[idim] = start[idim];
737 value -= (length[idim] * memtypelen);
738 if (--idim < 0)
739 break; /* normal return */
740 goto carry;
741 }
742 } /* I/O loop */
743 done:
744 free(mystart);
745 } /* variable is array */
746 return status;
747 }
748
749 /* Called by externally visible nc_get_vars_xxx routines */
750 static int
NC_get_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,void * value,nc_type memtype)751 NC_get_vars(int ncid, int varid, const size_t *start,
752 const size_t *edges, const ptrdiff_t *stride, void *value,
753 nc_type memtype)
754 {
755 NC* ncp;
756 int stat = NC_check_id(ncid, &ncp);
757
758 if(stat != NC_NOERR) return stat;
759 #ifdef USE_NETCDF4
760 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
761 #endif
762 return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
763 }
764
765 static int
NC_put_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const void * value,nc_type memtype)766 NC_put_vars(int ncid, int varid, const size_t *start,
767 const size_t *edges, const ptrdiff_t *stride,
768 const void *value, nc_type memtype)
769 {
770 NC* ncp;
771 int stat = NC_check_id(ncid, &ncp);
772
773 if(stat != NC_NOERR) return stat;
774 #ifdef USE_NETCDF4
775 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
776 #endif
777 return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
778 }
779
780 /* Called by externally visible nc_get_vars_xxx routines */
781 static int
NC_get_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * map,void * value,nc_type memtype)782 NC_get_varm(int ncid, int varid, const size_t *start,
783 const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
784 void *value, nc_type memtype)
785 {
786 NC* ncp;
787 int stat = NC_check_id(ncid, &ncp);
788
789 if(stat != NC_NOERR) return stat;
790 #ifdef USE_NETCDF4
791 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
792 #endif
793 return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
794 }
795
796 static int
NC_put_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * map,const void * value,nc_type memtype)797 NC_put_varm(int ncid, int varid, const size_t *start,
798 const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
799 const void *value, nc_type memtype)
800 {
801 NC* ncp;
802 int stat = NC_check_id(ncid, &ncp);
803
804 if(stat != NC_NOERR) return stat;
805 #ifdef USE_NETCDF4
806 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
807 #endif
808 return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
809 }
810
811 /* Ok to use NC pointers because
812 all IOSP's will use that structure,
813 but not ok to use e.g. NC_Var pointers
814 because they may be different structure
815 entirely.
816 */
817
818 /*
819 * This is how much space is required by the user, as in
820 *
821 * vals = malloc(nel * nctypelen(var.type));
822 * ncvarget(cdfid, varid, cor, edg, vals);
823 */
824 int
nctypelen(nc_type type)825 nctypelen(nc_type type)
826 {
827 switch(type){
828 case NC_CHAR :
829 return((int)sizeof(char));
830 case NC_BYTE :
831 return((int)sizeof(signed char));
832 case NC_SHORT :
833 return(int)(sizeof(short));
834 case NC_INT :
835 return((int)sizeof(int));
836 case NC_FLOAT :
837 return((int)sizeof(float));
838 case NC_DOUBLE :
839 return((int)sizeof(double));
840
841 /* These can occur in netcdf-3 code */
842 case NC_UBYTE :
843 return((int)sizeof(unsigned char));
844 case NC_USHORT :
845 return((int)(sizeof(unsigned short)));
846 case NC_UINT :
847 return((int)sizeof(unsigned int));
848 case NC_INT64 :
849 return((int)sizeof(signed long long));
850 case NC_UINT64 :
851 return((int)sizeof(unsigned long long));
852 #ifdef USE_NETCDF4
853 case NC_STRING :
854 return((int)sizeof(char*));
855 #endif /*USE_NETCDF4*/
856
857 default:
858 return -1;
859 }
860 }
861
862 /* utility functions */
863 /* Redunant over nctypelen above */
864 int
NC_atomictypelen(nc_type xtype)865 NC_atomictypelen(nc_type xtype)
866 {
867 int sz = 0;
868 switch(xtype) {
869 case NC_NAT: sz = 0; break;
870 case NC_BYTE: sz = sizeof(signed char); break;
871 case NC_CHAR: sz = sizeof(char); break;
872 case NC_SHORT: sz = sizeof(short); break;
873 case NC_INT: sz = sizeof(int); break;
874 case NC_FLOAT: sz = sizeof(float); break;
875 case NC_DOUBLE: sz = sizeof(double); break;
876 case NC_INT64: sz = sizeof(signed long long); break;
877 case NC_UBYTE: sz = sizeof(unsigned char); break;
878 case NC_USHORT: sz = sizeof(unsigned short); break;
879 case NC_UINT: sz = sizeof(unsigned int); break;
880 case NC_UINT64: sz = sizeof(unsigned long long); break;
881 #ifdef USE_NETCDF4
882 case NC_STRING: sz = sizeof(char*); break;
883 #endif
884 default: break;
885 }
886 return sz;
887 }
888
889 char*
NC_atomictypename(nc_type xtype)890 NC_atomictypename(nc_type xtype)
891 {
892 char* nm = NULL;
893 switch(xtype) {
894 case NC_NAT: nm = "undefined"; break;
895 case NC_BYTE: nm = "byte"; break;
896 case NC_CHAR: nm = "char"; break;
897 case NC_SHORT: nm = "short"; break;
898 case NC_INT: nm = "int"; break;
899 case NC_FLOAT: nm = "float"; break;
900 case NC_DOUBLE: nm = "double"; break;
901 case NC_INT64: nm = "int64"; break;
902 case NC_UBYTE: nm = "ubyte"; break;
903 case NC_USHORT: nm = "ushort"; break;
904 case NC_UINT: nm = "uint"; break;
905 case NC_UINT64: nm = "uint64"; break;
906 #ifdef USE_NETCDF4
907 case NC_STRING: nm = "string"; break;
908 #endif
909 default: break;
910 }
911 return nm;
912 }
913
914 int
nc_put_vara(int ncid,int varid,const size_t * start,const size_t * edges,const void * value)915 nc_put_vara(int ncid, int varid,
916 const size_t *start, const size_t *edges,
917 const void *value)
918 {
919 NC* ncp;
920 int stat = NC_check_id(ncid, &ncp);
921 nc_type xtype;
922 if(stat != NC_NOERR) return stat;
923 stat = nc_inq_vartype(ncid, varid, &xtype);
924 if(stat != NC_NOERR) return stat;
925 return NC_put_vara(ncid,varid,start,edges,value,xtype);
926 }
927
928 int
nc_get_vara(int ncid,int varid,const size_t * start,const size_t * edges,void * value)929 nc_get_vara(int ncid, int varid,
930 const size_t *start, const size_t *edges,
931 void *value)
932 {
933 NC* ncp;
934 int stat = NC_check_id(ncid, &ncp);
935 nc_type xtype;
936 if(stat != NC_NOERR) return stat;
937 stat = nc_inq_vartype(ncid, varid, &xtype);
938 if(stat != NC_NOERR) return stat;
939 return NC_get_vara(ncid,varid,start,edges,value,xtype);
940 }
941
942 int
nc_get_var(int ncid,int varid,void * value)943 nc_get_var(int ncid, int varid, void *value)
944 {
945 return NC_get_var(ncid, varid, value, NC_NAT);
946 }
947
948 int
nc_put_var(int ncid,int varid,const void * value)949 nc_put_var(int ncid, int varid, const void *value)
950 {
951 return NC_put_var(ncid, varid, value, NC_NAT);
952 }
953
954 int
nc_get_var1(int ncid,int varid,const size_t * coord,void * value)955 nc_get_var1(int ncid, int varid, const size_t *coord, void *value)
956 {
957 return NC_get_var1(ncid, varid, coord, value, NC_NAT);
958 }
959
960 int
nc_put_var1(int ncid,int varid,const size_t * coord,const void * value)961 nc_put_var1(int ncid, int varid, const size_t *coord, const void *value)
962 {
963 return NC_put_var1(ncid, varid, coord, value, NC_NAT);
964 }
965
966 int
nc_get_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,void * value)967 nc_get_varm(int ncid, int varid, const size_t * start,
968 const size_t * edges, const ptrdiff_t * stride,
969 const ptrdiff_t * imapp, void *value)
970 {
971 NC* ncp;
972 int stat;
973
974 if ((stat = NC_check_id(ncid, &ncp)))
975 return stat;
976 return ncp->dispatch->get_varm(ncid, varid, start, edges, stride, imapp,
977 value, NC_NAT);
978 }
979
980 int
nc_put_varm(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const void * value)981 nc_put_varm (int ncid, int varid, const size_t * start,
982 const size_t * edges, const ptrdiff_t * stride,
983 const ptrdiff_t * imapp, const void *value)
984 {
985 NC* ncp;
986 int stat;
987
988 if ((stat = NC_check_id(ncid, &ncp)))
989 return stat;
990 return ncp->dispatch->put_varm(ncid, varid, start, edges, stride, imapp,
991 value, NC_NAT);
992 }
993
994 int
nc_get_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,void * value)995 nc_get_vars (int ncid, int varid, const size_t * start,
996 const size_t * edges, const ptrdiff_t * stride,
997 void *value)
998 {
999 NC* ncp;
1000 int stat;
1001
1002 if ((stat = NC_check_id(ncid, &ncp)))
1003 return stat;
1004 return ncp->dispatch->get_vars(ncid, varid, start, edges, stride,
1005 value, NC_NAT);
1006 }
1007
1008 int
nc_put_vars(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const void * value)1009 nc_put_vars (int ncid, int varid, const size_t * start,
1010 const size_t * edges, const ptrdiff_t * stride,
1011 const void *value)
1012 {
1013 NC* ncp;
1014 int stat;
1015
1016 if ((stat = NC_check_id(ncid, &ncp)))
1017 return stat;
1018 return ncp->dispatch->put_vars(ncid, varid, start, edges, stride,
1019 value, NC_NAT);
1020 }
1021
1022 int
nc_get_var1_text(int ncid,int varid,const size_t * coord,char * value)1023 nc_get_var1_text(int ncid, int varid, const size_t *coord, char *value)
1024 {
1025 NC* ncp;
1026 int stat = NC_check_id(ncid, &ncp);
1027 if(stat != NC_NOERR) return stat;
1028 INITCOORD1;
1029 return NC_get_var1(ncid, varid, coord, (void*)value, NC_CHAR);
1030 }
1031
1032 int
nc_get_var1_schar(int ncid,int varid,const size_t * coord,signed char * value)1033 nc_get_var1_schar(int ncid, int varid, const size_t *coord, signed char *value)
1034 {
1035 NC* ncp;
1036 int stat = NC_check_id(ncid, &ncp);
1037 if(stat != NC_NOERR) return stat;
1038 INITCOORD1;
1039 return NC_get_var1(ncid, varid, coord, (void*)value, NC_BYTE);
1040 }
1041
1042 int
nc_get_var1_uchar(int ncid,int varid,const size_t * coord,unsigned char * value)1043 nc_get_var1_uchar(int ncid, int varid, const size_t *coord, unsigned char *value)
1044 {
1045 NC* ncp;
1046 int stat = NC_check_id(ncid, &ncp);
1047 if(stat != NC_NOERR) return stat;
1048 INITCOORD1;
1049 return NC_get_var1(ncid, varid, coord, (void*)value, NC_UBYTE);
1050 }
1051
1052 int
nc_get_var1_short(int ncid,int varid,const size_t * coord,short * value)1053 nc_get_var1_short(int ncid, int varid, const size_t *coord, short *value)
1054 {
1055 NC* ncp;
1056 int stat = NC_check_id(ncid, &ncp);
1057 if(stat != NC_NOERR) return stat;
1058 INITCOORD1;
1059 return NC_get_var1(ncid, varid, coord, (void*)value, NC_SHORT);
1060 }
1061
1062 int
nc_get_var1_int(int ncid,int varid,const size_t * coord,int * value)1063 nc_get_var1_int(int ncid, int varid, const size_t *coord, int *value)
1064 {
1065 NC* ncp;
1066 int stat = NC_check_id(ncid, &ncp);
1067 if(stat != NC_NOERR) return stat;
1068 INITCOORD1;
1069 return NC_get_var1(ncid, varid, coord, (void*)value, NC_INT);
1070 }
1071
1072 int
nc_get_var1_long(int ncid,int varid,const size_t * coord,long * value)1073 nc_get_var1_long(int ncid, int varid, const size_t *coord, long *value)
1074 {
1075 NC* ncp;
1076 int stat = NC_check_id(ncid, &ncp);
1077 if(stat != NC_NOERR) return stat;
1078 INITCOORD1;
1079 return NC_get_var1(ncid,varid,coord,(void*)value, longtype);
1080 }
1081
1082 int
nc_get_var1_float(int ncid,int varid,const size_t * coord,float * value)1083 nc_get_var1_float(int ncid, int varid, const size_t *coord, float *value)
1084 {
1085 NC* ncp;
1086 int stat = NC_check_id(ncid, &ncp);
1087 if(stat != NC_NOERR) return stat;
1088 INITCOORD1;
1089 return NC_get_var1(ncid,varid,coord,(void*)value, NC_FLOAT);
1090 }
1091
1092 int
nc_get_var1_double(int ncid,int varid,const size_t * coord,double * value)1093 nc_get_var1_double(int ncid, int varid, const size_t *coord, double *value)
1094 {
1095 NC* ncp;
1096 int stat = NC_check_id(ncid, &ncp);
1097 if(stat != NC_NOERR) return stat;
1098 INITCOORD1;
1099 return NC_get_var1(ncid,varid,coord,(void*)value, NC_DOUBLE);
1100 }
1101
1102 int
nc_get_var1_ubyte(int ncid,int varid,const size_t * coord,unsigned char * value)1103 nc_get_var1_ubyte(int ncid, int varid, const size_t *coord, unsigned char *value)
1104 {
1105 NC* ncp;
1106 int stat = NC_check_id(ncid, &ncp);
1107 if(stat != NC_NOERR) return stat;
1108 INITCOORD1;
1109 return NC_get_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
1110 }
1111
1112 int
nc_get_var1_ushort(int ncid,int varid,const size_t * coord,unsigned short * value)1113 nc_get_var1_ushort(int ncid, int varid, const size_t *coord,
1114 unsigned short *value)
1115 {
1116 NC* ncp;
1117 int stat = NC_check_id(ncid, &ncp);
1118 if(stat != NC_NOERR) return stat;
1119 INITCOORD1;
1120 return NC_get_var1(ncid,varid,coord,(void*)value, NC_USHORT);
1121 }
1122
1123 int
nc_get_var1_uint(int ncid,int varid,const size_t * coord,unsigned int * value)1124 nc_get_var1_uint(int ncid, int varid, const size_t *coord, unsigned int *value)
1125 {
1126 NC* ncp;
1127 int stat = NC_check_id(ncid, &ncp);
1128 if(stat != NC_NOERR) return stat;
1129 INITCOORD1;
1130 return NC_get_var1(ncid,varid,coord,(void*)value, NC_INT);
1131 }
1132
1133 int
nc_get_var1_longlong(int ncid,int varid,const size_t * coord,long long * value)1134 nc_get_var1_longlong(int ncid, int varid, const size_t *coord, long long *value)
1135 {
1136 NC* ncp;
1137 int stat = NC_check_id(ncid, &ncp);
1138 if(stat != NC_NOERR) return stat;
1139 INITCOORD1;
1140 return NC_get_var1(ncid,varid,coord,(void*)value, NC_INT64);
1141 }
1142
1143 int
nc_get_var1_ulonglong(int ncid,int varid,const size_t * coord,unsigned long long * value)1144 nc_get_var1_ulonglong(int ncid, int varid, const size_t *coord, unsigned long long *value)
1145 {
1146 NC* ncp;
1147 int stat = NC_check_id(ncid, &ncp);
1148 if(stat != NC_NOERR) return stat;
1149 INITCOORD1;
1150 return NC_get_var1(ncid,varid,coord,(void*)value, NC_UINT64);
1151 }
1152
1153 #ifdef USE_NETCDF4
1154 int
nc_get_var1_string(int ncid,int varid,const size_t * coord,char ** value)1155 nc_get_var1_string(int ncid, int varid, const size_t *coord, char* *value)
1156 {
1157 NC* ncp;
1158 int stat = NC_check_id(ncid, &ncp);
1159 if(stat != NC_NOERR) return stat;
1160 INITCOORD1;
1161 return NC_get_var1(ncid,varid,coord,(void*)value, NC_STRING);
1162 }
1163
1164 #endif /*USE_NETCDF4*/
1165
1166 int
nc_put_var1_text(int ncid,int varid,const size_t * coord,const char * value)1167 nc_put_var1_text(int ncid, int varid, const size_t *coord, const char *value)
1168 {
1169 NC* ncp;
1170 int stat = NC_check_id(ncid, &ncp);
1171 if(stat != NC_NOERR) return stat;
1172 INITCOORD1;
1173 return NC_put_var1(ncid,varid,coord,(void*)value, NC_CHAR);
1174 }
1175
1176 int
nc_put_var1_schar(int ncid,int varid,const size_t * coord,const signed char * value)1177 nc_put_var1_schar(int ncid, int varid, const size_t *coord, const signed char *value)
1178 {
1179 NC* ncp;
1180 int stat = NC_check_id(ncid, &ncp);
1181 if(stat != NC_NOERR) return stat;
1182 INITCOORD1;
1183 return NC_put_var1(ncid,varid,coord,(void*)value, NC_BYTE);
1184 }
1185
1186 int
nc_put_var1_uchar(int ncid,int varid,const size_t * coord,const unsigned char * value)1187 nc_put_var1_uchar(int ncid, int varid, const size_t *coord, const unsigned char *value)
1188 {
1189 NC* ncp;
1190 int stat = NC_check_id(ncid, &ncp);
1191 if(stat != NC_NOERR) return stat;
1192 INITCOORD1;
1193 return NC_put_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
1194 }
1195
1196 int
nc_put_var1_short(int ncid,int varid,const size_t * coord,const short * value)1197 nc_put_var1_short(int ncid, int varid, const size_t *coord, const short *value)
1198 {
1199 NC* ncp;
1200 int stat = NC_check_id(ncid, &ncp);
1201 if(stat != NC_NOERR) return stat;
1202 INITCOORD1;
1203 return NC_put_var1(ncid,varid,coord,(void*)value, NC_SHORT);
1204 }
1205
1206 int
nc_put_var1_int(int ncid,int varid,const size_t * coord,const int * value)1207 nc_put_var1_int(int ncid, int varid, const size_t *coord, const int *value)
1208 {
1209 NC* ncp;
1210 int stat = NC_check_id(ncid, &ncp);
1211 if(stat != NC_NOERR) return stat;
1212 INITCOORD1;
1213 return NC_put_var1(ncid,varid,coord,(void*)value, NC_INT);
1214 }
1215
1216 int
nc_put_var1_long(int ncid,int varid,const size_t * coord,const long * value)1217 nc_put_var1_long(int ncid, int varid, const size_t *coord, const long *value)
1218 {
1219 NC* ncp;
1220 int stat = NC_check_id(ncid, &ncp);
1221 if(stat != NC_NOERR) return stat;
1222 INITCOORD1;
1223 return NC_put_var1(ncid,varid,coord,(void*)value, longtype);
1224 }
1225
1226 int
nc_put_var1_float(int ncid,int varid,const size_t * coord,const float * value)1227 nc_put_var1_float(int ncid, int varid, const size_t *coord, const float *value)
1228 {
1229 NC* ncp;
1230 int stat = NC_check_id(ncid, &ncp);
1231 if(stat != NC_NOERR) return stat;
1232 INITCOORD1;
1233 return NC_put_var1(ncid,varid,coord,(void*)value, NC_FLOAT);
1234 }
1235
1236 int
nc_put_var1_double(int ncid,int varid,const size_t * coord,const double * value)1237 nc_put_var1_double(int ncid, int varid, const size_t *coord, const double *value)
1238 {
1239 NC* ncp;
1240 int stat = NC_check_id(ncid, &ncp);
1241 if(stat != NC_NOERR) return stat;
1242 INITCOORD1;
1243 return NC_put_var1(ncid,varid,coord,(void*)value, NC_DOUBLE);
1244 }
1245
1246 int
nc_put_var1_ubyte(int ncid,int varid,const size_t * coord,const unsigned char * value)1247 nc_put_var1_ubyte(int ncid, int varid, const size_t *coord, const unsigned char *value)
1248 {
1249 NC* ncp;
1250 int stat = NC_check_id(ncid, &ncp);
1251 if(stat != NC_NOERR) return stat;
1252 INITCOORD1;
1253 return NC_put_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
1254 }
1255
1256 int
nc_put_var1_ushort(int ncid,int varid,const size_t * coord,const unsigned short * value)1257 nc_put_var1_ushort(int ncid, int varid, const size_t *coord, const unsigned short *value)
1258 {
1259 NC* ncp;
1260 int stat = NC_check_id(ncid, &ncp);
1261 if(stat != NC_NOERR) return stat;
1262 INITCOORD1;
1263 return NC_put_var1(ncid,varid,coord,(void*)value, NC_USHORT);
1264 }
1265
1266 int
nc_put_var1_uint(int ncid,int varid,const size_t * coord,const unsigned int * value)1267 nc_put_var1_uint(int ncid, int varid, const size_t *coord, const unsigned int *value)
1268 {
1269 NC* ncp;
1270 int stat = NC_check_id(ncid, &ncp);
1271 if(stat != NC_NOERR) return stat;
1272 INITCOORD1;
1273 return NC_put_var1(ncid,varid,coord,(void*)value, NC_UINT);
1274 }
1275
1276 int
nc_put_var1_longlong(int ncid,int varid,const size_t * coord,const long long * value)1277 nc_put_var1_longlong(int ncid, int varid, const size_t *coord, const long long *value)
1278 {
1279 NC* ncp;
1280 int stat = NC_check_id(ncid, &ncp);
1281 if(stat != NC_NOERR) return stat;
1282 INITCOORD1;
1283 return NC_put_var1(ncid,varid,coord,(void*)value, NC_INT64);
1284 }
1285
1286 int
nc_put_var1_ulonglong(int ncid,int varid,const size_t * coord,const unsigned long long * value)1287 nc_put_var1_ulonglong(int ncid, int varid, const size_t *coord, const unsigned long long *value)
1288 {
1289 NC* ncp;
1290 int stat = NC_check_id(ncid, &ncp);
1291 if(stat != NC_NOERR) return stat;
1292 INITCOORD1;
1293 return NC_put_var1(ncid,varid,coord,(void*)value, NC_UINT64);
1294 }
1295
1296 #ifdef USE_NETCDF4
1297 int
nc_put_var1_string(int ncid,int varid,const size_t * coord,const char ** value)1298 nc_put_var1_string(int ncid, int varid, const size_t *coord, const char* *value)
1299 {
1300 NC* ncp;
1301 int stat = NC_check_id(ncid, &ncp);
1302 if(stat != NC_NOERR) return stat;
1303 INITCOORD1;
1304 return NC_put_var1(ncid, varid, coord, (void*)value, NC_STRING);
1305 }
1306
1307 #endif /*USE_NETCDF4*/
1308
1309 int
nc_get_var_text(int ncid,int varid,char * value)1310 nc_get_var_text(int ncid, int varid, char *value)
1311 {
1312 NC* ncp;
1313 int stat = NC_check_id(ncid, &ncp);
1314 if(stat != NC_NOERR) return stat;
1315 return NC_get_var(ncid, varid, (void*)value, NC_CHAR);
1316 }
1317
1318 int
nc_get_var_schar(int ncid,int varid,signed char * value)1319 nc_get_var_schar(int ncid, int varid, signed char *value)
1320 {
1321 NC* ncp;
1322 int stat = NC_check_id(ncid, &ncp);
1323 if(stat != NC_NOERR) return stat;
1324 return NC_get_var(ncid,varid,(void*)value, NC_BYTE);
1325 }
1326
1327 int
nc_get_var_uchar(int ncid,int varid,unsigned char * value)1328 nc_get_var_uchar(int ncid, int varid, unsigned char *value)
1329 {
1330 NC* ncp;
1331 int stat = NC_check_id(ncid, &ncp);
1332 if(stat != NC_NOERR) return stat;
1333 return NC_get_var(ncid,varid,(void*)value, NC_UBYTE);
1334 }
1335
1336 int
nc_get_var_short(int ncid,int varid,short * value)1337 nc_get_var_short(int ncid, int varid, short *value)
1338 {
1339 NC* ncp;
1340 int stat = NC_check_id(ncid, &ncp);
1341 if(stat != NC_NOERR) return stat;
1342 return NC_get_var(ncid,varid,(void*)value, NC_SHORT);
1343 }
1344
1345 int
nc_get_var_int(int ncid,int varid,int * value)1346 nc_get_var_int(int ncid, int varid, int *value)
1347 {
1348 NC* ncp;
1349 int stat = NC_check_id(ncid, &ncp);
1350 if(stat != NC_NOERR) return stat;
1351 return NC_get_var(ncid,varid,(void*)value, NC_INT);
1352 }
1353
1354 int
nc_get_var_long(int ncid,int varid,long * value)1355 nc_get_var_long(int ncid, int varid, long *value)
1356 {
1357 NC* ncp;
1358 int stat = NC_check_id(ncid, &ncp);
1359 if(stat != NC_NOERR) return stat;
1360 return NC_get_var(ncid,varid,(void*)value, longtype);
1361 }
1362
1363 int
nc_get_var_float(int ncid,int varid,float * value)1364 nc_get_var_float(int ncid, int varid, float *value)
1365 {
1366 NC* ncp;
1367 int stat = NC_check_id(ncid, &ncp);
1368 if(stat != NC_NOERR) return stat;
1369 return NC_get_var(ncid,varid,(void*)value, NC_FLOAT);
1370 }
1371
1372 int
nc_get_var_double(int ncid,int varid,double * value)1373 nc_get_var_double(int ncid, int varid, double *value)
1374 {
1375 NC* ncp;
1376 int stat = NC_check_id(ncid, &ncp);
1377 if(stat != NC_NOERR) return stat;
1378 return NC_get_var(ncid,varid,(void*)value, NC_DOUBLE);
1379 }
1380
1381 int
nc_get_var_ubyte(int ncid,int varid,unsigned char * value)1382 nc_get_var_ubyte(int ncid, int varid, unsigned char *value)
1383 {
1384 NC* ncp;
1385 int stat = NC_check_id(ncid, &ncp);
1386 if(stat != NC_NOERR) return stat;
1387 return NC_get_var(ncid,varid,(void*)value, NC_UBYTE);
1388 }
1389
1390 int
nc_get_var_ushort(int ncid,int varid,unsigned short * value)1391 nc_get_var_ushort(int ncid, int varid, unsigned short *value)
1392 {
1393 NC* ncp;
1394 int stat = NC_check_id(ncid, &ncp);
1395 if(stat != NC_NOERR) return stat;
1396 return NC_get_var(ncid,varid,(void*)value, NC_USHORT);
1397 }
1398
1399 int
nc_get_var_uint(int ncid,int varid,unsigned int * value)1400 nc_get_var_uint(int ncid, int varid, unsigned int *value)
1401 {
1402 NC* ncp;
1403 int stat = NC_check_id(ncid, &ncp);
1404 if(stat != NC_NOERR) return stat;
1405 return NC_get_var(ncid,varid,(void*)value, NC_UINT);
1406 }
1407
1408 int
nc_get_var_longlong(int ncid,int varid,long long * value)1409 nc_get_var_longlong(int ncid, int varid, long long *value)
1410 {
1411 NC* ncp;
1412 int stat = NC_check_id(ncid, &ncp);
1413 if(stat != NC_NOERR) return stat;
1414 return NC_get_var(ncid,varid,(void*)value, NC_INT64);
1415 }
1416
1417 int
nc_get_var_ulonglong(int ncid,int varid,unsigned long long * value)1418 nc_get_var_ulonglong(int ncid, int varid, unsigned long long *value)
1419 {
1420 NC* ncp;
1421 int stat = NC_check_id(ncid, &ncp);
1422 if(stat != NC_NOERR) return stat;
1423 return NC_get_var(ncid,varid,(void*)value,NC_UINT64);
1424 }
1425
1426 #ifdef USE_NETCDF4
1427 int
nc_get_var_string(int ncid,int varid,char ** value)1428 nc_get_var_string(int ncid, int varid, char* *value)
1429 {
1430 NC* ncp;
1431 int stat = NC_check_id(ncid, &ncp);
1432 if(stat != NC_NOERR) return stat;
1433 return NC_get_var(ncid,varid,(void*)value,NC_STRING);
1434 }
1435
1436 #endif /*USE_NETCDF4*/
1437
1438 int
nc_put_var_text(int ncid,int varid,const char * value)1439 nc_put_var_text(int ncid, int varid, const char *value)
1440 {
1441 NC* ncp;
1442 int stat = NC_check_id(ncid, &ncp);
1443 if(stat != NC_NOERR) return stat;
1444 return NC_put_var(ncid,varid,(void*)value,NC_CHAR);
1445 }
1446
1447 int
nc_put_var_schar(int ncid,int varid,const signed char * value)1448 nc_put_var_schar(int ncid, int varid, const signed char *value)
1449 {
1450 NC* ncp;
1451 int stat = NC_check_id(ncid, &ncp);
1452 if(stat != NC_NOERR) return stat;
1453 return NC_put_var(ncid,varid,(void*)value,NC_BYTE);
1454 }
1455
1456 int
nc_put_var_uchar(int ncid,int varid,const unsigned char * value)1457 nc_put_var_uchar(int ncid, int varid, const unsigned char *value)
1458 {
1459 NC* ncp;
1460 int stat = NC_check_id(ncid, &ncp);
1461 if(stat != NC_NOERR) return stat;
1462 return NC_put_var(ncid,varid,(void*)value,T_uchar);
1463 }
1464
1465 int
nc_put_var_short(int ncid,int varid,const short * value)1466 nc_put_var_short(int ncid, int varid, const short *value)
1467 {
1468 NC* ncp;
1469 int stat = NC_check_id(ncid, &ncp);
1470 if(stat != NC_NOERR) return stat;
1471 return NC_put_var(ncid,varid,(void*)value,NC_SHORT);
1472 }
1473
1474 int
nc_put_var_int(int ncid,int varid,const int * value)1475 nc_put_var_int(int ncid, int varid, const int *value)
1476 {
1477 NC* ncp;
1478 int stat = NC_check_id(ncid, &ncp);
1479 if(stat != NC_NOERR) return stat;
1480 return NC_put_var(ncid,varid,(void*)value,NC_INT);
1481 }
1482
1483 int
nc_put_var_long(int ncid,int varid,const long * value)1484 nc_put_var_long(int ncid, int varid, const long *value)
1485 {
1486 NC* ncp;
1487 int stat = NC_check_id(ncid, &ncp);
1488 if(stat != NC_NOERR) return stat;
1489 return NC_put_var(ncid,varid,(void*)value,T_long);
1490 }
1491
1492 int
nc_put_var_float(int ncid,int varid,const float * value)1493 nc_put_var_float(int ncid, int varid, const float *value)
1494 {
1495 NC* ncp;
1496 int stat = NC_check_id(ncid, &ncp);
1497 if(stat != NC_NOERR) return stat;
1498 return NC_put_var(ncid,varid,(void*)value,T_float);
1499 }
1500
1501 int
nc_put_var_double(int ncid,int varid,const double * value)1502 nc_put_var_double(int ncid, int varid, const double *value)
1503 {
1504 NC* ncp;
1505 int stat = NC_check_id(ncid, &ncp);
1506 if(stat != NC_NOERR) return stat;
1507 return NC_put_var(ncid,varid,(void*)value,T_double);
1508 }
1509
1510 int
nc_put_var_ubyte(int ncid,int varid,const unsigned char * value)1511 nc_put_var_ubyte(int ncid, int varid, const unsigned char *value)
1512 {
1513 NC* ncp;
1514 int stat = NC_check_id(ncid, &ncp);
1515 if(stat != NC_NOERR) return stat;
1516 return NC_put_var(ncid,varid,(void*)value,T_ubyte);
1517 }
1518
1519 int
nc_put_var_ushort(int ncid,int varid,const unsigned short * value)1520 nc_put_var_ushort(int ncid, int varid, const unsigned short *value)
1521 {
1522 NC* ncp;
1523 int stat = NC_check_id(ncid, &ncp);
1524 if(stat != NC_NOERR) return stat;
1525 return NC_put_var(ncid,varid,(void*)value,T_ushort);
1526 }
1527
1528 int
nc_put_var_uint(int ncid,int varid,const unsigned int * value)1529 nc_put_var_uint(int ncid, int varid, const unsigned int *value)
1530 {
1531 NC* ncp;
1532 int stat = NC_check_id(ncid, &ncp);
1533 if(stat != NC_NOERR) return stat;
1534 return NC_put_var(ncid,varid,(void*)value,T_uint);
1535 }
1536
1537 int
nc_put_var_longlong(int ncid,int varid,const long long * value)1538 nc_put_var_longlong(int ncid, int varid, const long long *value)
1539 {
1540 NC* ncp;
1541 int stat = NC_check_id(ncid, &ncp);
1542 if(stat != NC_NOERR) return stat;
1543 return NC_put_var(ncid,varid,(void*)value,T_longlong);
1544 }
1545
1546 int
nc_put_var_ulonglong(int ncid,int varid,const unsigned long long * value)1547 nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *value)
1548 {
1549 NC* ncp;
1550 int stat = NC_check_id(ncid, &ncp);
1551 if(stat != NC_NOERR) return stat;
1552 return NC_put_var(ncid,varid,(void*)value,NC_UINT64);
1553 }
1554
1555 #ifdef USE_NETCDF4
1556 int
nc_put_var_string(int ncid,int varid,const char ** value)1557 nc_put_var_string(int ncid, int varid, const char* *value)
1558 {
1559 NC* ncp;
1560 int stat = NC_check_id(ncid, &ncp);
1561 if(stat != NC_NOERR) return stat;
1562 return NC_put_var(ncid,varid,(void*)value,NC_STRING);
1563 }
1564
1565 #endif /*USE_NETCDF4*/
1566
1567
1568 int
nc_put_vara_text(int ncid,int varid,const size_t * start,const size_t * edges,const char * value)1569 nc_put_vara_text(int ncid, int varid, const size_t *start,
1570 const size_t *edges, const char *value)
1571 {
1572 return NC_put_vara(ncid, varid, start, edges,
1573 (void*)value, NC_CHAR);
1574 }
1575
1576 int
nc_put_vara_schar(int ncid,int varid,const size_t * start,const size_t * edges,const signed char * value)1577 nc_put_vara_schar(int ncid, int varid,
1578 const size_t *start, const size_t *edges, const signed char *value)
1579 {
1580 NC* ncp;
1581 int stat = NC_check_id(ncid, &ncp);
1582 if(stat != NC_NOERR) return stat;
1583 return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_BYTE);
1584 }
1585
1586 int
nc_put_vara_uchar(int ncid,int varid,const size_t * start,const size_t * edges,const unsigned char * value)1587 nc_put_vara_uchar(int ncid, int varid,
1588 const size_t *start, const size_t *edges, const unsigned char *value)
1589 {
1590 NC* ncp;
1591 int stat = NC_check_id(ncid, &ncp);
1592 if(stat != NC_NOERR) return stat;
1593 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_uchar);
1594 }
1595
1596 int
nc_put_vara_short(int ncid,int varid,const size_t * start,const size_t * edges,const short * value)1597 nc_put_vara_short(int ncid, int varid,
1598 const size_t *start, const size_t *edges, const short *value)
1599 {
1600 NC* ncp;
1601 int stat = NC_check_id(ncid, &ncp);
1602 if(stat != NC_NOERR) return stat;
1603 return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_SHORT);
1604 }
1605
1606 int
nc_put_vara_int(int ncid,int varid,const size_t * start,const size_t * edges,const int * value)1607 nc_put_vara_int(int ncid, int varid,
1608 const size_t *start, const size_t *edges, const int *value)
1609 {
1610 NC* ncp;
1611 int stat = NC_check_id(ncid, &ncp);
1612 if(stat != NC_NOERR) return stat;
1613 return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_INT);
1614 }
1615
1616 int
nc_put_vara_long(int ncid,int varid,const size_t * start,const size_t * edges,const long * value)1617 nc_put_vara_long(int ncid, int varid,
1618 const size_t *start, const size_t *edges, const long *value)
1619 {
1620 NC* ncp;
1621 int stat = NC_check_id(ncid, &ncp);
1622 if(stat != NC_NOERR) return stat;
1623 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_long);
1624 }
1625
1626 int
nc_put_vara_float(int ncid,int varid,const size_t * start,const size_t * edges,const float * value)1627 nc_put_vara_float(int ncid, int varid,
1628 const size_t *start, const size_t *edges, const float *value)
1629 {
1630 NC* ncp;
1631 int stat = NC_check_id(ncid, &ncp);
1632 if(stat != NC_NOERR) return stat;
1633 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_float);
1634 }
1635
1636 int
nc_put_vara_double(int ncid,int varid,const size_t * start,const size_t * edges,const double * value)1637 nc_put_vara_double(int ncid, int varid,
1638 const size_t *start, const size_t *edges, const double *value)
1639 {
1640 NC* ncp;
1641 int stat = NC_check_id(ncid, &ncp);
1642 if(stat != NC_NOERR) return stat;
1643 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_double);
1644 }
1645
1646 int
nc_put_vara_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,const unsigned char * value)1647 nc_put_vara_ubyte(int ncid, int varid,
1648 const size_t *start, const size_t *edges, const unsigned char *value)
1649 {
1650 NC* ncp;
1651 int stat = NC_check_id(ncid, &ncp);
1652 if(stat != NC_NOERR) return stat;
1653 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_ubyte);
1654 }
1655
1656 int
nc_put_vara_ushort(int ncid,int varid,const size_t * start,const size_t * edges,const unsigned short * value)1657 nc_put_vara_ushort(int ncid, int varid,
1658 const size_t *start, const size_t *edges, const unsigned short *value)
1659 {
1660 NC* ncp;
1661 int stat = NC_check_id(ncid, &ncp);
1662 if(stat != NC_NOERR) return stat;
1663 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_ushort);
1664 }
1665
1666 int
nc_put_vara_uint(int ncid,int varid,const size_t * start,const size_t * edges,const unsigned int * value)1667 nc_put_vara_uint(int ncid, int varid,
1668 const size_t *start, const size_t *edges, const unsigned int *value)
1669 {
1670 NC* ncp;
1671 int stat = NC_check_id(ncid, &ncp);
1672 if(stat != NC_NOERR) return stat;
1673 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_uint);
1674 }
1675
1676 int
nc_put_vara_longlong(int ncid,int varid,const size_t * start,const size_t * edges,const long long * value)1677 nc_put_vara_longlong(int ncid, int varid,
1678 const size_t *start, const size_t *edges, const long long *value)
1679 {
1680 NC* ncp;
1681 int stat = NC_check_id(ncid, &ncp);
1682 if(stat != NC_NOERR) return stat;
1683 return NC_put_vara(ncid,varid,start,edges,(void*)value,T_longlong);
1684 }
1685
1686 int
nc_put_vara_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,const unsigned long long * value)1687 nc_put_vara_ulonglong(int ncid, int varid,
1688 const size_t *start, const size_t *edges, const unsigned long long *value)
1689 {
1690 NC* ncp;
1691 int stat = NC_check_id(ncid, &ncp);
1692 if(stat != NC_NOERR) return stat;
1693 return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_UINT64);
1694 }
1695
1696 #ifdef USE_NETCDF4
1697 int
nc_put_vara_string(int ncid,int varid,const size_t * start,const size_t * edges,const char ** value)1698 nc_put_vara_string(int ncid, int varid,
1699 const size_t *start, const size_t *edges, const char* *value)
1700 {
1701 NC* ncp;
1702 int stat = NC_check_id(ncid, &ncp);
1703 if(stat != NC_NOERR) return stat;
1704 return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_STRING);
1705 }
1706
1707 #endif /*USE_NETCDF4*/
1708
1709 int
nc_get_vara_text(int ncid,int varid,const size_t * start,const size_t * edges,char * value)1710 nc_get_vara_text(int ncid, int varid,
1711 const size_t *start, const size_t *edges, char *value)
1712 {
1713 NC* ncp;
1714 int stat = NC_check_id(ncid, &ncp);
1715 if(stat != NC_NOERR) return stat;
1716 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_CHAR);
1717 }
1718
1719 int
nc_get_vara_schar(int ncid,int varid,const size_t * start,const size_t * edges,signed char * value)1720 nc_get_vara_schar(int ncid, int varid,
1721 const size_t *start, const size_t *edges, signed char *value)
1722 {
1723 NC* ncp;
1724 int stat = NC_check_id(ncid, &ncp);
1725 if(stat != NC_NOERR) return stat;
1726 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_BYTE);
1727 }
1728
1729 int
nc_get_vara_uchar(int ncid,int varid,const size_t * start,const size_t * edges,unsigned char * value)1730 nc_get_vara_uchar(int ncid, int varid,
1731 const size_t *start, const size_t *edges, unsigned char *value)
1732 {
1733 NC* ncp;
1734 int stat = NC_check_id(ncid, &ncp);
1735 if(stat != NC_NOERR) return stat;
1736 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_uchar);
1737 }
1738
1739 int
nc_get_vara_short(int ncid,int varid,const size_t * start,const size_t * edges,short * value)1740 nc_get_vara_short(int ncid, int varid,
1741 const size_t *start, const size_t *edges, short *value)
1742 {
1743 NC* ncp;
1744 int stat = NC_check_id(ncid, &ncp);
1745 if(stat != NC_NOERR) return stat;
1746 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_SHORT);
1747 }
1748
1749 int
nc_get_vara_int(int ncid,int varid,const size_t * start,const size_t * edges,int * value)1750 nc_get_vara_int(int ncid, int varid,
1751 const size_t *start, const size_t *edges, int *value)
1752 {
1753 NC* ncp;
1754 int stat = NC_check_id(ncid, &ncp);
1755 if(stat != NC_NOERR) return stat;
1756 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_INT);
1757 }
1758
1759 int
nc_get_vara_long(int ncid,int varid,const size_t * start,const size_t * edges,long * value)1760 nc_get_vara_long(int ncid, int varid,
1761 const size_t *start, const size_t *edges, long *value)
1762 {
1763 NC* ncp;
1764 int stat = NC_check_id(ncid, &ncp);
1765 if(stat != NC_NOERR) return stat;
1766 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_long);
1767 }
1768
1769 int
nc_get_vara_float(int ncid,int varid,const size_t * start,const size_t * edges,float * value)1770 nc_get_vara_float(int ncid, int varid,
1771 const size_t *start, const size_t *edges, float *value)
1772 {
1773 NC* ncp;
1774 int stat = NC_check_id(ncid, &ncp);
1775 if(stat != NC_NOERR) return stat;
1776 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_float);
1777 }
1778
1779 int
nc_get_vara_double(int ncid,int varid,const size_t * start,const size_t * edges,double * value)1780 nc_get_vara_double(int ncid, int varid,
1781 const size_t *start, const size_t *edges, double *value)
1782 {
1783 NC* ncp;
1784 int stat = NC_check_id(ncid, &ncp);
1785 if(stat != NC_NOERR) return stat;
1786 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_double);
1787 }
1788
1789 int
nc_get_vara_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,unsigned char * value)1790 nc_get_vara_ubyte(int ncid, int varid,
1791 const size_t *start, const size_t *edges, unsigned char *value)
1792 {
1793 NC* ncp;
1794 int stat = NC_check_id(ncid, &ncp);
1795 if(stat != NC_NOERR) return stat;
1796 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_ubyte);
1797 }
1798
1799 int
nc_get_vara_ushort(int ncid,int varid,const size_t * start,const size_t * edges,unsigned short * value)1800 nc_get_vara_ushort(int ncid, int varid,
1801 const size_t *start, const size_t *edges, unsigned short *value)
1802 {
1803 NC* ncp;
1804 int stat = NC_check_id(ncid, &ncp);
1805 if(stat != NC_NOERR) return stat;
1806 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_ushort);
1807 }
1808
1809 int
nc_get_vara_uint(int ncid,int varid,const size_t * start,const size_t * edges,unsigned int * value)1810 nc_get_vara_uint(int ncid, int varid,
1811 const size_t *start, const size_t *edges, unsigned int *value)
1812 {
1813 NC* ncp;
1814 int stat = NC_check_id(ncid, &ncp);
1815 if(stat != NC_NOERR) return stat;
1816 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_uint);
1817 }
1818
1819 int
nc_get_vara_longlong(int ncid,int varid,const size_t * start,const size_t * edges,long long * value)1820 nc_get_vara_longlong(int ncid, int varid,
1821 const size_t *start, const size_t *edges, long long *value)
1822 {
1823 NC* ncp;
1824 int stat = NC_check_id(ncid, &ncp);
1825 if(stat != NC_NOERR) return stat;
1826 return NC_get_vara(ncid,varid,start,edges,(void*)value,T_longlong);
1827 }
1828
1829 int
nc_get_vara_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,unsigned long long * value)1830 nc_get_vara_ulonglong(int ncid, int varid,
1831 const size_t *start, const size_t *edges, unsigned long long *value)
1832 {
1833 NC* ncp;
1834 int stat = NC_check_id(ncid, &ncp);
1835 if(stat != NC_NOERR) return stat;
1836 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_UINT64);
1837 }
1838
1839 #ifdef USE_NETCDF4
1840 int
nc_get_vara_string(int ncid,int varid,const size_t * start,const size_t * edges,char ** value)1841 nc_get_vara_string(int ncid, int varid,
1842 const size_t *start, const size_t *edges, char* *value)
1843 {
1844 NC* ncp;
1845 int stat = NC_check_id(ncid, &ncp);
1846 if(stat != NC_NOERR) return stat;
1847 return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_STRING);
1848 }
1849
1850 #endif /*USE_NETCDF4*/
1851
1852 int
nc_put_varm_text(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const char * value)1853 nc_put_varm_text(int ncid, int varid,
1854 const size_t *start, const size_t *edges,
1855 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1856 const char *value)
1857 {
1858 NC* ncp;
1859 int stat = NC_check_id(ncid, &ncp);
1860 if(stat != NC_NOERR) return stat;
1861 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_CHAR);
1862 }
1863
1864 int
nc_put_varm_schar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const signed char * value)1865 nc_put_varm_schar(int ncid, int varid,
1866 const size_t *start, const size_t *edges,
1867 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1868 const signed char *value)
1869 {
1870 NC* ncp;
1871 int stat = NC_check_id(ncid, &ncp);
1872 if(stat != NC_NOERR) return stat;
1873 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_BYTE);
1874 }
1875
1876 int
nc_put_varm_uchar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const unsigned char * value)1877 nc_put_varm_uchar(int ncid, int varid,
1878 const size_t *start, const size_t *edges,
1879 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1880 const unsigned char *value)
1881 {
1882 NC* ncp;
1883 int stat = NC_check_id(ncid, &ncp);
1884 if(stat != NC_NOERR) return stat;
1885 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uchar);
1886 }
1887
1888 int
nc_put_varm_short(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const short * value)1889 nc_put_varm_short(int ncid, int varid,
1890 const size_t *start, const size_t *edges,
1891 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1892 const short *value)
1893 {
1894 NC* ncp;
1895 int stat = NC_check_id(ncid, &ncp);
1896 if(stat != NC_NOERR) return stat;
1897 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_SHORT);
1898 }
1899
1900 int
nc_put_varm_int(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const int * value)1901 nc_put_varm_int(int ncid, int varid,
1902 const size_t *start, const size_t *edges,
1903 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1904 const int *value)
1905 {
1906 NC* ncp;
1907 int stat = NC_check_id(ncid, &ncp);
1908 if(stat != NC_NOERR) return stat;
1909 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_INT);
1910 }
1911
1912 int
nc_put_varm_long(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const long * value)1913 nc_put_varm_long(int ncid, int varid,
1914 const size_t *start, const size_t *edges,
1915 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1916 const long *value)
1917 {
1918 NC* ncp;
1919 int stat = NC_check_id(ncid, &ncp);
1920 if(stat != NC_NOERR) return stat;
1921 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_long);
1922 }
1923
1924 int
nc_put_varm_float(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const float * value)1925 nc_put_varm_float(int ncid, int varid,
1926 const size_t *start, const size_t *edges,
1927 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1928 const float *value)
1929 {
1930 NC* ncp;
1931 int stat = NC_check_id(ncid, &ncp);
1932 if(stat != NC_NOERR) return stat;
1933 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_float);
1934 }
1935
1936 int
nc_put_varm_double(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const double * value)1937 nc_put_varm_double(int ncid, int varid,
1938 const size_t *start, const size_t *edges,
1939 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1940 const double *value)
1941 {
1942 NC* ncp;
1943 int stat = NC_check_id(ncid, &ncp);
1944 if(stat != NC_NOERR) return stat;
1945 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_double);
1946 }
1947
1948 int
nc_put_varm_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const unsigned char * value)1949 nc_put_varm_ubyte(int ncid, int varid,
1950 const size_t *start, const size_t *edges,
1951 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1952 const unsigned char *value)
1953 {
1954 NC* ncp;
1955 int stat = NC_check_id(ncid, &ncp);
1956 if(stat != NC_NOERR) return stat;
1957 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ubyte);
1958 }
1959
1960 int
nc_put_varm_ushort(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const unsigned short * value)1961 nc_put_varm_ushort(int ncid, int varid,
1962 const size_t *start, const size_t *edges,
1963 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1964 const unsigned short *value)
1965 {
1966 NC* ncp;
1967 int stat = NC_check_id(ncid, &ncp);
1968 if(stat != NC_NOERR) return stat;
1969 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ushort);
1970 }
1971
1972 int
nc_put_varm_uint(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const unsigned int * value)1973 nc_put_varm_uint(int ncid, int varid,
1974 const size_t *start, const size_t *edges,
1975 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1976 const unsigned int *value)
1977 {
1978 NC* ncp;
1979 int stat = NC_check_id(ncid, &ncp);
1980 if(stat != NC_NOERR) return stat;
1981 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uint);
1982 }
1983
1984 int
nc_put_varm_longlong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const long long * value)1985 nc_put_varm_longlong(int ncid, int varid,
1986 const size_t *start, const size_t *edges,
1987 const ptrdiff_t * stride, const ptrdiff_t * imapp,
1988 const long long *value)
1989 {
1990 NC* ncp;
1991 int stat = NC_check_id(ncid, &ncp);
1992 if(stat != NC_NOERR) return stat;
1993 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_longlong);
1994 }
1995
1996 int
nc_put_varm_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const unsigned long long * value)1997 nc_put_varm_ulonglong(int ncid, int varid,
1998 const size_t *start, const size_t *edges,
1999 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2000 const unsigned long long *value)
2001 {
2002 NC* ncp;
2003 int stat = NC_check_id(ncid, &ncp);
2004 if(stat != NC_NOERR) return stat;
2005 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_UINT64);
2006 }
2007
2008 #ifdef USE_NETCDF4
2009 int
nc_put_varm_string(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,const char ** value)2010 nc_put_varm_string(int ncid, int varid,
2011 const size_t *start, const size_t *edges,
2012 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2013 const char* *value)
2014 {
2015 NC* ncp;
2016 int stat = NC_check_id(ncid, &ncp);
2017 if(stat != NC_NOERR) return stat;
2018 return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_STRING);
2019 }
2020
2021 #endif /*USE_NETCDF4*/
2022
2023 int
nc_get_varm_text(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,char * value)2024 nc_get_varm_text(int ncid, int varid,
2025 const size_t *start, const size_t *edges,
2026 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2027 char *value)
2028 {
2029 NC* ncp;
2030 int stat = NC_check_id(ncid, &ncp);
2031 if(stat != NC_NOERR) return stat;
2032 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_CHAR);
2033 }
2034
2035 int
nc_get_varm_schar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,signed char * value)2036 nc_get_varm_schar(int ncid, int varid,
2037 const size_t *start, const size_t *edges,
2038 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2039 signed char *value)
2040 {
2041 NC* ncp;
2042 int stat = NC_check_id(ncid, &ncp);
2043 if(stat != NC_NOERR) return stat;
2044 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_BYTE);
2045 }
2046
2047 int
nc_get_varm_uchar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,unsigned char * value)2048 nc_get_varm_uchar(int ncid, int varid,
2049 const size_t *start, const size_t *edges,
2050 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2051 unsigned char *value)
2052 {
2053 NC* ncp;
2054 int stat = NC_check_id(ncid, &ncp);
2055 if(stat != NC_NOERR) return stat;
2056 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uchar);
2057 }
2058
2059 int
nc_get_varm_short(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,short * value)2060 nc_get_varm_short(int ncid, int varid,
2061 const size_t *start, const size_t *edges,
2062 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2063 short *value)
2064 {
2065 NC* ncp;
2066 int stat = NC_check_id(ncid, &ncp);
2067 if(stat != NC_NOERR) return stat;
2068 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_SHORT);
2069 }
2070
2071 int
nc_get_varm_int(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,int * value)2072 nc_get_varm_int(int ncid, int varid,
2073 const size_t *start, const size_t *edges,
2074 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2075 int *value)
2076 {
2077 NC* ncp;
2078 int stat = NC_check_id(ncid, &ncp);
2079 if(stat != NC_NOERR) return stat;
2080 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_INT);
2081 }
2082
2083 int
nc_get_varm_long(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,long * value)2084 nc_get_varm_long(int ncid, int varid,
2085 const size_t *start, const size_t *edges,
2086 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2087 long *value)
2088 {
2089 NC* ncp;
2090 int stat = NC_check_id(ncid, &ncp);
2091 if(stat != NC_NOERR) return stat;
2092 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_long);
2093 }
2094
2095 int
nc_get_varm_float(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,float * value)2096 nc_get_varm_float(int ncid, int varid,
2097 const size_t *start, const size_t *edges,
2098 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2099 float *value)
2100 {
2101 NC* ncp;
2102 int stat = NC_check_id(ncid, &ncp);
2103 if(stat != NC_NOERR) return stat;
2104 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_float);
2105 }
2106
2107 int
nc_get_varm_double(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,double * value)2108 nc_get_varm_double(int ncid, int varid,
2109 const size_t *start, const size_t *edges,
2110 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2111 double *value)
2112 {
2113 NC* ncp;
2114 int stat = NC_check_id(ncid, &ncp);
2115 if(stat != NC_NOERR) return stat;
2116 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_double);
2117 }
2118
2119 int
nc_get_varm_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,unsigned char * value)2120 nc_get_varm_ubyte(int ncid, int varid,
2121 const size_t *start, const size_t *edges,
2122 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2123 unsigned char *value)
2124 {
2125 NC* ncp;
2126 int stat = NC_check_id(ncid, &ncp);
2127 if(stat != NC_NOERR) return stat;
2128 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ubyte);
2129 }
2130
2131 int
nc_get_varm_ushort(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,unsigned short * value)2132 nc_get_varm_ushort(int ncid, int varid,
2133 const size_t *start, const size_t *edges,
2134 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2135 unsigned short *value)
2136 {
2137 NC* ncp;
2138 int stat = NC_check_id(ncid, &ncp);
2139 if(stat != NC_NOERR) return stat;
2140 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ushort);
2141 }
2142
2143 int
nc_get_varm_uint(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,unsigned int * value)2144 nc_get_varm_uint(int ncid, int varid,
2145 const size_t *start, const size_t *edges,
2146 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2147 unsigned int *value)
2148 {
2149 NC* ncp;
2150 int stat = NC_check_id(ncid, &ncp);
2151 if(stat != NC_NOERR) return stat;
2152 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uint);
2153 }
2154
2155 int
nc_get_varm_longlong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,long long * value)2156 nc_get_varm_longlong(int ncid, int varid,
2157 const size_t *start, const size_t *edges,
2158 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2159 long long *value)
2160 {
2161 NC* ncp;
2162 int stat = NC_check_id(ncid, &ncp);
2163 if(stat != NC_NOERR) return stat;
2164 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_longlong);
2165 }
2166
2167 int
nc_get_varm_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,unsigned long long * value)2168 nc_get_varm_ulonglong(int ncid, int varid,
2169 const size_t *start, const size_t *edges,
2170 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2171 unsigned long long *value)
2172 {
2173 NC* ncp;
2174 int stat = NC_check_id(ncid, &ncp);
2175 if(stat != NC_NOERR) return stat;
2176 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_UINT64);
2177 }
2178
2179 #ifdef USE_NETCDF4
2180 int
nc_get_varm_string(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const ptrdiff_t * imapp,char ** value)2181 nc_get_varm_string(int ncid, int varid,
2182 const size_t *start, const size_t *edges,
2183 const ptrdiff_t * stride, const ptrdiff_t * imapp,
2184 char* *value)
2185 {
2186 NC* ncp;
2187 int stat = NC_check_id(ncid, &ncp);
2188 if(stat != NC_NOERR) return stat;
2189 return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_STRING);
2190 }
2191
2192 #endif /*USE_NETCDF4*/
2193
2194 int
nc_put_vars_text(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const char * value)2195 nc_put_vars_text(int ncid, int varid,
2196 const size_t *start, const size_t *edges,
2197 const ptrdiff_t * stride,
2198 const char *value)
2199 {
2200 NC* ncp;
2201 int stat = NC_check_id(ncid, &ncp);
2202 if(stat != NC_NOERR) return stat;
2203 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_CHAR);
2204 }
2205
2206 int
nc_put_vars_schar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const signed char * value)2207 nc_put_vars_schar(int ncid, int varid,
2208 const size_t *start, const size_t *edges,
2209 const ptrdiff_t * stride,
2210 const signed char *value)
2211 {
2212 NC* ncp;
2213 int stat = NC_check_id(ncid, &ncp);
2214 if(stat != NC_NOERR) return stat;
2215 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_BYTE);
2216 }
2217
2218 int
nc_put_vars_uchar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const unsigned char * value)2219 nc_put_vars_uchar(int ncid, int varid,
2220 const size_t *start, const size_t *edges,
2221 const ptrdiff_t * stride,
2222 const unsigned char *value)
2223 {
2224 NC* ncp;
2225 int stat = NC_check_id(ncid, &ncp);
2226 if(stat != NC_NOERR) return stat;
2227 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_uchar);
2228 }
2229
2230 int
nc_put_vars_short(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const short * value)2231 nc_put_vars_short(int ncid, int varid,
2232 const size_t *start, const size_t *edges,
2233 const ptrdiff_t * stride,
2234 const short *value)
2235 {
2236 NC* ncp;
2237 int stat = NC_check_id(ncid, &ncp);
2238 if(stat != NC_NOERR) return stat;
2239 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_SHORT);
2240 }
2241
2242 int
nc_put_vars_int(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const int * value)2243 nc_put_vars_int(int ncid, int varid,
2244 const size_t *start, const size_t *edges,
2245 const ptrdiff_t * stride,
2246 const int *value)
2247 {
2248 NC* ncp;
2249 int stat = NC_check_id(ncid, &ncp);
2250 if(stat != NC_NOERR) return stat;
2251 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_INT);
2252 }
2253
2254 int
nc_put_vars_long(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const long * value)2255 nc_put_vars_long(int ncid, int varid,
2256 const size_t *start, const size_t *edges,
2257 const ptrdiff_t * stride,
2258 const long *value)
2259 {
2260 NC* ncp;
2261 int stat = NC_check_id(ncid, &ncp);
2262 if(stat != NC_NOERR) return stat;
2263 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_long);
2264 }
2265
2266 int
nc_put_vars_float(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const float * value)2267 nc_put_vars_float(int ncid, int varid,
2268 const size_t *start, const size_t *edges,
2269 const ptrdiff_t * stride,
2270 const float *value)
2271 {
2272 NC* ncp;
2273 int stat = NC_check_id(ncid, &ncp);
2274 if(stat != NC_NOERR) return stat;
2275 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_float);
2276 }
2277
2278 int
nc_put_vars_double(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const double * value)2279 nc_put_vars_double(int ncid, int varid,
2280 const size_t *start, const size_t *edges,
2281 const ptrdiff_t * stride,
2282 const double *value)
2283 {
2284 NC* ncp;
2285 int stat = NC_check_id(ncid, &ncp);
2286 if(stat != NC_NOERR) return stat;
2287 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_double);
2288 }
2289
2290 int
nc_put_vars_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const unsigned char * value)2291 nc_put_vars_ubyte(int ncid, int varid,
2292 const size_t *start, const size_t *edges,
2293 const ptrdiff_t * stride,
2294 const unsigned char *value)
2295 {
2296 NC* ncp;
2297 int stat = NC_check_id(ncid, &ncp);
2298 if(stat != NC_NOERR) return stat;
2299 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_ubyte);
2300 }
2301
2302 int
nc_put_vars_ushort(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const unsigned short * value)2303 nc_put_vars_ushort(int ncid, int varid,
2304 const size_t *start, const size_t *edges,
2305 const ptrdiff_t * stride,
2306 const unsigned short *value)
2307 {
2308 NC* ncp;
2309 int stat = NC_check_id(ncid, &ncp);
2310 if(stat != NC_NOERR) return stat;
2311 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_ushort);
2312 }
2313
2314 int
nc_put_vars_uint(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const unsigned int * value)2315 nc_put_vars_uint(int ncid, int varid,
2316 const size_t *start, const size_t *edges,
2317 const ptrdiff_t * stride,
2318 const unsigned int *value)
2319 {
2320 NC* ncp;
2321 int stat = NC_check_id(ncid, &ncp);
2322 if(stat != NC_NOERR) return stat;
2323 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_uint);
2324 }
2325
2326 int
nc_put_vars_longlong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const long long * value)2327 nc_put_vars_longlong(int ncid, int varid,
2328 const size_t *start, const size_t *edges,
2329 const ptrdiff_t * stride,
2330 const long long *value)
2331 {
2332 NC* ncp;
2333 int stat = NC_check_id(ncid, &ncp);
2334 if(stat != NC_NOERR) return stat;
2335 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_longlong);
2336 }
2337
2338 int
nc_put_vars_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const unsigned long long * value)2339 nc_put_vars_ulonglong(int ncid, int varid,
2340 const size_t *start, const size_t *edges,
2341 const ptrdiff_t * stride,
2342 const unsigned long long *value)
2343 {
2344 NC* ncp;
2345 int stat = NC_check_id(ncid, &ncp);
2346 if(stat != NC_NOERR) return stat;
2347 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_UINT64);
2348 }
2349
2350 #ifdef USE_NETCDF4
2351 int
nc_put_vars_string(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,const char ** value)2352 nc_put_vars_string(int ncid, int varid,
2353 const size_t *start, const size_t *edges,
2354 const ptrdiff_t * stride,
2355 const char* *value)
2356 {
2357 NC* ncp;
2358 int stat = NC_check_id(ncid, &ncp);
2359 if(stat != NC_NOERR) return stat;
2360 return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_STRING);
2361 }
2362
2363 #endif /*USE_NETCDF4*/
2364
2365 int
nc_get_vars_text(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,char * value)2366 nc_get_vars_text(int ncid, int varid,
2367 const size_t *start, const size_t *edges,
2368 const ptrdiff_t * stride,
2369 char *value)
2370 {
2371 NC* ncp;
2372 int stat = NC_check_id(ncid, &ncp);
2373 if(stat != NC_NOERR) return stat;
2374 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_CHAR);
2375 }
2376
2377 int
nc_get_vars_schar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,signed char * value)2378 nc_get_vars_schar(int ncid, int varid,
2379 const size_t *start, const size_t *edges,
2380 const ptrdiff_t * stride,
2381 signed char *value)
2382 {
2383 NC* ncp;
2384 int stat = NC_check_id(ncid, &ncp);
2385 if(stat != NC_NOERR) return stat;
2386 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_BYTE);
2387 }
2388
2389 int
nc_get_vars_uchar(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,unsigned char * value)2390 nc_get_vars_uchar(int ncid, int varid,
2391 const size_t *start, const size_t *edges,
2392 const ptrdiff_t * stride,
2393 unsigned char *value)
2394 {
2395 NC* ncp;
2396 int stat = NC_check_id(ncid, &ncp);
2397 if(stat != NC_NOERR) return stat;
2398 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_uchar);
2399 }
2400
2401 int
nc_get_vars_short(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,short * value)2402 nc_get_vars_short(int ncid, int varid,
2403 const size_t *start, const size_t *edges,
2404 const ptrdiff_t * stride,
2405 short *value)
2406 {
2407 NC* ncp;
2408 int stat = NC_check_id(ncid, &ncp);
2409 if(stat != NC_NOERR) return stat;
2410 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_SHORT);
2411 }
2412
2413 int
nc_get_vars_int(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,int * value)2414 nc_get_vars_int(int ncid, int varid,
2415 const size_t *start, const size_t *edges,
2416 const ptrdiff_t * stride,
2417 int *value)
2418 {
2419 NC* ncp;
2420 int stat = NC_check_id(ncid, &ncp);
2421 if(stat != NC_NOERR) return stat;
2422 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_INT);
2423 }
2424
2425 int
nc_get_vars_long(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,long * value)2426 nc_get_vars_long(int ncid, int varid,
2427 const size_t *start, const size_t *edges,
2428 const ptrdiff_t * stride,
2429 long *value)
2430 {
2431 NC* ncp;
2432 int stat = NC_check_id(ncid, &ncp);
2433 if(stat != NC_NOERR) return stat;
2434 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_long);
2435 }
2436
2437 int
nc_get_vars_float(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,float * value)2438 nc_get_vars_float(int ncid, int varid,
2439 const size_t *start, const size_t *edges,
2440 const ptrdiff_t * stride,
2441 float *value)
2442 {
2443 NC* ncp;
2444 int stat = NC_check_id(ncid, &ncp);
2445 if(stat != NC_NOERR) return stat;
2446 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_float);
2447 }
2448
2449 int
nc_get_vars_double(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,double * value)2450 nc_get_vars_double(int ncid, int varid,
2451 const size_t *start, const size_t *edges,
2452 const ptrdiff_t * stride,
2453 double *value)
2454 {
2455 NC* ncp;
2456 int stat = NC_check_id(ncid, &ncp);
2457 if(stat != NC_NOERR) return stat;
2458 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_double);
2459 }
2460
2461 int
nc_get_vars_ubyte(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,unsigned char * value)2462 nc_get_vars_ubyte(int ncid, int varid,
2463 const size_t *start, const size_t *edges,
2464 const ptrdiff_t * stride,
2465 unsigned char *value)
2466 {
2467 NC* ncp;
2468 int stat = NC_check_id(ncid, &ncp);
2469 if(stat != NC_NOERR) return stat;
2470 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_ubyte);
2471 }
2472
2473 int
nc_get_vars_ushort(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,unsigned short * value)2474 nc_get_vars_ushort(int ncid, int varid,
2475 const size_t *start, const size_t *edges,
2476 const ptrdiff_t * stride,
2477 unsigned short *value)
2478 {
2479 NC* ncp;
2480 int stat = NC_check_id(ncid, &ncp);
2481 if(stat != NC_NOERR) return stat;
2482 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_ushort);
2483 }
2484
2485 int
nc_get_vars_uint(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,unsigned int * value)2486 nc_get_vars_uint(int ncid, int varid,
2487 const size_t *start, const size_t *edges,
2488 const ptrdiff_t * stride,
2489 unsigned int *value)
2490 {
2491 NC* ncp;
2492 int stat = NC_check_id(ncid, &ncp);
2493 if(stat != NC_NOERR) return stat;
2494 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_uint);
2495 }
2496
2497 int
nc_get_vars_longlong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,long long * value)2498 nc_get_vars_longlong(int ncid, int varid,
2499 const size_t *start, const size_t *edges,
2500 const ptrdiff_t * stride,
2501 long long *value)
2502 {
2503 NC* ncp;
2504 int stat = NC_check_id(ncid, &ncp);
2505 if(stat != NC_NOERR) return stat;
2506 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_longlong);
2507 }
2508
2509 int
nc_get_vars_ulonglong(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,unsigned long long * value)2510 nc_get_vars_ulonglong(int ncid, int varid,
2511 const size_t *start, const size_t *edges,
2512 const ptrdiff_t * stride,
2513 unsigned long long *value)
2514 {
2515 NC* ncp;
2516 int stat = NC_check_id(ncid, &ncp);
2517 if(stat != NC_NOERR) return stat;
2518 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_UINT64);
2519 }
2520
2521 #ifdef USE_NETCDF4
2522 int
nc_get_vars_string(int ncid,int varid,const size_t * start,const size_t * edges,const ptrdiff_t * stride,char ** value)2523 nc_get_vars_string(int ncid, int varid,
2524 const size_t *start, const size_t *edges,
2525 const ptrdiff_t * stride,
2526 char* *value)
2527 {
2528 NC* ncp;
2529 int stat = NC_check_id(ncid, &ncp);
2530 if(stat != NC_NOERR) return stat;
2531 return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_STRING);
2532 }
2533
2534 #endif /*USE_NETCDF4*/
2535
2536
2537