netCDF  4.3.0
 All Data Structures Files Functions Variables Typedefs Macros Groups Pages
dvarput.c
1 
8 #include "ncdispatch.h"
9 
10 #undef VARS_USES_VARM
11 #ifndef VARS_USES_VARM
12 struct PUTodometer {
13  int rank;
14  size_t index[NC_MAX_VAR_DIMS];
15  size_t start[NC_MAX_VAR_DIMS];
16  size_t edges[NC_MAX_VAR_DIMS];
17  ptrdiff_t stride[NC_MAX_VAR_DIMS];
18  size_t stop[NC_MAX_VAR_DIMS];
19 };
20 
21 static void
22 odom_init(struct PUTodometer* odom,
23  size_t rank,
24  const size_t* start, const size_t* edges, const ptrdiff_t* stride)
25 {
26  int i;
27  memset(odom,0,sizeof(struct PUTodometer));
28  odom->rank = rank;
29  assert(odom->rank <= NC_MAX_VAR_DIMS);
30  for(i=0;i<odom->rank;i++) {
31  odom->start[i] = (start != NULL ? start[i] : 0);
32  odom->edges[i] = (edges != NULL ? edges[i] : 1);
33  odom->stride[i] = (stride != NULL ? stride[i] : 1);
34  odom->stop[i] = odom->start[i] + (odom->edges[i]*odom->stride[i]);
35  odom->index[i] = odom->start[i];
36  }
37 }
38 
39 static int
40 odom_more(struct PUTodometer* odom)
41 {
42  return (odom->index[0] < odom->stop[0]);
43 }
44 
45 static int
46 odom_next(struct PUTodometer* odom)
47 {
48  int i;
49  if(odom->rank == 0) return 0;
50  for(i=odom->rank-1;i>=0;i--) {
51  odom->index[i] += odom->stride[i];
52  if(odom->index[i] < odom->stop[i]) break;
53  if(i == 0) return 0; /* leave the 0th entry if it overflows*/
54  odom->index[i] = odom->start[i]; /* reset this position*/
55  }
56  return 1;
57 }
58 #endif
59 
63 static int
64 NC_put_vara(int ncid, int varid, const size_t *start,
65  const size_t *edges, const void *value, nc_type memtype)
66 {
67  NC* ncp;
68  int stat = NC_check_id(ncid, &ncp);
69  if(stat != NC_NOERR) return stat;
70  if(edges == NULL) {
71  size_t shape[NC_MAX_VAR_DIMS];
72  int ndims;
73  stat = nc_inq_varndims(ncid, varid, &ndims);
74  if(stat != NC_NOERR) return stat;
75  stat = NC_getshape(ncid, varid, ndims, shape);
76  if(stat != NC_NOERR) return stat;
77  return ncp->dispatch->put_vara(ncid, varid, start, shape, value, memtype);
78  } else
79  return ncp->dispatch->put_vara(ncid, varid, start, edges, value, memtype);
80 }
81 
85 static int
86 NC_put_var(int ncid, int varid, const void *value, nc_type memtype)
87 {
88  int ndims;
89  size_t shape[NC_MAX_VAR_DIMS];
90  int stat = nc_inq_varndims(ncid,varid, &ndims);
91  if(stat) return stat;
92  stat = NC_getshape(ncid,varid, ndims, shape);
93  if(stat) return stat;
94  return NC_put_vara(ncid, varid, NC_coord_zero, shape, value, memtype);
95 }
96 
100 static int
101 NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
102  nc_type memtype)
103 {
104  return NC_put_vara(ncid, varid, coord, NC_coord_one, value, memtype);
105 }
106 
110 int
111 NCDEFAULT_put_vars(int ncid, int varid, const size_t * start,
112  const size_t * edges, const ptrdiff_t * stride,
113  const void *value0, nc_type memtype)
114 {
115 #ifdef VARS_USES_VARM
116  NC* ncp;
117  int stat = NC_check_id(ncid, &ncp);
118 
119  if(stat != NC_NOERR) return stat;
120  return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
121 #else
122  /* Rebuilt put_vars code to simplify and avoid use of put_varm */
123 
124  int status = NC_NOERR;
125  int i,simplestride,rank,isrecvar;
126  struct PUTodometer odom;
127  nc_type vartype = NC_NAT;
128  NC* ncp;
129  size_t vartypelen, memtypelen;
130  const char* value = (const char*)value0;
131  size_t numrecs;
132  size_t varshape[NC_MAX_VAR_DIMS];
133  size_t mystart[NC_MAX_VAR_DIMS];
134  size_t myedges[NC_MAX_VAR_DIMS];
135  ptrdiff_t mystride[NC_MAX_VAR_DIMS];
136 
137  const char* memptr = value;
138 
139  status = NC_check_id (ncid, &ncp);
140  if(status != NC_NOERR) return status;
141 
142  status = nc_inq_vartype(ncid, varid, &vartype);
143  if(status != NC_NOERR) return status;
144 
145  if(memtype == NC_NAT) memtype = vartype;
146 
147  /* compute the variable type size */
148  status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
149  if(status != NC_NOERR) return status;
150 
151  if(memtype > NC_MAX_ATOMIC_TYPE)
152  memtypelen = vartypelen;
153  else
154  memtypelen = nctypelen(memtype);
155 
156  /* Check gross internal/external type compatibility */
157  if(vartype != memtype) {
158  /* If !atomic, the two types must be the same */
159  if(vartype > NC_MAX_ATOMIC_TYPE
160  || memtype > NC_MAX_ATOMIC_TYPE)
161  return NC_EBADTYPE;
162  /* ok, the types differ but both are atomic */
163  if(memtype == NC_CHAR || vartype == NC_CHAR)
164  return NC_ECHAR;
165  }
166 
167  /* Get the variable rank */
168  status = nc_inq_varndims(ncid, varid, &rank);
169  if(status != NC_NOERR) return status;
170 
171  /* Get variable dimension sizes */
172  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
173  NC_getshape(ncid,varid,rank,varshape);
174 
175  /* Optimize out using various checks */
176  if (rank == 0) {
177  /*
178  * The variable is a scalar; consequently,
179  * there is only one thing to get and only one place to put it.
180  * (Why was I called?)
181  */
182  size_t edge1[1] = {1};
183  return NC_put_vara(ncid, varid, start, edge1, value0, memtype);
184  }
185 
186  /* Do various checks and fixups on start/edges/stride */
187  simplestride = 1; /* assume so */
188  for(i=0;i<rank;i++) {
189  size_t dimlen;
190  mystart[i] = (start == NULL ? 0 : start[i]);
191  if(edges == NULL) {
192  if(i == 0 && isrecvar)
193  myedges[i] = numrecs - start[i];
194  else
195  myedges[i] = varshape[i] - mystart[i];
196  } else
197  myedges[i] = edges[i];
198  if(myedges[i] == 0)
199  return NC_NOERR; /* cannot write anything */
200  mystride[i] = (stride == NULL ? 1 : stride[i]);
201  if(mystride[i] <= 0
202  /* cast needed for braindead systems with signed size_t */
203  || ((unsigned long) mystride[i] >= X_INT_MAX))
204  return NC_ESTRIDE;
205  if(mystride[i] != 1) simplestride = 0;
206  /* illegal value checks */
207  dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
208  if(i == 0 && isrecvar) {/*do nothing*/}
209  else {
210  if(mystart[i] < 0 || mystart[i] > dimlen)
211  return NC_EINVALCOORDS;
212  if(myedges[i] < 0 || (mystart[i] + myedges[i] > dimlen))
213  return NC_EEDGE;
214  }
215  }
216  if(simplestride) {
217  return NC_put_vara(ncid, varid, mystart, myedges, value, memtype);
218  }
219 
220  /* Initial version uses and odometer to walk the variable
221  and read each value one at a time. This can later be optimized
222  to read larger chunks at a time.
223  */
224 
225 
226  odom_init(&odom,rank,mystart,myedges,mystride);
227 
228  /* walk the odometer to extract values */
229  while(odom_more(&odom)) {
230  int localstatus = NC_NOERR;
231  /* Write a single value */
232  localstatus = NC_put_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
233  /* So it turns out that when get_varm is used, all errors are
234  delayed and ERANGE will be overwritten by more serious errors.
235  */
236  if(localstatus != NC_NOERR) {
237  if(status == NC_NOERR || localstatus != NC_ERANGE)
238  status = localstatus;
239  }
240  memptr += memtypelen;
241  odom_next(&odom);
242  }
243  return status;
244 #endif
245 }
246 
250 int
251 NCDEFAULT_put_varm(
252  int ncid,
253  int varid,
254  const size_t * start,
255  const size_t * edges,
256  const ptrdiff_t * stride,
257  const ptrdiff_t * imapp,
258  const void *value0,
259  nc_type memtype)
260 {
261  int status = NC_NOERR;
262  nc_type vartype = NC_NAT;
263  int varndims = 0;
264  int maxidim = 0;
265  NC* ncp;
266  size_t memtypelen;
267  ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
268  const char* value = (char*)value0;
269 
270  status = NC_check_id (ncid, &ncp);
271  if(status != NC_NOERR) return status;
272 
273 /*
274  if(NC_indef(ncp)) return NC_EINDEFINE;
275  if(NC_readonly (ncp)) return NC_EPERM;
276 */
277 
278  /* mid body */
279  status = nc_inq_vartype(ncid, varid, &vartype);
280  if(status != NC_NOERR) return status;
281  /* Check that this is an atomic type */
282  if(vartype > NC_MAX_ATOMIC_TYPE)
283  return NC_EMAPTYPE;
284 
285  status = nc_inq_varndims(ncid, varid, &varndims);
286  if(status != NC_NOERR) return status;
287 
288  if(memtype == NC_NAT) {
289  if(imapp != NULL && varndims != 0) {
290  /*
291  * convert map units from bytes to units of sizeof(type)
292  */
293  size_t ii;
294  const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
295  for(ii = 0; ii < varndims; ii++) {
296  if(imapp[ii] % szof != 0) {
297  /*free(cvtmap);*/
298  return NC_EINVAL;
299  }
300  cvtmap[ii] = imapp[ii] / szof;
301  }
302  imapp = cvtmap;
303  }
304  memtype = vartype;
305  }
306 
307  if(memtype == NC_CHAR && vartype != NC_CHAR)
308  return NC_ECHAR;
309  else if(memtype != NC_CHAR && vartype == NC_CHAR)
310  return NC_ECHAR;
311 
312  memtypelen = nctypelen(memtype);
313 
314  maxidim = (int) varndims - 1;
315 
316  if (maxidim < 0)
317  {
318  /*
319  * The variable is a scalar; consequently,
320  * there s only one thing to get and only one place to put it.
321  * (Why was I called?)
322  */
323  size_t edge1[1] = {1};
324  return NC_put_vara(ncid, varid, start, edge1, value, memtype);
325  }
326 
327  /*
328  * else
329  * The variable is an array.
330  */
331  {
332  int idim;
333  size_t *mystart = NULL;
334  size_t *myedges;
335  size_t *iocount; /* count vector */
336  size_t *stop; /* stop indexes */
337  size_t *length; /* edge lengths in bytes */
338  ptrdiff_t *mystride;
339  ptrdiff_t *mymap;
340  size_t varshape[NC_MAX_VAR_DIMS];
341  int isrecvar;
342  size_t numrecs;
343  int stride1; /* is stride all ones? */
344 
345  /*
346  * Verify stride argument.
347  */
348  stride1 = 1; /* assume ok; */
349  if(stride != NULL) {
350  for (idim = 0; idim <= maxidim; ++idim) {
351  if ((stride[idim] == 0)
352  /* cast needed for braindead systems with signed size_t */
353  || ((unsigned long) stride[idim] >= X_INT_MAX))
354  {
355  return NC_ESTRIDE;
356  }
357  if(stride[idim] != 1) stride1 = 0;
358  }
359  }
360 
361  /* If stride1 is true, and there is no imap, then call get_vara
362  directly
363  */
364  if(stride1 && imapp == NULL) {
365  return NC_put_vara(ncid, varid, start, edges, value, memtype);
366  }
367 
368  /* Compute some dimension related values */
369  isrecvar = NC_is_recvar(ncid,varid,&numrecs);
370  NC_getshape(ncid,varid,varndims,varshape);
371 
372  /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
373  mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t));
374  if(mystart == NULL) return NC_ENOMEM;
375  myedges = mystart + varndims;
376  iocount = myedges + varndims;
377  stop = iocount + varndims;
378  length = stop + varndims;
379  mystride = (ptrdiff_t *)(length + varndims);
380  mymap = mystride + varndims;
381 
382  /*
383  * Initialize I/O parameters.
384  */
385  for (idim = maxidim; idim >= 0; --idim)
386  {
387  mystart[idim] = start != NULL
388  ? start[idim]
389  : 0;
390 
391  if (edges != NULL && edges[idim] == 0)
392  {
393  status = NC_NOERR; /* read/write no data */
394  goto done;
395  }
396 
397  myedges[idim] = edges != NULL
398  ? edges[idim]
399  : idim == 0 && isrecvar
400  ? numrecs - mystart[idim]
401  : varshape[idim] - mystart[idim];
402  mystride[idim] = stride != NULL
403  ? stride[idim]
404  : 1;
405  mymap[idim] = imapp != NULL
406  ? imapp[idim]
407  : idim == maxidim
408  ? 1
409  : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
410 
411  iocount[idim] = 1;
412  length[idim] = mymap[idim] * myedges[idim];
413  stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
414  }
415 
416  /*
417  * Check start, edges
418  */
419  for (idim = isrecvar; idim < maxidim; ++idim)
420  {
421  if (mystart[idim] > varshape[idim])
422  {
423  status = NC_EINVALCOORDS;
424  goto done;
425  }
426  if (mystart[idim] + myedges[idim] > varshape[idim])
427  {
428  status = NC_EEDGE;
429  goto done;
430  }
431  }
432 
433  /* Lower body */
434  /*
435  * As an optimization, adjust I/O parameters when the fastest
436  * dimension has unity stride both externally and internally.
437  * In this case, the user could have called a simpler routine
438  * (i.e. ncvar$1()
439  */
440  if (mystride[maxidim] == 1
441  && mymap[maxidim] == 1)
442  {
443  iocount[maxidim] = myedges[maxidim];
444  mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
445  mymap[maxidim] = (ptrdiff_t) length[maxidim];
446  }
447 
448  /*
449  * Perform I/O. Exit when done.
450  */
451  for (;;)
452  {
453  /* TODO: */
454  int lstatus = NC_put_vara(ncid, varid, mystart, iocount,
455  value, memtype);
456  if (lstatus != NC_NOERR) {
457  if(status == NC_NOERR || lstatus != NC_ERANGE)
458  status = lstatus;
459  }
460 
461  /*
462  * The following code permutes through the variable s
463  * external start-index space and it s internal address
464  * space. At the UPC, this algorithm is commonly
465  * called "odometer code".
466  */
467  idim = maxidim;
468  carry:
469  value += (mymap[idim] * memtypelen);
470  mystart[idim] += mystride[idim];
471  if (mystart[idim] == stop[idim])
472  {
473  mystart[idim] = start[idim];
474  value -= (length[idim] * memtypelen);
475  if (--idim < 0)
476  break; /* normal return */
477  goto carry;
478  }
479  } /* I/O loop */
480  done:
481  free(mystart);
482  } /* variable is array */
483  return status;
484 }
485 
489 static int
490 NC_put_vars(int ncid, int varid, const size_t *start,
491  const size_t *edges, const ptrdiff_t *stride,
492  const void *value, nc_type memtype)
493 {
494  NC* ncp;
495  int stat = NC_check_id(ncid, &ncp);
496 
497  if(stat != NC_NOERR) return stat;
498 #ifdef USE_NETCDF4
499  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
500 #endif
501  return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
502 }
503 
507 static int
508 NC_put_varm(int ncid, int varid, const size_t *start,
509  const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map,
510  const void *value, nc_type memtype)
511 {
512  NC* ncp;
513  int stat = NC_check_id(ncid, &ncp);
514 
515  if(stat != NC_NOERR) return stat;
516 #ifdef USE_NETCDF4
517  if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
518 #endif
519  return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
520 }
521  /* All these functions are part of this named group... */
526 
567 int
568 nc_put_vara(int ncid, int varid, const size_t *startp,
569  const size_t *countp, const void *op)
570 {
571  NC* ncp;
572  int stat = NC_check_id(ncid, &ncp);
573  nc_type xtype;
574  if(stat != NC_NOERR) return stat;
575  stat = nc_inq_vartype(ncid, varid, &xtype);
576  if(stat != NC_NOERR) return stat;
577  return NC_put_vara(ncid, varid, startp, countp, op, xtype);
578 }
579 
580 int
581 nc_put_vara_text(int ncid, int varid, const size_t *startp,
582  const size_t *countp, const char *op)
583 {
584  return NC_put_vara(ncid, varid, startp, countp,
585  (void*)op, NC_CHAR);
586 }
587 
588 int
589 nc_put_vara_schar(int ncid, int varid, const size_t *startp,
590  const size_t *countp, const signed char *op)
591 {
592  NC* ncp;
593  int stat = NC_check_id(ncid, &ncp);
594  if(stat != NC_NOERR) return stat;
595  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
596  NC_BYTE);
597 }
598 
599 int
600 nc_put_vara_uchar(int ncid, int varid, const size_t *startp,
601  const size_t *countp, const unsigned char *op)
602 {
603  NC* ncp;
604  int stat = NC_check_id(ncid, &ncp);
605  if(stat != NC_NOERR) return stat;
606  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
607  T_uchar);
608 }
609 
610 int
611 nc_put_vara_short(int ncid, int varid, const size_t *startp,
612  const size_t *countp, const short *op)
613 {
614  NC* ncp;
615  int stat = NC_check_id(ncid, &ncp);
616  if(stat != NC_NOERR) return stat;
617  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
618  NC_SHORT);
619 }
620 
621 int
622 nc_put_vara_int(int ncid, int varid, const size_t *startp,
623  const size_t *countp, const int *op)
624 {
625  NC* ncp;
626  int stat = NC_check_id(ncid, &ncp);
627  if(stat != NC_NOERR) return stat;
628  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
629  NC_INT);
630 }
631 
632 int
633 nc_put_vara_long(int ncid, int varid, const size_t *startp,
634  const size_t *countp, const long *op)
635 {
636  NC* ncp;
637  int stat = NC_check_id(ncid, &ncp);
638  if(stat != NC_NOERR) return stat;
639  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
640  T_long);
641 }
642 
643 int
644 nc_put_vara_float(int ncid, int varid, const size_t *startp,
645  const size_t *countp, const float *op)
646 {
647  NC* ncp;
648  int stat = NC_check_id(ncid, &ncp);
649  if(stat != NC_NOERR) return stat;
650  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
651  T_float);
652 }
653 
654 int
655 nc_put_vara_double(int ncid, int varid, const size_t *startp,
656  const size_t *countp, const double *op)
657 {
658  NC* ncp;
659  int stat = NC_check_id(ncid, &ncp);
660  if(stat != NC_NOERR) return stat;
661  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
662  T_double);
663 }
664 
665 int
666 nc_put_vara_ubyte(int ncid, int varid, const size_t *startp,
667  const size_t *countp, const unsigned char *op)
668 {
669  NC* ncp;
670  int stat = NC_check_id(ncid, &ncp);
671  if(stat != NC_NOERR) return stat;
672  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
673  T_ubyte);
674 }
675 
676 int
677 nc_put_vara_ushort(int ncid, int varid, const size_t *startp,
678  const size_t *countp, const unsigned short *op)
679 {
680  NC* ncp;
681  int stat = NC_check_id(ncid, &ncp);
682  if(stat != NC_NOERR) return stat;
683  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
684  T_ushort);
685 }
686 
687 int
688 nc_put_vara_uint(int ncid, int varid, const size_t *startp,
689  const size_t *countp, const unsigned int *op)
690 {
691  NC* ncp;
692  int stat = NC_check_id(ncid, &ncp);
693  if(stat != NC_NOERR) return stat;
694  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
695  T_uint);
696 }
697 
698 int
699 nc_put_vara_longlong(int ncid, int varid, const size_t *startp,
700  const size_t *countp, const long long *op)
701 {
702  NC* ncp;
703  int stat = NC_check_id(ncid, &ncp);
704  if(stat != NC_NOERR) return stat;
705  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
706  T_longlong);
707 }
708 
709 int
710 nc_put_vara_ulonglong(int ncid, int varid, const size_t *startp,
711  const size_t *countp, const unsigned long long *op)
712 {
713  NC* ncp;
714  int stat = NC_check_id(ncid, &ncp);
715  if(stat != NC_NOERR) return stat;
716  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
717  NC_UINT64);
718 }
719 
720 #ifdef USE_NETCDF4
721 int
722 nc_put_vara_string(int ncid, int varid, const size_t *startp,
723  const size_t *countp, const char* *op)
724 {
725  NC* ncp;
726  int stat = NC_check_id(ncid, &ncp);
727  if(stat != NC_NOERR) return stat;
728  return NC_put_vara(ncid, varid, startp, countp, (void *)op,
729  NC_STRING);
730 }
731 
732 #endif /*USE_NETCDF4*/
733 
757 int
758 nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
759 {
760  return NC_put_var1(ncid, varid, indexp, op, NC_NAT);
761 }
762 
763 int
764 nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
765 {
766  NC* ncp;
767  int stat = NC_check_id(ncid, &ncp);
768  if(stat != NC_NOERR) return stat;
769  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_CHAR);
770 }
771 
772 int
773 nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
774 {
775  NC* ncp;
776  int stat = NC_check_id(ncid, &ncp);
777  if(stat != NC_NOERR) return stat;
778  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_BYTE);
779 }
780 
781 int
782 nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
783 {
784  NC* ncp;
785  int stat = NC_check_id(ncid, &ncp);
786  if(stat != NC_NOERR) return stat;
787  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
788 }
789 
790 int
791 nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
792 {
793  NC* ncp;
794  int stat = NC_check_id(ncid, &ncp);
795  if(stat != NC_NOERR) return stat;
796  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_SHORT);
797 }
798 
799 int
800 nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
801 {
802  NC* ncp;
803  int stat = NC_check_id(ncid, &ncp);
804  if(stat != NC_NOERR) return stat;
805  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT);
806 }
807 
808 int
809 nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
810 {
811  NC* ncp;
812  int stat = NC_check_id(ncid, &ncp);
813  if(stat != NC_NOERR) return stat;
814  return NC_put_var1(ncid, varid, indexp, (void*)op, longtype);
815 }
816 
817 int
818 nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
819 {
820  NC* ncp;
821  int stat = NC_check_id(ncid, &ncp);
822  if(stat != NC_NOERR) return stat;
823  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_FLOAT);
824 }
825 
826 int
827 nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
828 {
829  NC* ncp;
830  int stat = NC_check_id(ncid, &ncp);
831  if(stat != NC_NOERR) return stat;
832  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_DOUBLE);
833 }
834 
835 int
836 nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
837 {
838  NC* ncp;
839  int stat = NC_check_id(ncid, &ncp);
840  if(stat != NC_NOERR) return stat;
841  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE);
842 }
843 
844 int
845 nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
846 {
847  NC* ncp;
848  int stat = NC_check_id(ncid, &ncp);
849  if(stat != NC_NOERR) return stat;
850  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_USHORT);
851 }
852 
853 int
854 nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
855 {
856  NC* ncp;
857  int stat = NC_check_id(ncid, &ncp);
858  if(stat != NC_NOERR) return stat;
859  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT);
860 }
861 
862 int
863 nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
864 {
865  NC* ncp;
866  int stat = NC_check_id(ncid, &ncp);
867  if(stat != NC_NOERR) return stat;
868  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT64);
869 }
870 
871 int
872 nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
873 {
874  NC* ncp;
875  int stat = NC_check_id(ncid, &ncp);
876  if(stat != NC_NOERR) return stat;
877  return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT64);
878 }
879 
880 #ifdef USE_NETCDF4
881 int
882 nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char* *op)
883 {
884  NC* ncp;
885  int stat = NC_check_id(ncid, &ncp);
886  if(stat != NC_NOERR) return stat;
887  return NC_put_var1(ncid, varid, indexp, (void*)op, NC_STRING);
888 }
889 #endif /*USE_NETCDF4*/
890 
938 int
939 nc_put_var(int ncid, int varid, const void *op)
940 {
941  return NC_put_var(ncid, varid, op, NC_NAT);
942 }
943 
944 int
945 nc_put_var_text(int ncid, int varid, const char *op)
946 {
947  NC* ncp;
948  int stat = NC_check_id(ncid, &ncp);
949  if(stat != NC_NOERR) return stat;
950  return NC_put_var(ncid,varid,(void*)op,NC_CHAR);
951 }
952 
953 int
954 nc_put_var_schar(int ncid, int varid, const signed char *op)
955 {
956  NC* ncp;
957  int stat = NC_check_id(ncid, &ncp);
958  if(stat != NC_NOERR) return stat;
959  return NC_put_var(ncid,varid,(void*)op,NC_BYTE);
960 }
961 
962 int
963 nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
964 {
965  NC* ncp;
966  int stat = NC_check_id(ncid, &ncp);
967  if(stat != NC_NOERR) return stat;
968  return NC_put_var(ncid,varid,(void*)op,T_uchar);
969 }
970 
971 int
972 nc_put_var_short(int ncid, int varid, const short *op)
973 {
974  NC* ncp;
975  int stat = NC_check_id(ncid, &ncp);
976  if(stat != NC_NOERR) return stat;
977  return NC_put_var(ncid,varid,(void*)op,NC_SHORT);
978 }
979 
980 int
981 nc_put_var_int(int ncid, int varid, const int *op)
982 {
983  NC* ncp;
984  int stat = NC_check_id(ncid, &ncp);
985  if(stat != NC_NOERR) return stat;
986  return NC_put_var(ncid,varid,(void*)op,NC_INT);
987 }
988 
989 int
990 nc_put_var_long(int ncid, int varid, const long *op)
991 {
992  NC* ncp;
993  int stat = NC_check_id(ncid, &ncp);
994  if(stat != NC_NOERR) return stat;
995  return NC_put_var(ncid,varid,(void*)op,T_long);
996 }
997 
998 int
999 nc_put_var_float(int ncid, int varid, const float *op)
1000 {
1001  NC* ncp;
1002  int stat = NC_check_id(ncid, &ncp);
1003  if(stat != NC_NOERR) return stat;
1004  return NC_put_var(ncid,varid,(void*)op,T_float);
1005 }
1006 
1007 int
1008 nc_put_var_double(int ncid, int varid, const double *op)
1009 {
1010  NC* ncp;
1011  int stat = NC_check_id(ncid, &ncp);
1012  if(stat != NC_NOERR) return stat;
1013  return NC_put_var(ncid,varid,(void*)op,T_double);
1014 }
1015 
1016 int
1017 nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
1018 {
1019  NC* ncp;
1020  int stat = NC_check_id(ncid, &ncp);
1021  if(stat != NC_NOERR) return stat;
1022  return NC_put_var(ncid,varid,(void*)op,T_ubyte);
1023 }
1024 
1025 int
1026 nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
1027 {
1028  NC* ncp;
1029  int stat = NC_check_id(ncid, &ncp);
1030  if(stat != NC_NOERR) return stat;
1031  return NC_put_var(ncid,varid,(void*)op,T_ushort);
1032 }
1033 
1034 int
1035 nc_put_var_uint(int ncid, int varid, const unsigned int *op)
1036 {
1037  NC* ncp;
1038  int stat = NC_check_id(ncid, &ncp);
1039  if(stat != NC_NOERR) return stat;
1040  return NC_put_var(ncid,varid,(void*)op,T_uint);
1041 }
1042 
1043 int
1044 nc_put_var_longlong(int ncid, int varid, const long long *op)
1045 {
1046  NC* ncp;
1047  int stat = NC_check_id(ncid, &ncp);
1048  if(stat != NC_NOERR) return stat;
1049  return NC_put_var(ncid,varid,(void*)op,T_longlong);
1050 }
1051 
1052 int
1053 nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
1054 {
1055  NC* ncp;
1056  int stat = NC_check_id(ncid, &ncp);
1057  if(stat != NC_NOERR) return stat;
1058  return NC_put_var(ncid,varid,(void*)op,NC_UINT64);
1059 }
1060 
1061 #ifdef USE_NETCDF4
1062 int
1063 nc_put_var_string(int ncid, int varid, const char* *op)
1064 {
1065  NC* ncp;
1066  int stat = NC_check_id(ncid, &ncp);
1067  if(stat != NC_NOERR) return stat;
1068  return NC_put_var(ncid,varid,(void*)op,NC_STRING);
1069 }
1070 #endif /*USE_NETCDF4*/
1071 
1103 int
1104 nc_put_vars (int ncid, int varid, const size_t *startp,
1105  const size_t *countp, const ptrdiff_t *stridep,
1106  const void *op)
1107 {
1108  NC *ncp;
1109  int stat = NC_NOERR;
1110 
1111  if ((stat = NC_check_id(ncid, &ncp)))
1112  return stat;
1113  return ncp->dispatch->put_vars(ncid, varid, startp, countp,
1114  stridep, op, NC_NAT);
1115 }
1116 
1117 int
1118 nc_put_vars_text(int ncid, int varid, const size_t *startp,
1119  const size_t *countp, const ptrdiff_t *stridep,
1120  const char *op)
1121 {
1122  NC *ncp;
1123  int stat = NC_check_id(ncid, &ncp);
1124  if(stat != NC_NOERR) return stat;
1125  return NC_put_vars(ncid, varid, startp, countp,
1126  stridep,(void*)op,NC_CHAR);
1127 }
1128 
1129 int
1130 nc_put_vars_schar(int ncid, int varid, const size_t *startp,
1131  const size_t *countp, const ptrdiff_t *stridep,
1132  const signed char *op)
1133 {
1134  NC *ncp;
1135  int stat = NC_check_id(ncid, &ncp);
1136  if(stat != NC_NOERR) return stat;
1137  return NC_put_vars(ncid, varid, startp, countp,
1138  stridep,(void*)op,NC_BYTE);
1139 }
1140 
1141 int
1142 nc_put_vars_uchar(int ncid, int varid,
1143  const size_t *startp, const size_t *countp,
1144  const ptrdiff_t *stridep,
1145  const unsigned char *op)
1146 {
1147  NC *ncp;
1148  int stat = NC_check_id(ncid, &ncp);
1149  if(stat != NC_NOERR) return stat;
1150  return NC_put_vars(ncid, varid, startp, countp,
1151  stridep, (void *)op, T_uchar);
1152 }
1153 
1154 int
1155 nc_put_vars_short(int ncid, int varid,
1156  const size_t *startp, const size_t *countp,
1157  const ptrdiff_t *stridep,
1158  const short *op)
1159 {
1160  NC *ncp;
1161  int stat = NC_check_id(ncid, &ncp);
1162  if(stat != NC_NOERR) return stat;
1163  return NC_put_vars(ncid, varid, startp, countp,
1164  stridep, (void *)op, NC_SHORT);
1165 }
1166 
1167 int
1168 nc_put_vars_int(int ncid, int varid,
1169  const size_t *startp, const size_t *countp,
1170  const ptrdiff_t *stridep,
1171  const int *op)
1172 {
1173  NC *ncp;
1174  int stat = NC_check_id(ncid, &ncp);
1175  if(stat != NC_NOERR) return stat;
1176  return NC_put_vars(ncid, varid, startp, countp,
1177  stridep, (void *)op, NC_INT);
1178 }
1179 
1180 int
1181 nc_put_vars_long(int ncid, int varid,
1182  const size_t *startp, const size_t *countp,
1183  const ptrdiff_t *stridep,
1184  const long *op)
1185 {
1186  NC *ncp;
1187  int stat = NC_check_id(ncid, &ncp);
1188  if(stat != NC_NOERR) return stat;
1189  return NC_put_vars(ncid, varid, startp, countp,
1190  stridep, (void *)op, T_long);
1191 }
1192 
1193 int
1194 nc_put_vars_float(int ncid, int varid,
1195  const size_t *startp, const size_t *countp,
1196  const ptrdiff_t *stridep,
1197  const float *op)
1198 {
1199  NC *ncp;
1200  int stat = NC_check_id(ncid, &ncp);
1201  if(stat != NC_NOERR) return stat;
1202  return NC_put_vars(ncid, varid, startp, countp,
1203  stridep, (void *)op, T_float);
1204 }
1205 
1206 int
1207 nc_put_vars_double(int ncid, int varid,
1208  const size_t *startp, const size_t *countp,
1209  const ptrdiff_t *stridep,
1210  const double *op)
1211 {
1212  NC *ncp;
1213  int stat = NC_check_id(ncid, &ncp);
1214  if(stat != NC_NOERR) return stat;
1215  return NC_put_vars(ncid, varid, startp, countp,
1216  stridep, (void *)op, T_double);
1217 }
1218 
1219 int
1220 nc_put_vars_ubyte(int ncid, int varid,
1221  const size_t *startp, const size_t *countp,
1222  const ptrdiff_t *stridep,
1223  const unsigned char *op)
1224 {
1225  NC *ncp;
1226  int stat = NC_check_id(ncid, &ncp);
1227  if(stat != NC_NOERR) return stat;
1228  return NC_put_vars(ncid, varid, startp, countp,
1229  stridep, (void *)op, T_ubyte);
1230 }
1231 
1232 int
1233 nc_put_vars_ushort(int ncid, int varid,
1234  const size_t *startp, const size_t *countp,
1235  const ptrdiff_t *stridep,
1236  const unsigned short *op)
1237 {
1238  NC *ncp;
1239  int stat = NC_check_id(ncid, &ncp);
1240  if(stat != NC_NOERR) return stat;
1241  return NC_put_vars(ncid, varid, startp, countp,
1242  stridep, (void *)op, T_ushort);
1243 }
1244 
1245 int
1246 nc_put_vars_uint(int ncid, int varid,
1247  const size_t *startp, const size_t *countp,
1248  const ptrdiff_t *stridep,
1249  const unsigned int *op)
1250 {
1251  NC *ncp;
1252  int stat = NC_check_id(ncid, &ncp);
1253  if(stat != NC_NOERR) return stat;
1254  return NC_put_vars(ncid, varid, startp, countp,
1255  stridep, (void *)op, T_uint);
1256 }
1257 
1258 int
1259 nc_put_vars_longlong(int ncid, int varid,
1260  const size_t *startp, const size_t *countp,
1261  const ptrdiff_t *stridep,
1262  const long long *op)
1263 {
1264  NC *ncp;
1265  int stat = NC_check_id(ncid, &ncp);
1266  if(stat != NC_NOERR) return stat;
1267  return NC_put_vars(ncid, varid, startp, countp,
1268  stridep, (void *)op, T_longlong);
1269 }
1270 
1271 int
1272 nc_put_vars_ulonglong(int ncid, int varid,
1273  const size_t *startp, const size_t *countp,
1274  const ptrdiff_t *stridep,
1275  const unsigned long long *op)
1276 {
1277  NC *ncp;
1278  int stat = NC_check_id(ncid, &ncp);
1279  if(stat != NC_NOERR) return stat;
1280  return NC_put_vars(ncid, varid, startp, countp,
1281  stridep, (void *)op, NC_UINT64);
1282 }
1283 
1284 #ifdef USE_NETCDF4
1285 int
1286 nc_put_vars_string(int ncid, int varid,
1287  const size_t *startp, const size_t *countp,
1288  const ptrdiff_t *stridep,
1289  const char**op)
1290 {
1291  NC *ncp;
1292  int stat = NC_check_id(ncid, &ncp);
1293  if(stat != NC_NOERR) return stat;
1294  return NC_put_vars(ncid, varid, startp, countp, stridep,
1295  (void *)op, NC_STRING);
1296 }
1297 #endif /*USE_NETCDF4*/
1298 
1342 int
1343 nc_put_varm (int ncid, int varid, const size_t *startp,
1344  const size_t *countp, const ptrdiff_t *stridep,
1345  const ptrdiff_t *imapp, const void *op)
1346 {
1347  NC *ncp;
1348  int stat = NC_NOERR;
1349 
1350  if ((stat = NC_check_id(ncid, &ncp)))
1351  return stat;
1352  return ncp->dispatch->put_varm(ncid, varid, startp, countp,
1353  stridep, imapp, op, NC_NAT);
1354 }
1355 
1356 int
1357 nc_put_varm_text(int ncid, int varid, const size_t *startp,
1358  const size_t *countp, const ptrdiff_t *stridep,
1359  const ptrdiff_t *imapp, const char *op)
1360 {
1361  NC *ncp;
1362  int stat = NC_check_id(ncid, &ncp);
1363  if(stat != NC_NOERR) return stat;
1364  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1365  (void *)op, NC_CHAR);
1366 }
1367 
1368 int
1369 nc_put_varm_schar(int ncid, int varid,
1370  const size_t *startp, const size_t *countp,
1371  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1372  const signed char *op)
1373 {
1374  NC *ncp;
1375  int stat = NC_check_id(ncid, &ncp);
1376  if(stat != NC_NOERR) return stat;
1377  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1378  (void *)op, NC_BYTE);
1379 }
1380 
1381 int
1382 nc_put_varm_uchar(int ncid, int varid,
1383  const size_t *startp, const size_t *countp,
1384  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1385  const unsigned char *op)
1386 {
1387  NC *ncp;
1388  int stat = NC_check_id(ncid, &ncp);
1389  if(stat != NC_NOERR) return stat;
1390  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1391  (void *)op, T_uchar);
1392 }
1393 
1394 int
1395 nc_put_varm_short(int ncid, int varid,
1396  const size_t *startp, const size_t *countp,
1397  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1398  const short *op)
1399 {
1400  NC *ncp;
1401  int stat = NC_check_id(ncid, &ncp);
1402  if(stat != NC_NOERR) return stat;
1403  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1404  (void *)op, NC_SHORT);
1405 }
1406 
1407 int
1408 nc_put_varm_int(int ncid, int varid,
1409  const size_t *startp, const size_t *countp,
1410  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1411  const int *op)
1412 {
1413  NC *ncp;
1414  int stat = NC_check_id(ncid, &ncp);
1415  if(stat != NC_NOERR) return stat;
1416  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1417  (void *)op, NC_INT);
1418 }
1419 
1420 int
1421 nc_put_varm_long(int ncid, int varid,
1422  const size_t *startp, const size_t *countp,
1423  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1424  const long *op)
1425 {
1426  NC *ncp;
1427  int stat = NC_check_id(ncid, &ncp);
1428  if(stat != NC_NOERR) return stat;
1429  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1430  (void *)op, T_long);
1431 }
1432 
1433 int
1434 nc_put_varm_float(int ncid, int varid,
1435  const size_t *startp, const size_t *countp,
1436  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1437  const float *op)
1438 {
1439  NC *ncp;
1440  int stat = NC_check_id(ncid, &ncp);
1441  if(stat != NC_NOERR) return stat;
1442  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1443  (void *)op, T_float);
1444 }
1445 
1446 int
1447 nc_put_varm_double(int ncid, int varid,
1448  const size_t *startp, const size_t *countp,
1449  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1450  const double *op)
1451 {
1452  NC *ncp;
1453  int stat = NC_check_id(ncid, &ncp);
1454  if(stat != NC_NOERR) return stat;
1455  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1456  (void *)op, T_double);
1457 }
1458 
1459 int
1460 nc_put_varm_ubyte(int ncid, int varid,
1461  const size_t *startp, const size_t *countp,
1462  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1463  const unsigned char *op)
1464 {
1465  NC *ncp;
1466  int stat = NC_check_id(ncid, &ncp);
1467  if(stat != NC_NOERR) return stat;
1468  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1469  (void *)op, T_ubyte);
1470 }
1471 
1472 int
1473 nc_put_varm_ushort(int ncid, int varid,
1474  const size_t *startp, const size_t *countp,
1475  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1476  const unsigned short *op)
1477 {
1478  NC *ncp;
1479  int stat = NC_check_id(ncid, &ncp);
1480  if(stat != NC_NOERR) return stat;
1481  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1482  (void *)op, T_ushort);
1483 }
1484 
1485 int
1486 nc_put_varm_uint(int ncid, int varid,
1487  const size_t *startp, const size_t *countp,
1488  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1489  const unsigned int *op)
1490 {
1491  NC *ncp;
1492  int stat = NC_check_id(ncid, &ncp);
1493  if(stat != NC_NOERR) return stat;
1494  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1495  (void *)op, T_uint);
1496 }
1497 
1498 int
1499 nc_put_varm_longlong(int ncid, int varid,
1500  const size_t *startp, const size_t *countp,
1501  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1502  const long long *op)
1503 {
1504  NC *ncp;
1505  int stat = NC_check_id(ncid, &ncp);
1506  if(stat != NC_NOERR) return stat;
1507  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1508  (void *)op, T_longlong);
1509 }
1510 
1511 int
1512 nc_put_varm_ulonglong(int ncid, int varid,
1513  const size_t *startp, const size_t *countp,
1514  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1515  const unsigned long long *op)
1516 {
1517  NC *ncp;
1518  int stat = NC_check_id(ncid, &ncp);
1519  if(stat != NC_NOERR) return stat;
1520  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1521  (void *)op, NC_UINT64);
1522 }
1523 
1524 #ifdef USE_NETCDF4
1525 int
1526 nc_put_varm_string(int ncid, int varid,
1527  const size_t *startp, const size_t *countp,
1528  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1529  const char**op)
1530 {
1531  NC *ncp;
1532  int stat = NC_check_id(ncid, &ncp);
1533  if(stat != NC_NOERR) return stat;
1534  return NC_put_varm(ncid, varid, startp, countp, stridep, imapp,
1535  (void *)op, NC_STRING);
1536 }
1537 #endif /*USE_NETCDF4*/
1538  /*End of named group... */
1542 

Generated on Tue Jul 9 2013 19:17:27 for netCDF. NetCDF is a Unidata library.