1/*! \file dvarput.c
2Functions for writing data to variables.
3
4Copyright 2010 University Corporation for Atmospheric
5Research/Unidata. See COPYRIGHT file for more info.
6*/
7
8#include "ncdispatch.h"
9
10#undef VARS_USES_VARM
11#ifndef VARS_USES_VARM
12struct 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
21static void
22odom_init(struct PUTodometerodom,
23     int rank,
24     const size_t* start, const size_t* edges, const ptrdiff_tstride)
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
39static int
40odom_more(struct PUTodometerodom)
41{
42    return (odom->index[0] < odom->stop[0]);
43}
44
45static int
46odom_next(struct PUTodometerodom)
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
60/** \internal
61\ingroup variables
62*/
63static int
64NC_put_vara(int ncid, int varid, const size_t *start,
65     const size_t *edges, const void *valuenc_type memtype)
66{
67   NCncp;
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(ncidvarid, &ndims);
74      if(stat != NC_NOERR) return stat;
75      stat = NC_getshape(ncidvaridndimsshape);
76      if(stat != NC_NOERR) return stat;
77      return ncp->dispatch->put_vara(ncidvaridstartshapevaluememtype);
78   } else
79      return ncp->dispatch->put_vara(ncidvaridstartedgesvaluememtype);
80}
81
82/** \internal
83\ingroup variables
84*/
85static int
86NC_put_var(int ncid, int varid, const void *valuenc_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,varidndimsshape);
93   if(stat) return stat;
94   return NC_put_vara(ncidvaridNC_coord_zeroshapevaluememtype);
95}
96
97/** \internal
98\ingroup variables
99*/
100static int
101NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
102     nc_type memtype)
103{
104   return NC_put_vara(ncidvaridcoordNC_coord_onevaluememtype);
105}
106
107/** \internal
108\ingroup variables
109*/
110int
111NCDEFAULT_put_vars(int ncid, int varid, const size_t * start,
112     const size_t * edges, const ptrdiff_t * stride,
113     const void *value0nc_type memtype)
114{
115#ifdef VARS_USES_VARM
116   NCncp;
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,isstride1,isrecvar;
126   int rank;
127   struct PUTodometer odom;
128   nc_type vartype = NC_NAT;
129   NCncp;
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   const char* memptr = value;
141
142   status = NC_check_id (ncid, &ncp);
143   if(status != NC_NOERR) return status;
144
145   status = nc_inq_vartype(ncidvarid, &vartype);
146   if(status != NC_NOERR) return status;
147
148   if(memtype == NC_NATmemtype = vartype;
149
150   /* compute the variable type size */
151   status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
152   if(status != NC_NOERR) return status;
153
154   if(memtype > NC_MAX_ATOMIC_TYPE)
155 memtypelen = (int)vartypelen;
156    else
157 memtypelen = nctypelen(memtype);
158
159   /* Check gross internal/external type compatibility */
160   if(vartype != memtype) {
161      /* If !atomic, the two types must be the same */
162      if(vartype > NC_MAX_ATOMIC_TYPE
163         || memtype > NC_MAX_ATOMIC_TYPE)
164  return NC_EBADTYPE;
165      /* ok, the types differ but both are atomic */
166      if(memtype == NC_CHAR || vartype == NC_CHAR)
167  return NC_ECHAR;
168   }
169
170   /* Get the variable rank */
171   status = nc_inq_varndims(ncidvarid, &rank);
172   if(status != NC_NOERR) return status;
173
174   /* Get variable dimension sizes */
175#if 0
176   isrecvar = NC_is_recvar(ncid,varid,&numrecs);
177#endif
178   status = NC_inq_recvar(ncid,varid,&nrecdims,is_recdim);
179   if(status != NC_NOERR) return status;
180   isrecvar = (nrecdims > 0);
181   NC_getshape(ncid,varid,rank,varshape);
182
183   /* Optimize out using various checks */
184   if (rank == 0) {
185      /*
186       * The variable is a scalar; consequently,
187       * there is only one thing to get and only one place to put it.
188       * (Why was I called?)
189       */
190      size_t edge1[1] = {1};
191      return NC_put_vara(ncidvaridstartedge1value0memtype);
192   }
193
194   /* Do various checks and fixups on start/edges/stride */
195   isstride1 = 1; /* assume so */
196   for(i=0;i<rank;i++) {
197 size_t dimlen;
198 mystart[i] = (start == NULL ? 0 : start[i]);
199 if(edges == NULL) {
200#if 0
201    if(i == 0 && isrecvar)
202         myedges[i] = numrecs - start[i];
203#else
204    if(is_recdim[i] && isrecvar)
205         myedges[i] = varshape[i] - start[i];
206#endif
207    else
208       myedges[i] = varshape[i] - mystart[i];
209 } else
210     myedges[i] = edges[i];
211 if(myedges[i] == 0)
212     return NC_NOERR; /* cannot write anything */
213 mystride[i] = (stride == NULL ? 1 : stride[i]);
214 if(mystride[i] <= 0
215    /* cast needed for braindead systems with signed size_t */
216           || ((unsigned long) mystride[i] >= X_INT_MAX))
217           return NC_ESTRIDE;
218   if(mystride[i] != 1) isstride1 = 0;
219        /* illegal value checks */
220#if 0
221 dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
222 if(i == 0 && isrecvar) {/*do nothing*/}
223#else
224 dimlen = varshape[i];
225 if(is_recdim[i]) {/*do nothing*/}
226#endif
227        else {
228   /* mystart is unsigned, will never be < 0 */
229   if(mystart[i] > dimlen)
230     return NC_EINVALCOORDS;
231          /* myediges is unsigned, will never be < 0 */
232   if(mystart[i] + myedges[i] > dimlen)
233     return NC_EEDGE;
234       }
235   }
236   if(isstride1) {
237      return NC_put_vara(ncidvaridmystartmyedgesvaluememtype);
238   }
239
240   /* Initial version uses and odometer to walk the variable
241      and read each value one at a time. This can later be optimized
242      to read larger chunks at a time.
243    */
244
245
246   odom_init(&odom,rank,mystart,myedges,mystride);
247
248   /* walk the odometer to extract values */
249   while(odom_more(&odom)) {
250      int localstatus = NC_NOERR;
251      /* Write a single value */
252      localstatus = NC_put_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
253      /* So it turns out that when get_varm is used, all errors are
254         delayed and ERANGE will be overwritten by more serious errors.
255      */
256      if(localstatus != NC_NOERR) {
257     if(status == NC_NOERR || localstatus != NC_ERANGE)
258        status = localstatus;
259      }
260      memptr += memtypelen;
261      odom_next(&odom);
262   }
263   return status;
264#endif
265}
266
267/** \internal
268\ingroup variables
269*/
270int
271NCDEFAULT_put_varm(
272   int ncid,
273   int varid,
274   const size_t * start,
275   const size_t * edges,
276   const ptrdiff_t * stride,
277   const ptrdiff_t * imapp,
278   const void *value0,
279   nc_type memtype)
280{
281   int status = NC_NOERR;
282   nc_type vartype = NC_NAT;
283   int varndims = 0;
284   int maxidim = 0;
285   NCncp;
286   int memtypelen;
287   const char* value = (char*)value0;
288
289   status = NC_check_id (ncid, &ncp);
290   if(status != NC_NOERR) return status;
291
292/*
293  if(NC_indef(ncp)) return NC_EINDEFINE;
294  if(NC_readonly (ncp)) return NC_EPERM;
295*/
296
297   /* mid body */
298   status = nc_inq_vartype(ncidvarid, &vartype);
299   if(status != NC_NOERR) return status;
300   /* Check that this is an atomic type */
301   if(vartype > NC_MAX_ATOMIC_TYPE)
302 return NC_EMAPTYPE;
303
304   status = nc_inq_varndims(ncidvarid, &varndims);
305   if(status != NC_NOERR) return status;
306
307   if(memtype == NC_NAT) {
308      memtype = vartype;
309   }
310
311   if(memtype == NC_CHAR && vartype != NC_CHAR)
312      return NC_ECHAR;
313   else if(memtype != NC_CHAR && vartype == NC_CHAR)
314      return NC_ECHAR;
315
316   memtypelen = nctypelen(memtype);
317
318   maxidim = (int) varndims - 1;
319
320   if (maxidim < 0)
321   {
322      /*
323       * The variable is a scalar; consequently,
324       * there s only one thing to get and only one place to put it.
325       * (Why was I called?)
326       */
327      size_t edge1[1] = {1};
328      return NC_put_vara(ncidvaridstartedge1valuememtype);
329   }
330
331   /*
332    * else
333    * The variable is an array.
334    */
335   {
336      int idim;
337      size_t *mystart = NULL;
338      size_t *myedges = 0;
339      size_t *iocount= 0;    /* count vector */
340      size_t *stop = 0;   /* stop indexes */
341      size_t *length = 0; /* edge lengths in bytes */
342      ptrdiff_t *mystride = 0;
343      ptrdiff_t *mymap= 0;
344      size_t varshape[NC_MAX_VAR_DIMS];
345      int isrecvar;
346      size_t numrecs;
347      int stride1; /* is stride all ones? */
348
349      /*
350       * Verify stride argument.
351       */
352      stride1 = 1; /*  assume ok; */
353      if(stride != NULL) {
354  for (idim = 0; idim <= maxidim; ++idim) {
355            if ((stride[idim] == 0)
356 /* cast needed for braindead systems with signed size_t */
357                || ((unsigned long) stride[idim] >= X_INT_MAX))
358     {
359        return NC_ESTRIDE;
360            }
361     if(stride[idim] != 1) stride1 = 0;
362  }
363      }
364
365      /* If stride1 is true, and there is no imap, then call get_vara
366         directly
367      */
368      if(stride1 && imapp == NULL) {
369  return NC_put_vara(ncidvaridstartedgesvaluememtype);
370      }
371
372      /* Compute some dimension related values */
373      isrecvar = NC_is_recvar(ncid,varid,&numrecs);
374      NC_getshape(ncid,varid,varndims,varshape);
375
376      /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
377      mystart = (size_t *)calloc((size_t)(varndims * 7), sizeof(ptrdiff_t));
378      if(mystart == NULL) return NC_ENOMEM;
379      myedges = mystart + varndims;
380      iocount = myedges + varndims;
381      stop = iocount + varndims;
382      length = stop + varndims;
383      mystride = (ptrdiff_t *)(length + varndims);
384      mymap = mystride + varndims;
385
386      /*
387       * Initialize I/O parameters.
388       */
389      for (idim = maxidimidim >= 0; --idim)
390      {
391  mystart[idim] = start != NULL
392     ? start[idim]
393     : 0;
394
395  if (edges != NULL && edges[idim] == 0)
396  {
397     status = NC_NOERR;    /* read/write no data */
398     goto done;
399  }
400
401  myedges[idim] = edges != NULL
402     ? edges[idim]
403     : idim == 0 && isrecvar
404             ? numrecs - mystart[idim]
405         : varshape[idim] - mystart[idim];
406  mystride[idim] = stride != NULL
407     ? stride[idim]
408     : 1;
409  mymap[idim] = imapp != NULL
410     ? imapp[idim]
411     : idim == maxidim
412         ? 1
413         : mymap[idim + 1] * (ptrdiff_tmyedges[idim + 1];
414
415  iocount[idim] = 1;
416  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
417  stop[idim] = mystart[idim] + myedges[idim] * (size_t)mystride[idim];
418      }
419
420      /*
421       * Check start, edges
422       */
423      for (idim = isrecvaridim < maxidim; ++idim)
424      {
425  if (mystart[idim] > varshape[idim])
426  {
427     status = NC_EINVALCOORDS;
428     goto done;
429  }
430  if (mystart[idim] + myedges[idim] > varshape[idim])
431  {
432     status = NC_EEDGE;
433     goto done;
434  }
435      }
436
437      /* Lower body */
438      /*
439       * As an optimization, adjust I/O parameters when the fastest
440       * dimension has unity stride both externally and internally.
441       * In this case, the user could have called a simpler routine
442       * (i.e. ncvar$1()
443       */
444      if (mystride[maxidim] == 1
445   && mymap[maxidim] == 1)
446      {
447  iocount[maxidim] = myedges[maxidim];
448  mystride[maxidim] = (ptrdiff_tmyedges[maxidim];
449  mymap[maxidim] = (ptrdiff_tlength[maxidim];
450      }
451
452      /*
453       * Perform I/O.  Exit when done.
454       */
455      for (;;)
456      {
457  /* TODO: */
458  int lstatus = NC_put_vara(ncidvaridmystartiocount,
459    valuememtype);
460  if (lstatus != NC_NOERR) {
461     if(status == NC_NOERR || lstatus != NC_ERANGE)
462        status = lstatus;
463  }
464
465  /*
466   * The following code permutes through the variable s
467   * external start-index space and it s internal address
468   * space.  At the UPC, this algorithm is commonly
469   * called "odometer code".
470   */
471  idim = maxidim;
472        carry:
473  value += (mymap[idim] * memtypelen);
474  mystart[idim] += (size_t)mystride[idim];
475  if (mystart[idim] == stop[idim])
476  {
477     size_t l = (length[idim] * (size_t)memtypelen);
478     value -= l;
479     mystart[idim] = start[idim];
480     if (--idim < 0)
481        break; /* normal return */
482     goto carry;
483  }
484      } /* I/O loop */
485     done:
486      free(mystart);
487   } /* variable is array */
488   return status;
489}
490
491/** \internal
492\ingroup variables
493*/
494static int
495NC_put_vars(int ncid, int varid, const size_t *start,
496     const size_t *edges, const ptrdiff_t *stride,
497     const void *valuenc_type memtype)
498{
499   NCncp;
500   int stat = NC_check_id(ncid, &ncp);
501
502   if(stat != NC_NOERR) return stat;
503#ifdef USE_NETCDF4
504   if(memtype >= NC_FIRSTUSERTYPEIDmemtype = NC_NAT;
505#endif
506   return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype);
507}
508
509/** \internal
510\ingroup variables
511*/
512static int
513NC_put_varm(int ncid, int varid, const size_t *start,
514     const size_t *edges, const ptrdiff_t *stride, const ptrdiff_tmap,
515     const void *valuenc_type memtype)
516{
517   NCncp;
518   int stat = NC_check_id(ncid, &ncp);
519
520   if(stat != NC_NOERR) return stat;
521#ifdef USE_NETCDF4
522   if(memtype >= NC_FIRSTUSERTYPEIDmemtype = NC_NAT;
523#endif
524   return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype);
525}
526
527/** \name Writing Data to Variables
528
529Functions to write data from variables. */
530/*! \{ */ /* All these functions are part of this named group... */
531
532/** \ingroup variables
533Write an array of values to a variable.
534
535The values to be written are associated with the netCDF variable by
536assuming that the last dimension of the netCDF variable varies fastest
537in the C interface. The netCDF dataset must be in data mode. The array
538to be written is specified by giving a corner and a vector of edge
539lengths to \ref specify_hyperslab.
540
541The functions for types ubyte, ushort, uint, longlong, ulonglong, and
542string are only available for netCDF-4/HDF5 files.
543
544The nc_put_var() function will write a variable of any type, including
545user defined type. For this function, the type of the data in memory
546must match the type of the variable - no data conversion is done.
547
548\param ncid NetCDF or group ID, from a previous call to nc_open(),
549nc_create(), nc_def_grp(), or associated inquiry functions such as
550nc_inq_ncid().
551
552\param varid Variable ID
553
554\param startp Start vector with one element for each dimension to \ref
555specify_hyperslab.
556
557\param countp Count vector with one element for each dimension to \ref
558specify_hyperslab.
559
560\param op Pointer where the data will be copied. Memory must be
561allocated by the user before this function is called.
562
563\returns ::NC_NOERR No error.
564\returns ::NC_ENOTVAR Variable not found.
565\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
566\returns ::NC_EEDGE Start+count exceeds dimension bound.
567\returns ::NC_ERANGE One or more of the values are out of range.
568\returns ::NC_EINDEFINE Operation not allowed in define mode.
569\returns ::NC_EBADID Bad ncid.
570 */
571/**@{*/
572int
573nc_put_vara(int ncid, int varid, const size_t *startp,
574     const size_t *countp, const void *op)
575{
576   NCncp;
577   int stat = NC_check_id(ncid, &ncp);
578   nc_type xtype;
579   if(stat != NC_NOERR) return stat;
580   stat = nc_inq_vartype(ncidvarid, &xtype);
581   if(stat != NC_NOERR) return stat;
582   return NC_put_vara(ncidvaridstartpcountpopxtype);
583}
584
585int
586nc_put_vara_text(int ncid, int varid, const size_t *startp,
587  const size_t *countp, const char *op)
588{
589   return NC_put_vara(ncidvaridstartpcountp,
590       (void*)opNC_CHAR);
591}
592
593int
594nc_put_vara_schar(int ncid, int varid, const size_t *startp,
595   const size_t *countp, const signed char *op)
596{
597   NCncp;
598   int stat = NC_check_id(ncid, &ncp);
599   if(stat != NC_NOERR) return stat;
600   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
601       NC_BYTE);
602}
603
604int
605nc_put_vara_uchar(int ncid, int varid, const size_t *startp,
606   const size_t *countp, const unsigned char *op)
607{
608   NCncp;
609   int stat = NC_check_id(ncid, &ncp);
610   if(stat != NC_NOERR) return stat;
611   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
612       T_uchar);
613}
614
615int
616nc_put_vara_short(int ncid, int varid, const size_t *startp,
617   const size_t *countp, const short *op)
618{
619   NCncp;
620   int stat = NC_check_id(ncid, &ncp);
621   if(stat != NC_NOERR) return stat;
622   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
623       NC_SHORT);
624}
625
626int
627nc_put_vara_int(int ncid, int varid, const size_t *startp,
628 const size_t *countp, const int *op)
629{
630   NCncp;
631   int stat = NC_check_id(ncid, &ncp);
632   if(stat != NC_NOERR) return stat;
633   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
634       NC_INT);
635}
636
637int
638nc_put_vara_long(int ncid, int varid, const size_t *startp,
639  const size_t *countp, const long *op)
640{
641   NCncp;
642   int stat = NC_check_id(ncid, &ncp);
643   if(stat != NC_NOERR) return stat;
644   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
645       T_long);
646}
647
648int
649nc_put_vara_float(int ncid, int varid, const size_t *startp,
650   const size_t *countp, const float *op)
651{
652   NCncp;
653   int stat = NC_check_id(ncid, &ncp);
654   if(stat != NC_NOERR) return stat;
655   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
656       T_float);
657}
658
659int
660nc_put_vara_double(int ncid, int varid, const size_t *startp,
661    const size_t *countp, const double *op)
662{
663   NCncp;
664   int stat = NC_check_id(ncid, &ncp);
665   if(stat != NC_NOERR) return stat;
666   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
667       T_double);
668}
669
670int
671nc_put_vara_ubyte(int ncid, int varid, const size_t *startp,
672   const size_t *countp, const unsigned char *op)
673{
674   NCncp;
675   int stat = NC_check_id(ncid, &ncp);
676   if(stat != NC_NOERR) return stat;
677   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
678       T_ubyte);
679}
680
681int
682nc_put_vara_ushort(int ncid, int varid, const size_t *startp,
683    const size_t *countp, const unsigned short *op)
684{
685   NCncp;
686   int stat = NC_check_id(ncid, &ncp);
687   if(stat != NC_NOERR) return stat;
688   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
689       T_ushort);
690}
691
692int
693nc_put_vara_uint(int ncid, int varid, const size_t *startp,
694  const size_t *countp, const unsigned int *op)
695{
696   NCncp;
697   int stat = NC_check_id(ncid, &ncp);
698   if(stat != NC_NOERR) return stat;
699   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
700       T_uint);
701}
702
703int
704nc_put_vara_longlong(int ncid, int varid, const size_t *startp,
705      const size_t *countp, const long long *op)
706{
707   NCncp;
708   int stat = NC_check_id(ncid, &ncp);
709   if(stat != NC_NOERR) return stat;
710   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
711       T_longlong);
712}
713
714int
715nc_put_vara_ulonglong(int ncid, int varid, const size_t *startp,
716       const size_t *countp, const unsigned long long *op)
717{
718   NCncp;
719   int stat = NC_check_id(ncid, &ncp);
720   if(stat != NC_NOERR) return stat;
721   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
722       NC_UINT64);
723}
724
725#ifdef USE_NETCDF4
726int
727nc_put_vara_string(int ncid, int varid, const size_t *startp,
728    const size_t *countp, const char* *op)
729{
730   NCncp;
731   int stat = NC_check_id(ncid, &ncp);
732   if(stat != NC_NOERR) return stat;
733   return NC_put_vara(ncidvaridstartpcountp, (void *)op,
734       NC_STRING);
735}
736
737#endif /*USE_NETCDF4*/
738/**@}*/
739
740/** \ingroup variables
741Write one datum.
742
743\param ncid NetCDF or group ID, from a previous call to nc_open(),
744nc_create(), nc_def_grp(), or associated inquiry functions such as
745nc_inq_ncid().
746
747\param varid Variable ID
748
749\param indexp Index vector with one element for each dimension.
750
751\param op Pointer from where the data will be copied.
752
753\returns ::NC_NOERR No error.
754\returns ::NC_ENOTVAR Variable not found.
755\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
756\returns ::NC_EEDGE Start+count exceeds dimension bound.
757\returns ::NC_ERANGE One or more of the values are out of range.
758\returns ::NC_EINDEFINE Operation not allowed in define mode.
759\returns ::NC_EBADID Bad ncid.
760 */
761/**@{*/
762int
763nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op)
764{
765   return NC_put_var1(ncidvaridindexpopNC_NAT);
766}
767
768int
769nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op)
770{
771   NCncp;
772   int stat = NC_check_id(ncid, &ncp);
773   if(stat != NC_NOERR) return stat;
774   return NC_put_var1(ncidvaridindexp, (void *)opNC_CHAR);
775}
776
777int
778nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op)
779{
780   NCncp;
781   int stat = NC_check_id(ncid, &ncp);
782   if(stat != NC_NOERR) return stat;
783   return NC_put_var1(ncidvaridindexp, (void *)opNC_BYTE);
784}
785
786int
787nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op)
788{
789   NCncp;
790   int stat = NC_check_id(ncid, &ncp);
791   if(stat != NC_NOERR) return stat;
792   return NC_put_var1(ncidvaridindexp, (void *)opNC_UBYTE);
793}
794
795int
796nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op)
797{
798   NCncp;
799   int stat = NC_check_id(ncid, &ncp);
800   if(stat != NC_NOERR) return stat;
801   return NC_put_var1(ncidvaridindexp, (void *)opNC_SHORT);
802}
803
804int
805nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op)
806{
807   NCncp;
808   int stat = NC_check_id(ncid, &ncp);
809   if(stat != NC_NOERR) return stat;
810   return NC_put_var1(ncidvaridindexp, (void *)opNC_INT);
811}
812
813int
814nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op)
815{
816   NCncp;
817   int stat = NC_check_id(ncid, &ncp);
818   if(stat != NC_NOERR) return stat;
819   return NC_put_var1(ncidvaridindexp, (void*)oplongtype);
820}
821
822int
823nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op)
824{
825   NCncp;
826   int stat = NC_check_id(ncid, &ncp);
827   if(stat != NC_NOERR) return stat;
828   return NC_put_var1(ncidvaridindexp, (void*)opNC_FLOAT);
829}
830
831int
832nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op)
833{
834   NCncp;
835   int stat = NC_check_id(ncid, &ncp);
836   if(stat != NC_NOERR) return stat;
837   return NC_put_var1(ncidvaridindexp, (void *)opNC_DOUBLE);
838}
839
840int
841nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op)
842{
843   NCncp;
844   int stat = NC_check_id(ncid, &ncp);
845   if(stat != NC_NOERR) return stat;
846   return NC_put_var1(ncidvaridindexp, (void *)opNC_UBYTE);
847}
848
849int
850nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op)
851{
852   NCncp;
853   int stat = NC_check_id(ncid, &ncp);
854   if(stat != NC_NOERR) return stat;
855   return NC_put_var1(ncidvaridindexp, (void *)opNC_USHORT);
856}
857
858int
859nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op)
860{
861   NCncp;
862   int stat = NC_check_id(ncid, &ncp);
863   if(stat != NC_NOERR) return stat;
864   return NC_put_var1(ncidvaridindexp, (void *)opNC_UINT);
865}
866
867int
868nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op)
869{
870   NCncp;
871   int stat = NC_check_id(ncid, &ncp);
872   if(stat != NC_NOERR) return stat;
873   return NC_put_var1(ncidvaridindexp, (void *)opNC_INT64);
874}
875
876int
877nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op)
878{
879   NCncp;
880   int stat = NC_check_id(ncid, &ncp);
881   if(stat != NC_NOERR) return stat;
882   return NC_put_var1(ncidvaridindexp, (void *)opNC_UINT64);
883}
884
885#ifdef USE_NETCDF4
886int
887nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char* *op)
888{
889   NCncp;
890   int stat = NC_check_id(ncid, &ncp);
891   if(stat != NC_NOERR) return stat;
892   return NC_put_var1(ncidvaridindexp, (void*)opNC_STRING);
893}
894#endif /*USE_NETCDF4*/
895/**@}*/
896
897/** \ingroup variables
898Write an entire variable with one call.
899
900The nc_put_var_ type family of functions write all the values of a
901variable into a netCDF variable of an open netCDF dataset. This is the
902simplest interface to use for writing a value in a scalar variable or
903whenever all the values of a multidimensional variable can all be
904written at once. The values to be written are associated with the
905netCDF variable by assuming that the last dimension of the netCDF
906variable varies fastest in the C interface. The values are converted
907to the external data type of the variable, if necessary.
908
909Take care when using this function with record variables (variables
910that use the ::NC_UNLIMITED dimension). If you try to write all the
911values of a record variable into a netCDF file that has no record data
912yet (hence has 0 records), nothing will be written. Similarly, if you
913try to write all the values of a record variable but there are more
914records in the file than you assume, more in-memory data will be
915accessed than you supply, which may result in a segmentation
916violation. To avoid such problems, it is better to use the nc_put_vara
917interfaces for variables that use the ::NC_UNLIMITED dimension.
918
919The functions for types ubyte, ushort, uint, longlong, ulonglong, and
920string are only available for netCDF-4/HDF5 files.
921
922The nc_put_var() function will write a variable of any type, including
923user defined type. For this function, the type of the data in memory
924must match the type of the variable - no data conversion is done.
925
926\param ncid NetCDF or group ID, from a previous call to nc_open(),
927nc_create(), nc_def_grp(), or associated inquiry functions such as
928nc_inq_ncid().
929
930\param varid Variable ID
931
932\param op Pointer from where the data will be copied.
933
934\returns ::NC_NOERR No error.
935\returns ::NC_ENOTVAR Variable not found.
936\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
937\returns ::NC_EEDGE Start+count exceeds dimension bound.
938\returns ::NC_ERANGE One or more of the values are out of range.
939\returns ::NC_EINDEFINE Operation not allowed in define mode.
940\returns ::NC_EBADID Bad ncid.
941 */
942/**@{*/
943int
944nc_put_var(int ncid, int varid, const void *op)
945{
946   return NC_put_var(ncidvaridopNC_NAT);
947}
948
949int
950nc_put_var_text(int ncid, int varid, const char *op)
951{
952   NCncp;
953   int stat = NC_check_id(ncid, &ncp);
954   if(stat != NC_NOERR) return stat;
955   return NC_put_var(ncid,varid,(void*)op,NC_CHAR);
956}
957
958int
959nc_put_var_schar(int ncid, int varid, const signed char *op)
960{
961   NCncp;
962   int stat = NC_check_id(ncid, &ncp);
963   if(stat != NC_NOERR) return stat;
964   return NC_put_var(ncid,varid,(void*)op,NC_BYTE);
965}
966
967int
968nc_put_var_uchar(int ncid, int varid, const unsigned char *op)
969{
970   NCncp;
971   int stat = NC_check_id(ncid, &ncp);
972   if(stat != NC_NOERR) return stat;
973   return NC_put_var(ncid,varid,(void*)op,T_uchar);
974}
975
976int
977nc_put_var_short(int ncid, int varid, const short *op)
978{
979   NCncp;
980   int stat = NC_check_id(ncid, &ncp);
981   if(stat != NC_NOERR) return stat;
982   return NC_put_var(ncid,varid,(void*)op,NC_SHORT);
983}
984
985int
986nc_put_var_int(int ncid, int varid, const int *op)
987{
988   NCncp;
989   int stat = NC_check_id(ncid, &ncp);
990   if(stat != NC_NOERR) return stat;
991   return NC_put_var(ncid,varid,(void*)op,NC_INT);
992}
993
994int
995nc_put_var_long(int ncid, int varid, const long *op)
996{
997   NCncp;
998   int stat = NC_check_id(ncid, &ncp);
999   if(stat != NC_NOERR) return stat;
1000   return NC_put_var(ncid,varid,(void*)op,T_long);
1001}
1002
1003int
1004nc_put_var_float(int ncid, int varid, const float *op)
1005{
1006   NCncp;
1007   int stat = NC_check_id(ncid, &ncp);
1008   if(stat != NC_NOERR) return stat;
1009   return NC_put_var(ncid,varid,(void*)op,T_float);
1010}
1011
1012int
1013nc_put_var_double(int ncid, int varid, const double *op)
1014{
1015   NCncp;
1016   int stat = NC_check_id(ncid, &ncp);
1017   if(stat != NC_NOERR) return stat;
1018   return NC_put_var(ncid,varid,(void*)op,T_double);
1019}
1020
1021int
1022nc_put_var_ubyte(int ncid, int varid, const unsigned char *op)
1023{
1024   NCncp;
1025   int stat = NC_check_id(ncid, &ncp);
1026   if(stat != NC_NOERR) return stat;
1027   return NC_put_var(ncid,varid,(void*)op,T_ubyte);
1028}
1029
1030int
1031nc_put_var_ushort(int ncid, int varid, const unsigned short *op)
1032{
1033   NCncp;
1034   int stat = NC_check_id(ncid, &ncp);
1035   if(stat != NC_NOERR) return stat;
1036   return NC_put_var(ncid,varid,(void*)op,T_ushort);
1037}
1038
1039int
1040nc_put_var_uint(int ncid, int varid, const unsigned int *op)
1041{
1042   NCncp;
1043   int stat = NC_check_id(ncid, &ncp);
1044   if(stat != NC_NOERR) return stat;
1045   return NC_put_var(ncid,varid,(void*)op,T_uint);
1046}
1047
1048int
1049nc_put_var_longlong(int ncid, int varid, const long long *op)
1050{
1051   NCncp;
1052   int stat = NC_check_id(ncid, &ncp);
1053   if(stat != NC_NOERR) return stat;
1054   return NC_put_var(ncid,varid,(void*)op,T_longlong);
1055}
1056
1057int
1058nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op)
1059{
1060   NCncp;
1061   int stat = NC_check_id(ncid, &ncp);
1062   if(stat != NC_NOERR) return stat;
1063   return NC_put_var(ncid,varid,(void*)op,NC_UINT64);
1064}
1065
1066#ifdef USE_NETCDF4
1067int
1068nc_put_var_string(int ncid, int varid, const char* *op)
1069{
1070   NCncp;
1071   int stat = NC_check_id(ncid, &ncp);
1072   if(stat != NC_NOERR) return stat;
1073   return NC_put_var(ncid,varid,(void*)op,NC_STRING);
1074}
1075#endif /*USE_NETCDF4*/
1076/**\} */
1077
1078/** \ingroup variables
1079Write a strided array of values to a variable.
1080
1081\param ncid NetCDF or group ID, from a previous call to nc_open(),
1082nc_create(), nc_def_grp(), or associated inquiry functions such as
1083nc_inq_ncid().
1084
1085\param varid Variable ID
1086
1087\param startp Start vector with one element for each dimension to \ref
1088specify_hyperslab.
1089
1090\param countp Count vector with one element for each dimension to \ref
1091specify_hyperslab.
1092
1093\param stridep Stride vector with one element for each dimension to
1094\ref specify_hyperslab.
1095
1096\param op Pointer where the data will be copied. Memory must be
1097allocated by the user before this function is called.
1098
1099\returns ::NC_NOERR No error.
1100\returns ::NC_ENOTVAR Variable not found.
1101\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
1102\returns ::NC_EEDGE Start+count exceeds dimension bound.
1103\returns ::NC_ERANGE One or more of the values are out of range.
1104\returns ::NC_EINDEFINE Operation not allowed in define mode.
1105\returns ::NC_EBADID Bad ncid.
1106 */
1107/**@{*/
1108int
1109nc_put_vars (int ncid, int varid, const size_t *startp,
1110      const size_t *countp, const ptrdiff_t *stridep,
1111      const void *op)
1112{
1113   NC *ncp;
1114   int stat = NC_NOERR;
1115
1116   if ((stat = NC_check_id(ncid, &ncp)))
1117       return stat;
1118   return ncp->dispatch->put_vars(ncidvaridstartpcountp,
1119   stridepopNC_NAT);
1120}
1121
1122int
1123nc_put_vars_text(int ncid, int varid, const size_t *startp,
1124  const size_t *countp, const ptrdiff_t *stridep,
1125  const char *op)
1126{
1127   NC *ncp;
1128   int stat = NC_check_id(ncid, &ncp);
1129   if(stat != NC_NOERR) return stat;
1130   return NC_put_vars(ncidvaridstartpcountp,
1131       stridep,(void*)op,NC_CHAR);
1132}
1133
1134int
1135nc_put_vars_schar(int ncid, int varid, const size_t *startp,
1136   const size_t *countp, const ptrdiff_t *stridep,
1137   const signed char *op)
1138{
1139   NC *ncp;
1140   int stat = NC_check_id(ncid, &ncp);
1141   if(stat != NC_NOERR) return stat;
1142   return NC_put_vars(ncidvaridstartpcountp,
1143       stridep,(void*)op,NC_BYTE);
1144}
1145
1146int
1147nc_put_vars_uchar(int ncid, int varid,
1148   const size_t *startp, const size_t *countp,
1149   const ptrdiff_t *stridep,
1150   const unsigned char *op)
1151{
1152   NC *ncp;
1153   int stat = NC_check_id(ncid, &ncp);
1154   if(stat != NC_NOERR) return stat;
1155   return NC_put_vars(ncidvaridstartpcountp,
1156       stridep, (void *)opT_uchar);
1157}
1158
1159int
1160nc_put_vars_short(int ncid, int varid,
1161   const size_t *startp, const size_t *countp,
1162   const ptrdiff_t *stridep,
1163   const short *op)
1164{
1165   NC *ncp;
1166   int stat = NC_check_id(ncid, &ncp);
1167   if(stat != NC_NOERR) return stat;
1168   return NC_put_vars(ncidvaridstartpcountp,
1169       stridep, (void *)opNC_SHORT);
1170}
1171
1172int
1173nc_put_vars_int(int ncid, int varid,
1174 const size_t *startp, const size_t *countp,
1175 const ptrdiff_t *stridep,
1176 const int *op)
1177{
1178   NC *ncp;
1179   int stat = NC_check_id(ncid, &ncp);
1180   if(stat != NC_NOERR) return stat;
1181   return NC_put_vars(ncidvaridstartpcountp,
1182       stridep, (void *)opNC_INT);
1183}
1184
1185int
1186nc_put_vars_long(int ncid, int varid,
1187  const size_t *startp, const size_t *countp,
1188  const ptrdiff_t *stridep,
1189  const long *op)
1190{
1191   NC *ncp;
1192   int stat = NC_check_id(ncid, &ncp);
1193   if(stat != NC_NOERR) return stat;
1194   return NC_put_vars(ncidvaridstartpcountp,
1195       stridep, (void *)opT_long);
1196}
1197
1198int
1199nc_put_vars_float(int ncid, int varid,
1200   const size_t *startp, const size_t *countp,
1201   const ptrdiff_t *stridep,
1202   const float *op)
1203{
1204   NC *ncp;
1205   int stat = NC_check_id(ncid, &ncp);
1206   if(stat != NC_NOERR) return stat;
1207   return NC_put_vars(ncidvaridstartpcountp,
1208       stridep, (void *)opT_float);
1209}
1210
1211int
1212nc_put_vars_double(int ncid, int varid,
1213    const size_t *startp, const size_t *countp,
1214    const ptrdiff_t *stridep,
1215    const double *op)
1216{
1217   NC *ncp;
1218   int stat = NC_check_id(ncid, &ncp);
1219   if(stat != NC_NOERR) return stat;
1220   return NC_put_vars(ncidvaridstartpcountp,
1221       stridep, (void *)opT_double);
1222}
1223
1224int
1225nc_put_vars_ubyte(int ncid, int varid,
1226   const size_t *startp, const size_t *countp,
1227   const ptrdiff_t *stridep,
1228   const unsigned char *op)
1229{
1230   NC *ncp;
1231   int stat = NC_check_id(ncid, &ncp);
1232   if(stat != NC_NOERR) return stat;
1233   return NC_put_vars(ncidvaridstartpcountp,
1234       stridep, (void *)opT_ubyte);
1235}
1236
1237int
1238nc_put_vars_ushort(int ncid, int varid,
1239    const size_t *startp, const size_t *countp,
1240    const ptrdiff_t *stridep,
1241    const unsigned short *op)
1242{
1243   NC *ncp;
1244   int stat = NC_check_id(ncid, &ncp);
1245   if(stat != NC_NOERR) return stat;
1246   return NC_put_vars(ncidvaridstartpcountp,
1247       stridep, (void *)opT_ushort);
1248}
1249
1250int
1251nc_put_vars_uint(int ncid, int varid,
1252  const size_t *startp, const size_t *countp,
1253  const ptrdiff_t *stridep,
1254  const unsigned int *op)
1255{
1256   NC *ncp;
1257   int stat = NC_check_id(ncid, &ncp);
1258   if(stat != NC_NOERR) return stat;
1259   return NC_put_vars(ncidvaridstartpcountp,
1260       stridep, (void *)opT_uint);
1261}
1262
1263int
1264nc_put_vars_longlong(int ncid, int varid,
1265      const size_t *startp, const size_t *countp,
1266      const ptrdiff_t *stridep,
1267      const long long *op)
1268{
1269   NC *ncp;
1270   int stat = NC_check_id(ncid, &ncp);
1271   if(stat != NC_NOERR) return stat;
1272   return NC_put_vars(ncidvaridstartpcountp,
1273       stridep, (void *)opT_longlong);
1274}
1275
1276int
1277nc_put_vars_ulonglong(int ncid, int varid,
1278       const size_t *startp, const size_t *countp,
1279       const ptrdiff_t *stridep,
1280       const unsigned long long *op)
1281{
1282   NC *ncp;
1283   int stat = NC_check_id(ncid, &ncp);
1284   if(stat != NC_NOERR) return stat;
1285   return NC_put_vars(ncidvaridstartpcountp,
1286       stridep, (void *)opNC_UINT64);
1287}
1288
1289#ifdef USE_NETCDF4
1290int
1291nc_put_vars_string(int ncid, int varid,
1292    const size_t *startp, const size_t *countp,
1293    const ptrdiff_t *stridep,
1294    const char**op)
1295{
1296   NC *ncp;
1297   int stat = NC_check_id(ncid, &ncp);
1298   if(stat != NC_NOERR) return stat;
1299   return NC_put_vars(ncidvaridstartpcountpstridep,
1300       (void *)opNC_STRING);
1301}
1302#endif /*USE_NETCDF4*/
1303/**\} */
1304
1305/** \ingroup variables
1306Write a mapped array of values to a variable.
1307
1308The nc_put_varm() function will only write a variable of an
1309atomic type; it will not write user defined types. For this
1310function, the type of the data in memory must match the type
1311of the variable - no data conversion is done.
1312
1313@deprecated Use of this family of functions is discouraged,
1314although it will continue to be supported.
1315The reason is the complexity of the
1316algorithm makes its use difficult for users to properly use.
1317
1318\param ncid NetCDF or group ID, from a previous call to nc_open(),
1319nc_create(), nc_def_grp(), or associated inquiry functions such as
1320nc_inq_ncid().
1321
1322\param varid Variable ID
1323
1324\param startp Start vector with one element for each dimension to \ref
1325specify_hyperslab.
1326
1327\param countp Count vector with one element for each dimension to \ref
1328specify_hyperslab.
1329
1330\param stridep Stride vector with one element for each dimension to
1331\ref specify_hyperslab.
1332
1333\param imapp Mapping vector with one element for each dimension to
1334\ref specify_hyperslab.
1335
1336\param op Pointer where the data will be copied. Memory must be
1337allocated by the user before this function is called.
1338
1339\returns ::NC_NOERR No error.
1340\returns ::NC_ENOTVAR Variable not found.
1341\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
1342\returns ::NC_EEDGE Start+count exceeds dimension bound.
1343\returns ::NC_ERANGE One or more of the values are out of range.
1344\returns ::NC_EINDEFINE Operation not allowed in define mode.
1345\returns ::NC_EBADID Bad ncid.
1346 */
1347/**@{*/
1348int
1349nc_put_varm (int ncid, int varid, const size_t *startp,
1350      const size_t *countp, const ptrdiff_t *stridep,
1351      const ptrdiff_t *imapp, const void *op)
1352{
1353   NC *ncp;
1354   int stat = NC_NOERR;
1355
1356   if ((stat = NC_check_id(ncid, &ncp)))
1357       return stat;
1358   return ncp->dispatch->put_varm(ncidvaridstartpcountp,
1359   stridepimappopNC_NAT);
1360}
1361
1362int
1363nc_put_varm_text(int ncid, int varid, const size_t *startp,
1364  const size_t *countp, const ptrdiff_t *stridep,
1365  const ptrdiff_t *imapp, const char *op)
1366{
1367   NC *ncp;
1368   int stat = NC_check_id(ncid, &ncp);
1369   if(stat != NC_NOERR) return stat;
1370   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1371       (void *)opNC_CHAR);
1372}
1373
1374int
1375nc_put_varm_schar(int ncid, int varid,
1376   const size_t *startp, const size_t *countp,
1377   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1378   const signed char *op)
1379{
1380   NC *ncp;
1381   int stat = NC_check_id(ncid, &ncp);
1382   if(stat != NC_NOERR) return stat;
1383   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1384       (void *)opNC_BYTE);
1385}
1386
1387int
1388nc_put_varm_uchar(int ncid, int varid,
1389   const size_t *startp, const size_t *countp,
1390   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1391   const unsigned char *op)
1392{
1393   NC *ncp;
1394   int stat = NC_check_id(ncid, &ncp);
1395   if(stat != NC_NOERR) return stat;
1396   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1397       (void *)opT_uchar);
1398}
1399
1400int
1401nc_put_varm_short(int ncid, int varid,
1402   const size_t *startp, const size_t *countp,
1403   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1404   const short *op)
1405{
1406   NC *ncp;
1407   int stat = NC_check_id(ncid, &ncp);
1408   if(stat != NC_NOERR) return stat;
1409   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1410       (void *)opNC_SHORT);
1411}
1412
1413int
1414nc_put_varm_int(int ncid, int varid,
1415 const size_t *startp, const size_t *countp,
1416 const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1417 const int *op)
1418{
1419   NC *ncp;
1420   int stat = NC_check_id(ncid, &ncp);
1421   if(stat != NC_NOERR) return stat;
1422   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1423       (void *)opNC_INT);
1424}
1425
1426int
1427nc_put_varm_long(int ncid, int varid,
1428  const size_t *startp, const size_t *countp,
1429  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1430  const long *op)
1431{
1432   NC *ncp;
1433   int stat = NC_check_id(ncid, &ncp);
1434   if(stat != NC_NOERR) return stat;
1435   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1436       (void *)opT_long);
1437}
1438
1439int
1440nc_put_varm_float(int ncid, int varid,
1441   const size_t *startp, const size_t *countp,
1442   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1443   const float *op)
1444{
1445   NC *ncp;
1446   int stat = NC_check_id(ncid, &ncp);
1447   if(stat != NC_NOERR) return stat;
1448   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1449       (void *)opT_float);
1450}
1451
1452int
1453nc_put_varm_double(int ncid, int varid,
1454    const size_t *startp, const size_t *countp,
1455    const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1456    const double *op)
1457{
1458   NC *ncp;
1459   int stat = NC_check_id(ncid, &ncp);
1460   if(stat != NC_NOERR) return stat;
1461   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1462       (void *)opT_double);
1463}
1464
1465int
1466nc_put_varm_ubyte(int ncid, int varid,
1467   const size_t *startp, const size_t *countp,
1468   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1469   const unsigned char *op)
1470{
1471   NC *ncp;
1472   int stat = NC_check_id(ncid, &ncp);
1473   if(stat != NC_NOERR) return stat;
1474   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1475       (void *)opT_ubyte);
1476}
1477
1478int
1479nc_put_varm_ushort(int ncid, int varid,
1480    const size_t *startp, const size_t *countp,
1481    const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1482    const unsigned short *op)
1483{
1484   NC *ncp;
1485   int stat = NC_check_id(ncid, &ncp);
1486   if(stat != NC_NOERR) return stat;
1487   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1488       (void *)opT_ushort);
1489}
1490
1491int
1492nc_put_varm_uint(int ncid, int varid,
1493  const size_t *startp, const size_t *countp,
1494  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1495  const unsigned int *op)
1496{
1497   NC *ncp;
1498   int stat = NC_check_id(ncid, &ncp);
1499   if(stat != NC_NOERR) return stat;
1500   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1501       (void *)opT_uint);
1502}
1503
1504int
1505nc_put_varm_longlong(int ncid, int varid,
1506      const size_t *startp, const size_t *countp,
1507      const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1508      const long long *op)
1509{
1510   NC *ncp;
1511   int stat = NC_check_id(ncid, &ncp);
1512   if(stat != NC_NOERR) return stat;
1513   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1514       (void *)opT_longlong);
1515}
1516
1517int
1518nc_put_varm_ulonglong(int ncid, int varid,
1519       const size_t *startp, const size_t *countp,
1520       const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1521       const unsigned long long *op)
1522{
1523   NC *ncp;
1524   int stat = NC_check_id(ncid, &ncp);
1525   if(stat != NC_NOERR) return stat;
1526   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1527       (void *)opNC_UINT64);
1528}
1529
1530#ifdef USE_NETCDF4
1531int
1532nc_put_varm_string(int ncid, int varid,
1533    const size_t *startp, const size_t *countp,
1534    const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1535    const char**op)
1536{
1537   NC *ncp;
1538   int stat = NC_check_id(ncid, &ncp);
1539   if(stat != NC_NOERR) return stat;
1540   return NC_put_varm(ncidvaridstartpcountpstridepimapp,
1541       (void *)opNC_STRING);
1542}
1543#endif /*USE_NETCDF4*/
1544/**\} */
1545
1546
1547/*! \} */ /*End of named group... */


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed