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

Return to the Main Unidata NetCDF page.
Generated on Sun Nov 1 2015 19:54:55 for NetCDF. NetCDF is a Unidata library.