1/*! \file
2Functions for getting data from variables.
3
4Copyright 2011 University Corporation for Atmospheric
5Research/Unidata. See \ref copyright file for more info.
6
7*/
8
9#include "ncdispatch.h"
10
11#undef VARS_USES_VARM
12#ifndef VARS_USES_VARM
13
14/*!
15  \internal
16
17*/
18struct GETodometer {
19    int            rank;
20    size_t         index[NC_MAX_VAR_DIMS];
21    size_t         start[NC_MAX_VAR_DIMS];
22    size_t         edges[NC_MAX_VAR_DIMS];
23    ptrdiff_t      stride[NC_MAX_VAR_DIMS];
24    size_t         stop[NC_MAX_VAR_DIMS];
25};
26
27
28/** \internal
29
30 */
31static void
32odom_init(struct GETodometerodom,
33     int rank,
34     const size_t* start, const size_t* edges, const ptrdiff_tstride)
35{
36    int i;
37    memset(odom,0,sizeof(struct GETodometer));
38    odom->rank = rank;
39    assert(odom->rank <= NC_MAX_VAR_DIMS);
40    for(i=0;i<odom->rank;i++) {
41 odom->start[i] = (start != NULL ? start[i] : 0);
42 odom->edges[i] = (edges != NULL ? edges[i] : 1);
43 odom->stride[i] = (stride != NULL ? stride[i] : 1);
44 odom->stop[i] = odom->start[i] + (odom->edges[i]*((size_t)odom->stride[i]));
45 odom->index[i] = odom->start[i];
46    }
47}
48
49/** \internal
50
51 */
52static int
53odom_more(struct GETodometerodom)
54{
55    return (odom->index[0] < odom->stop[0]);
56}
57
58/** \internal
59
60 */
61static int
62odom_next(struct GETodometerodom)
63{
64    int i;
65    if(odom->rank == 0) return 0;
66    for(i=odom->rank-1;i>=0;i--) {
67        odom->index[i] += (size_t)odom->stride[i];
68        if(odom->index[i] < odom->stop[i]) break;
69 if(i == 0) return 0; /* leave the 0th entry if it overflows*/
70 odom->index[i] = odom->start[i]; /* reset this position*/
71    }
72    return 1;
73}
74#endif
75
76/** \internal
77\ingroup variables
78
79 */
80int
81NC_get_vara(int ncid, int varid,
82     const size_t *start, const size_t *edges,
83            void *valuenc_type memtype)
84{
85   NCncp;
86   int stat = NC_check_id(ncid, &ncp);
87   if(stat != NC_NOERR) return stat;
88#ifdef USE_NETCDF4
89   if(memtype >= NC_FIRSTUSERTYPEIDmemtype = NC_NAT;
90#endif
91
92   if(edges == NULL) {
93      size_t shape[NC_MAX_VAR_DIMS];
94      int ndims;
95      stat = nc_inq_varndims(ncidvarid, &ndims);
96      if(stat != NC_NOERR) return stat;
97      stat = NC_getshape(ncid,varid,ndims,shape);
98      if(stat != NC_NOERR) return stat;
99      stat = ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
100   } else
101      stat =  ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
102   return stat;
103}
104
105/** \ingroup variables
106\internal
107 */
108static int
109NC_get_var(int ncid, int varid, void *valuenc_type memtype)
110{
111   int ndims;
112   size_t shape[NC_MAX_VAR_DIMS];
113   int stat = nc_inq_varndims(ncid,varid, &ndims);
114   if(stat) return stat;
115   stat = NC_getshape(ncid,varidndimsshape);
116   if(stat) return stat;
117   return NC_get_vara(ncidvaridNC_coord_zeroshapevaluememtype);
118}
119
120/** \internal
121\ingroup variables
122 Most dispatch tables will use the default procedures
123*/
124int
125NCDEFAULT_get_vars(int ncid, int varid, const size_t * start,
126     const size_t * edges, const ptrdiff_t * stride,
127     void *value0nc_type memtype)
128{
129#ifdef VARS_USES_VARM
130   NCncp;
131   int stat = NC_check_id(ncid, &ncp);
132
133   if(stat != NC_NOERR) return stat;
134   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,NULL,value0,memtype);
135#else
136  /* Rebuilt get_vars code to simplify and avoid use of get_varm */
137
138   int status = NC_NOERR;
139   int i,simplestride,isrecvar;
140   int rank;
141   struct GETodometer odom;
142   nc_type vartype = NC_NAT;
143   NCncp;
144   int memtypelen;
145   size_t vartypelen;
146   char* value = (char*)value0;
147   size_t numrecs;
148   size_t varshape[NC_MAX_VAR_DIMS];
149   size_t mystart[NC_MAX_VAR_DIMS];
150   size_t myedges[NC_MAX_VAR_DIMS];
151   ptrdiff_t mystride[NC_MAX_VAR_DIMS];
152   char *memptr = NULL;
153
154   status = NC_check_id (ncid, &ncp);
155   if(status != NC_NOERR) return status;
156
157   status = nc_inq_vartype(ncidvarid, &vartype);
158   if(status != NC_NOERR) return status;
159
160   if(memtype == NC_NATmemtype = vartype;
161
162   /* compute the variable type size */
163   status = nc_inq_type(ncid,vartype,NULL,&vartypelen);
164   if(status != NC_NOERR) return status;
165
166   if(memtype > NC_MAX_ATOMIC_TYPE)
167 memtypelen = (int)vartypelen;
168    else
169 memtypelen = nctypelen(memtype);
170
171   /* Check gross internal/external type compatibility */
172   if(vartype != memtype) {
173      /* If !atomic, the two types must be the same */
174      if(vartype > NC_MAX_ATOMIC_TYPE
175         || memtype > NC_MAX_ATOMIC_TYPE)
176  return NC_EBADTYPE;
177      /* ok, the types differ but both are atomic */
178      if(memtype == NC_CHAR || vartype == NC_CHAR)
179  return NC_ECHAR;
180   }
181
182   /* Get the variable rank */
183   status = nc_inq_varndims(ncidvarid, &rank);
184   if(status != NC_NOERR) return status;
185
186   /* Get variable dimension sizes */
187   isrecvar = NC_is_recvar(ncid,varid,&numrecs);
188   NC_getshape(ncid,varid,rank,varshape);
189
190   /* Optimize out using various checks */
191   if (rank == 0) {
192      /*
193       * The variable is a scalar; consequently,
194       * there s only one thing to get and only one place to put it.
195       * (Why was I called?)
196       */
197      size_t edge1[1] = {1};
198      return NC_get_vara(ncidvaridstartedge1valuememtype);
199   }
200
201   /* Do various checks and fixups on start/edges/stride */
202   simplestride = 1; /* assume so */
203   for(i=0;i<rank;i++) {
204 size_t dimlen;
205 mystart[i] = (start == NULL ? 0 : start[i]);
206 if(edges == NULL) {
207    if(i == 0 && isrecvar)
208         myedges[i] = numrecs - start[i];
209    else
210       myedges[i] = varshape[i] - mystart[i];
211 } else
212     myedges[i] = edges[i];
213 if(myedges[i] == 0)
214     return NC_NOERR; /* cannot read anything */
215 mystride[i] = (stride == NULL ? 1 : stride[i]);
216 if(mystride[i] <= 0
217    /* cast needed for braindead systems with signed size_t */
218           || ((unsigned long) mystride[i] >= X_INT_MAX))
219           return NC_ESTRIDE;
220   if(mystride[i] != 1) simplestride = 0;
221        /* illegal value checks */
222 dimlen = (i == 0 && isrecvar ? numrecs : varshape[i]);
223        /* mystart is unsigned, never < 0 */
224 if(mystart[i] >= dimlen)
225   return NC_EINVALCOORDS;
226        /* myedges is unsigned, never < 0 */
227 if(mystart[i] + myedges[i] > dimlen)
228   return NC_EEDGE;
229   }
230   if(simplestride) {
231      return NC_get_vara(ncidvaridmystartmyedgesvaluememtype);
232   }
233
234   /* memptr indicates where to store the next value */
235   memptr = value;
236
237   odom_init(&odom,rank,mystart,myedges,mystride);
238
239   /* walk the odometer to extract values */
240   while(odom_more(&odom)) {
241      int localstatus = NC_NOERR;
242      /* Read a single value */
243      localstatus = NC_get_vara(ncid,varid,odom.index,nc_sizevector1,memptr,memtype);
244      /* So it turns out that when get_varm is used, all errors are
245         delayed and ERANGE will be overwritten by more serious errors.
246      */
247      if(localstatus != NC_NOERR) {
248     if(status == NC_NOERR || localstatus != NC_ERANGE)
249        status = localstatus;
250      }
251      memptr += memtypelen;
252      odom_next(&odom);
253   }
254   return status;
255#endif
256}
257
258/** \internal
259\ingroup variables
260 */
261static int
262NC_get_var1(int ncid, int varid, const size_t *coord, void* value,
263     nc_type memtype)
264{
265   return NC_get_vara(ncidvaridcoordNC_coord_onevaluememtype);
266}
267
268/** \internal
269\ingroup variables
270 */
271int
272NCDEFAULT_get_varm(int ncid, int varid, const size_t *start,
273     const size_t *edges, const ptrdiff_t *stride,
274     const ptrdiff_t *imapp, void *value0nc_type memtype)
275{
276   int status = NC_NOERR;
277   nc_type vartype = NC_NAT;
278   int varndims,maxidim;
279   NCncp;
280   int memtypelen;
281   char* value = (char*)value0;
282
283   status = NC_check_id (ncid, &ncp);
284   if(status != NC_NOERR) return status;
285
286/*
287  if(NC_indef(ncp)) return NC_EINDEFINE;
288*/
289
290   status = nc_inq_vartype(ncidvarid, &vartype);
291   if(status != NC_NOERR) return status;
292   /* Check that this is an atomic type */
293   if(vartype > NC_MAX_ATOMIC_TYPE)
294 return NC_EMAPTYPE;
295
296   status = nc_inq_varndims(ncidvarid, &varndims);
297   if(status != NC_NOERR) return status;
298
299   if(memtype == NC_NAT) {
300      memtype = vartype;
301   }
302
303   if(memtype == NC_CHAR && vartype != NC_CHAR)
304      return NC_ECHAR;
305   else if(memtype != NC_CHAR && vartype == NC_CHAR)
306      return NC_ECHAR;
307
308   memtypelen = nctypelen(memtype);
309
310   maxidim = (int) varndims - 1;
311
312   if (maxidim < 0)
313   {
314      /*
315       * The variable is a scalar; consequently,
316       * there s only one thing to get and only one place to put it.
317       * (Why was I called?)
318       */
319      size_t edge1[1] = {1};
320      return NC_get_vara(ncidvaridstartedge1valuememtype);
321   }
322
323   /*
324    * else
325    * The variable is an array.
326    */
327   {
328      int idim;
329      size_t *mystart = NULL;
330      size_t *myedges;
331      size_t *iocount;    /* count vector */
332      size_t *stop;   /* stop indexes */
333      size_t *length; /* edge lengths in bytes */
334      ptrdiff_t *mystride;
335      ptrdiff_t *mymap;
336      size_t varshape[NC_MAX_VAR_DIMS];
337      int isrecvar;
338      size_t numrecs;
339
340      /* Compute some dimension related values */
341      isrecvar = NC_is_recvar(ncid,varid,&numrecs);
342      NC_getshape(ncid,varid,varndims,varshape);
343
344      /*
345       * Verify stride argument; also see if stride is all ones
346       */
347      if(stride != NULL) {
348  int stride1 = 1;
349  for (idim = 0; idim <= maxidim; ++idim)
350  {
351            if (stride[idim] == 0
352 /* cast needed for braindead systems with signed size_t */
353                || ((unsigned long) stride[idim] >= X_INT_MAX))
354            {
355        return NC_ESTRIDE;
356            }
357     if(stride[idim] != 1) stride1 = 0;
358  }
359         /* If stride1 is true, and there is no imap
360            then call get_vara directly.
361         */
362         if(stride1 && imapp == NULL) {
363      return NC_get_vara(ncidvaridstartedgesvaluememtype);
364  }
365      }
366
367      /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
368      /* Allocate space for mystart,mystride,mymap etc.all at once */
369      mystart = (size_t *)calloc((size_t)(varndims * 7), sizeof(ptrdiff_t));
370      if(mystart == NULL) return NC_ENOMEM;
371      myedges = mystart + varndims;
372      iocount = myedges + varndims;
373      stop = iocount + varndims;
374      length = stop + varndims;
375      mystride = (ptrdiff_t *)(length + varndims);
376      mymap = mystride + varndims;
377
378      /*
379       * Initialize I/O parameters.
380       */
381      for (idim = maxidimidim >= 0; --idim)
382      {
383  mystart[idim] = start != NULL
384     ? start[idim]
385     : 0;
386
387  if (edges != NULL && edges[idim] == 0)
388  {
389     status = NC_NOERR;    /* read/write no data */
390     goto done;
391  }
392
393#ifdef COMPLEX
394  myedges[idim] = edges != NULL
395     ? edges[idim]
396     : idim == 0 && isrecvar
397     ? numrecs - mystart[idim]
398     : varshape[idim] - mystart[idim];
399#else
400  if(edges != NULL)
401     myedges[idim] = edges[idim];
402  else if (idim == 0 && isrecvar)
403     myedges[idim] = numrecs - mystart[idim];
404  else
405     myedges[idim] = varshape[idim] - mystart[idim];
406#endif
407
408  mystride[idim] = stride != NULL
409     ? stride[idim]
410     : 1;
411
412  /* Remember: in netCDF-2 imapp is byte oriented, not index oriented
413   *           Starting from netCDF-3, imapp is index oriented */
414#ifdef COMPLEX
415  mymap[idim] = (imapp != NULL
416imapp[idim]
417 : (idim == maxidim ? 1
418    : mymap[idim + 1] * (ptrdiff_tmyedges[idim + 1]));
419#else
420  if(imapp != NULL)
421     mymap[idim] = imapp[idim];
422  else if (idim == maxidim)
423     mymap[idim] = 1;
424  else
425     mymap[idim] =
426        mymap[idim + 1] * (ptrdiff_tmyedges[idim + 1];
427#endif
428  iocount[idim] = 1;
429  length[idim] = ((size_t)mymap[idim]) * myedges[idim];
430  stop[idim] = (mystart[idim] + myedges[idim] * (size_t)mystride[idim]);
431      }
432
433      /*
434       * Check start, edges
435       */
436      for (idim = maxidimidim >= 0; --idim)
437      {
438  size_t dimlen =
439     idim == 0 && isrecvar
440     ? numrecs
441     : varshape[idim];
442  if (mystart[idim] >= dimlen)
443  {
444     status = NC_EINVALCOORDS;
445     goto done;
446  }
447
448  if (mystart[idim] + myedges[idim] > dimlen)
449  {
450     status = NC_EEDGE;
451     goto done;
452  }
453
454      }
455
456
457      /* Lower body */
458      /*
459       * As an optimization, adjust I/O parameters when the fastest
460       * dimension has unity stride both externally and internally.
461       * In this case, the user could have called a simpler routine
462       * (i.e. ncvar$1()
463       */
464      if (mystride[maxidim] == 1
465   && mymap[maxidim] == 1)
466      {
467  iocount[maxidim] = myedges[maxidim];
468  mystride[maxidim] = (ptrdiff_tmyedges[maxidim];
469  mymap[maxidim] = (ptrdiff_tlength[maxidim];
470      }
471
472      /*
473       * Perform I/O.  Exit when done.
474       */
475      for (;;)
476      {
477  /* TODO: */
478  int lstatus = NC_get_vara(ncidvaridmystartiocount,
479    valuememtype);
480  if (lstatus != NC_NOERR) {
481     if(status == NC_NOERR || lstatus != NC_ERANGE)
482        status = lstatus;
483  }
484  /*
485   * The following code permutes through the variable s
486   * external start-index space and it s internal address
487   * space.  At the UPC, this algorithm is commonly
488   * called "odometer code".
489   */
490  idim = maxidim;
491        carry:
492  value += (((int)mymap[idim]) * memtypelen);
493  mystart[idim] += (size_t)mystride[idim];
494  if (mystart[idim] == stop[idim])
495  {
496     size_t l = (length[idim] * (size_t)memtypelen);
497     value -= l;
498     mystart[idim] = start[idim];
499     if (--idim < 0)
500        break; /* normal return */
501     goto carry;
502  }
503      } /* I/O loop */
504     done:
505      free(mystart);
506   } /* variable is array */
507   return status;
508}
509
510/** \ingroup variables
511\internal
512Called by externally visible nc_get_vars_xxx routines */
513static int
514NC_get_vars(int ncid, int varid, const size_t *start,
515     const size_t *edges, const ptrdiff_t *stride, void *value,
516     nc_type memtype)
517{
518   NCncp;
519   int stat = NC_check_id(ncid, &ncp);
520
521   if(stat != NC_NOERR) return stat;
522#ifdef USE_NETCDF4
523   if(memtype >= NC_FIRSTUSERTYPEIDmemtype = NC_NAT;
524#endif
525   return ncp->dispatch->get_vars(ncid,varid,start,edges,stride,value,memtype);
526}
527
528/** \ingroup variables
529\internal
530Called by externally visible nc_get_varm_xxx routines
531 */
532static int
533NC_get_varm(int ncid, int varid, const size_t *start,
534     const size_t *edges, const ptrdiff_t *stride, const ptrdiff_tmap,
535     void *valuenc_type memtype)
536{
537   NCncp;
538   int stat = NC_check_id(ncid, &ncp);
539
540   if(stat != NC_NOERR) return stat;
541#ifdef USE_NETCDF4
542   if(memtype >= NC_FIRSTUSERTYPEIDmemtype = NC_NAT;
543#endif
544   return ncp->dispatch->get_varm(ncid,varid,start,edges,stride,map,value,memtype);
545}
546
547/** \name Reading Data from Variables
548
549Functions to read data from variables. */
550/*! \{ */ /* All these functions are part of this named group... */
551
552/** \ingroup variables
553Read an array of values from a variable.
554
555The array to be read is specified by giving a corner and a vector of
556edge lengths to \ref specify_hyperslab.
557
558The data values are read into consecutive locations with the last
559dimension varying fastest. The netCDF dataset must be in data mode
560(for netCDF-4/HDF5 files, the switch to data mode will happen
561automatically, unless the classic model is used).
562
563The nc_get_vara() function will read a variable of any type,
564including user defined type. For this function, the type of the data
565in memory must match the type of the variable - no data conversion is
566done.
567
568Other nc_get_vara_ functions will convert data to the desired output
569type as needed.
570
571\param ncid NetCDF or group ID, from a previous call to nc_open(),
572nc_create(), nc_def_grp(), or associated inquiry functions such as
573nc_inq_ncid().
574
575\param varid Variable ID
576
577\param startp Start vector with one element for each dimension to \ref
578specify_hyperslab.
579
580\param countp Count vector with one element for each dimension to \ref
581specify_hyperslab.
582
583\param ip Pointer where the data will be copied. Memory must be
584allocated by the user before this function is called.
585
586\returns ::NC_NOERR No error.
587\returns ::NC_ENOTVAR Variable not found.
588\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
589\returns ::NC_EEDGE Start+count exceeds dimension bound.
590\returns ::NC_ERANGE One or more of the values are out of range.
591\returns ::NC_EINDEFINE Operation not allowed in define mode.
592\returns ::NC_EBADID Bad ncid.
593
594\section nc_get_vara_double_example Example
595
596Here is an example using nc_get_vara_double() to read all the values of
597the variable named rh from an existing netCDF dataset named
598foo.nc. For simplicity in this example, we assume that we know that rh
599is dimensioned with time, lat, and lon, and that there are three time
600values, five lat values, and ten lon values.
601
602\code
603     #include <netcdf.h>
604        ...
605     #define TIMES 3
606     #define LATS 5
607     #define LONS 10
608     int  status;
609     int ncid;
610     int rh_id;
611     static size_t start[] = {0, 0, 0};
612     static size_t count[] = {TIMES, LATS, LONS};
613     double rh_vals[TIMES*LATS*LONS];
614        ...
615     status = nc_open("foo.nc", NC_NOWRITE, &ncid);
616     if (status != NC_NOERR) handle_error(status);
617        ...
618     status = nc_inq_varid (ncid, "rh", &rh_id);
619     if (status != NC_NOERR) handle_error(status);
620        ...
621     status = nc_get_vara_double(ncid, rh_id, start, count, rh_vals);
622     if (status != NC_NOERR) handle_error(status);
623\endcode
624 */
625/**@{*/
626int
627nc_get_vara(int ncid, int varid, const size_t *startp,
628     const size_t *countp, void *ip)
629{
630   NCncp = NULL;
631   nc_type xtype = NC_NAT;
632   int stat = NC_check_id(ncid, &ncp);
633   if(stat != NC_NOERR) return stat;
634   stat = nc_inq_vartype(ncidvarid, &xtype);
635   if(stat != NC_NOERR) return stat;
636   return NC_get_vara(ncidvaridstartpcountpipxtype);
637}
638
639int
640nc_get_vara_text(int ncid, int varid, const size_t *startp,
641  const size_t *countp, char *ip)
642{
643   NCncp;
644   int stat = NC_check_id(ncid, &ncp);
645   if(stat != NC_NOERR) return stat;
646   return NC_get_vara(ncidvaridstartpcountp,
647       (void *)ipNC_CHAR);
648}
649
650int
651nc_get_vara_schar(int ncid, int varid, const size_t *startp,
652   const size_t *countp, signed char *ip)
653{
654   NCncp;
655   int stat = NC_check_id(ncid, &ncp);
656   if(stat != NC_NOERR) return stat;
657   return NC_get_vara(ncidvaridstartpcountp,
658       (void *)ipNC_BYTE);
659}
660
661int
662nc_get_vara_uchar(int ncid, int varid, const size_t *startp,
663   const size_t *countp, unsigned char *ip)
664{
665   NCncp;
666   int stat = NC_check_id(ncid, &ncp);
667   if(stat != NC_NOERR) return stat;
668   return NC_get_vara(ncidvaridstartpcountp,
669       (void *)ipT_uchar);
670}
671
672int
673nc_get_vara_short(int ncid, int varid, const size_t *startp,
674   const size_t *countp, short *ip)
675{
676   NCncp;
677   int stat = NC_check_id(ncid, &ncp);
678   if(stat != NC_NOERR) return stat;
679   return NC_get_vara(ncidvaridstartpcountp,
680       (void *)ipNC_SHORT);
681}
682
683int
684nc_get_vara_int(int ncid, int varid,
685 const size_t *startp, const size_t *countp, int *ip)
686{
687   NCncp;
688   int stat = NC_check_id(ncid, &ncp);
689   if(stat != NC_NOERR) return stat;
690   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_INT);
691}
692
693int
694nc_get_vara_long(int ncid, int varid,
695  const size_t *startp, const size_t *countp, long *ip)
696{
697   NCncp;
698   int stat = NC_check_id(ncid, &ncp);
699   if(stat != NC_NOERR) return stat;
700   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_long);
701}
702
703int
704nc_get_vara_float(int ncid, int varid,
705   const size_t *startp, const size_t *countp, float *ip)
706{
707   NCncp;
708   int stat = NC_check_id(ncid, &ncp);
709   if(stat != NC_NOERR) return stat;
710   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_float);
711}
712
713
714int
715nc_get_vara_double(int ncid, int varid, const size_t *startp,
716    const size_t *countp, double *ip)
717{
718   NCncp;
719   int stat = NC_check_id(ncid, &ncp);
720   if(stat != NC_NOERR) return stat;
721   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_double);
722}
723
724int
725nc_get_vara_ubyte(int ncid, int varid,
726   const size_t *startp, const size_t *countp, unsigned char *ip)
727{
728   NCncp;
729   int stat = NC_check_id(ncid, &ncp);
730   if(stat != NC_NOERR) return stat;
731   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_ubyte);
732}
733
734int
735nc_get_vara_ushort(int ncid, int varid,
736    const size_t *startp, const size_t *countp, unsigned short *ip)
737{
738   NCncp;
739   int stat = NC_check_id(ncid, &ncp);
740   if(stat != NC_NOERR) return stat;
741   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_ushort);
742}
743
744int
745nc_get_vara_uint(int ncid, int varid,
746  const size_t *startp, const size_t *countp, unsigned int *ip)
747{
748   NCncp;
749   int stat = NC_check_id(ncid, &ncp);
750   if(stat != NC_NOERR) return stat;
751   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_uint);
752}
753
754int
755nc_get_vara_longlong(int ncid, int varid,
756      const size_t *startp, const size_t *countp, long long *ip)
757{
758   NCncp;
759   int stat = NC_check_id(ncid, &ncp);
760   if(stat != NC_NOERR) return stat;
761   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,T_longlong);
762}
763
764int
765nc_get_vara_ulonglong(int ncid, int varid,
766       const size_t *startp, const size_t *countp, unsigned long long *ip)
767{
768   NCncp;
769   int stat = NC_check_id(ncid, &ncp);
770   if(stat != NC_NOERR) return stat;
771   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_UINT64);
772}
773
774#ifdef USE_NETCDF4
775int
776nc_get_vara_string(int ncid, int varid,
777    const size_t *startp, const size_t *countp, char* *ip)
778{
779   NCncp;
780   int stat = NC_check_id(ncid, &ncp);
781   if(stat != NC_NOERR) return stat;
782   return NC_get_vara(ncid,varid,startp,countp, (void *)ip,NC_STRING);
783}
784
785#endif /*USE_NETCDF4*/
786/**@}*/
787
788/** \ingroup variables
789Read a single datum from a variable.
790
791Inputs are the netCDF ID, the variable ID, a multidimensional index
792that specifies which value to get, and the address of a location into
793which the data value will be read. The value is converted from the
794external data type of the variable, if necessary.
795
796The nc_get_var1() function will read a variable of any type, including
797user defined type. For this function, the type of the data in memory
798must match the type of the variable - no data conversion is done.
799
800Other nc_get_var1_ functions will convert data to the desired output
801type as needed.
802
803\param ncid NetCDF or group ID, from a previous call to nc_open(),
804nc_create(), nc_def_grp(), or associated inquiry functions such as
805nc_inq_ncid().
806
807\param varid Variable ID
808
809\param indexp Index vector with one element for each dimension.
810
811\param ip Pointer where the data will be copied. Memory must be
812allocated by the user before this function is called.
813
814\returns ::NC_NOERR No error.
815\returns ::NC_ENOTVAR Variable not found.
816\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
817\returns ::NC_ERANGE One or more of the values are out of range.
818\returns ::NC_EINDEFINE Operation not allowed in define mode.
819\returns ::NC_EBADID Bad ncid.
820*/
821/** \{ */
822int
823nc_get_var1(int ncid, int varid, const size_t *indexp, void *ip)
824{
825   return NC_get_var1(ncidvaridindexpipNC_NAT);
826}
827
828int
829nc_get_var1_text(int ncid, int varid, const size_t *indexp, char *ip)
830{
831   NCncp;
832   int stat = NC_check_id(ncid, &ncp);
833   if(stat != NC_NOERR) return stat;
834   return NC_get_var1(ncidvaridindexp, (void *)ipNC_CHAR);
835}
836
837int
838nc_get_var1_schar(int ncid, int varid, const size_t *indexp, signed char *ip)
839{
840   NCncp;
841   int stat = NC_check_id(ncid, &ncp);
842   if(stat != NC_NOERR) return stat;
843   return NC_get_var1(ncidvaridindexp, (void *)ipNC_BYTE);
844}
845
846int
847nc_get_var1_uchar(int ncid, int varid, const size_t *indexp, unsigned char *ip)
848{
849   NCncp;
850   int stat = NC_check_id(ncid, &ncp);
851   if(stat != NC_NOERR) return stat;
852   return NC_get_var1(ncidvaridindexp, (void *)ipNC_UBYTE);
853}
854
855int
856nc_get_var1_short(int ncid, int varid, const size_t *indexp, short *ip)
857{
858   NCncp;
859   int stat = NC_check_id(ncid, &ncp);
860   if(stat != NC_NOERR) return stat;
861   return NC_get_var1(ncidvaridindexp, (void *)ipNC_SHORT);
862}
863
864int
865nc_get_var1_int(int ncid, int varid, const size_t *indexp, int *ip)
866{
867   NCncp;
868   int stat = NC_check_id(ncid, &ncp);
869   if(stat != NC_NOERR) return stat;
870   return NC_get_var1(ncidvaridindexp, (void *)ipNC_INT);
871}
872
873int
874nc_get_var1_long(int ncid, int varid, const size_t *indexp,
875  long *ip)
876{
877   NCncp;
878   int stat = NC_check_id(ncid, &ncp);
879   if(stat != NC_NOERR) return stat;
880   return NC_get_var1(ncidvaridindexp, (void *)iplongtype);
881}
882
883int
884nc_get_var1_float(int ncid, int varid, const size_t *indexp,
885   float *ip)
886{
887   NCncp;
888   int stat = NC_check_id(ncid, &ncp);
889   if(stat != NC_NOERR) return stat;
890   return NC_get_var1(ncidvaridindexp, (void *)ipNC_FLOAT);
891}
892
893int
894nc_get_var1_double(int ncid, int varid, const size_t *indexp,
895    double *ip)
896{
897   NCncp;
898   int stat = NC_check_id(ncid, &ncp);
899   if(stat != NC_NOERR) return stat;
900   return NC_get_var1(ncidvaridindexp, (void *)ipNC_DOUBLE);
901}
902
903int
904nc_get_var1_ubyte(int ncid, int varid, const size_t *indexp,
905   unsigned char *ip)
906{
907   NCncp;
908   int stat = NC_check_id(ncid, &ncp);
909   if(stat != NC_NOERR) return stat;
910   return NC_get_var1(ncidvaridindexp, (void *)ipNC_UBYTE);
911}
912
913int
914nc_get_var1_ushort(int ncid, int varid, const size_t *indexp,
915    unsigned short *ip)
916{
917   NCncp;
918   int stat = NC_check_id(ncid, &ncp);
919   if(stat != NC_NOERR) return stat;
920   return NC_get_var1(ncidvaridindexp, (void *)ipNC_USHORT);
921}
922
923int
924nc_get_var1_uint(int ncid, int varid, const size_t *indexp,
925  unsigned int *ip)
926{
927   NCncp;
928   int stat = NC_check_id(ncid, &ncp);
929   if(stat != NC_NOERR) return stat;
930   return NC_get_var1(ncidvaridindexp, (void *)ipNC_UINT);
931}
932
933int
934nc_get_var1_longlong(int ncid, int varid, const size_t *indexp,
935      long long *ip)
936{
937   NCncp;
938   int stat = NC_check_id(ncid, &ncp);
939   if(stat != NC_NOERR) return stat;
940   return NC_get_var1(ncidvaridindexp, (void *)ipNC_INT64);
941}
942
943int
944nc_get_var1_ulonglong(int ncid, int varid, const size_t *indexp,
945       unsigned long long *ip)
946{
947   NCncp;
948   int stat = NC_check_id(ncid, &ncp);
949   if(stat != NC_NOERR) return stat;
950   return NC_get_var1(ncidvaridindexp, (void *)ipNC_UINT64);
951}
952
953#ifdef USE_NETCDF4
954int
955nc_get_var1_string(int ncid, int varid, const size_t *indexp, char* *ip)
956{
957   NCncp;
958   int stat = NC_check_id(ncid, &ncp);
959   if(stat != NC_NOERR) return stat;
960   return NC_get_var1(ncidvaridindexp, (void *)ipNC_STRING);
961}
962#endif /*USE_NETCDF4*/
963/** \} */
964
965/** \ingroup variables
966Read an entire variable in one call.
967
968This function will read all the values from a netCDF variable of an
969open netCDF dataset.
970
971This is the simplest interface to use for reading the value of a
972scalar variable or when all the values of a multidimensional variable
973can be read at once. The values are read into consecutive locations
974with the last dimension varying fastest. The netCDF dataset must be in
975data mode.
976
977Take care when using this function with record variables (variables
978that use the ::NC_UNLIMITED dimension). If you try to read all the
979values of a record variable into an array but there are more records
980in the file than you assume, more data will be read than you expect,
981which may cause a segmentation violation. To avoid such problems, it
982is better to use the nc_get_vara interfaces for variables that use the
983::NC_UNLIMITED dimension.
984
985The functions for types ubyte, ushort, uint, longlong, ulonglong, and
986string are only available for netCDF-4/HDF5 files.
987
988The nc_get_var() function will read a variable of any type, including
989user defined type. For this function, the type of the data in memory
990must match the type of the variable - no data conversion is done.
991
992\param ncid NetCDF or group ID, from a previous call to nc_open(),
993nc_create(), nc_def_grp(), or associated inquiry functions such as
994nc_inq_ncid().
995
996\param varid Variable ID
997
998\param ip Pointer where the data will be copied. Memory must be
999allocated by the user before this function is called.
1000
1001\returns ::NC_NOERR No error.
1002\returns ::NC_ENOTVAR Variable not found.
1003\returns ::NC_ERANGE One or more of the values are out of range.
1004\returns ::NC_EINDEFINE Operation not allowed in define mode.
1005\returns ::NC_EBADID Bad ncid.
1006*/
1007/** \{ */
1008int
1009nc_get_var(int ncid, int varid, void *ip)
1010{
1011   return NC_get_var(ncidvaridipNC_NAT);
1012}
1013
1014int
1015nc_get_var_text(int ncid, int varid, char *ip)
1016{
1017   NC *ncp;
1018   int stat = NC_check_id(ncid, &ncp);
1019   if(stat != NC_NOERR) return stat;
1020   return NC_get_var(ncidvarid, (void *)ipNC_CHAR);
1021}
1022
1023int
1024nc_get_var_schar(int ncid, int varid, signed char *ip)
1025{
1026   NC *ncp;
1027   int stat = NC_check_id(ncid, &ncp);
1028   if(stat != NC_NOERR) return stat;
1029   return NC_get_var(ncidvarid, (void *)ipNC_BYTE);
1030}
1031
1032int
1033nc_get_var_uchar(int ncid, int varid, unsigned char *ip)
1034{
1035   NC *ncp;
1036   int stat = NC_check_id(ncid, &ncp);
1037   if(stat != NC_NOERR) return stat;
1038   return NC_get_var(ncid,varid, (void *)ipNC_UBYTE);
1039}
1040
1041int
1042nc_get_var_short(int ncid, int varid, short *ip)
1043{
1044   NCncp;
1045   int stat = NC_check_id(ncid, &ncp);
1046   if(stat != NC_NOERR) return stat;
1047   return NC_get_var(ncidvarid, (void *)ipNC_SHORT);
1048}
1049
1050int
1051nc_get_var_int(int ncid, int varid, int *ip)
1052{
1053   NCncp;
1054   int stat = NC_check_id(ncid, &ncp);
1055   if(stat != NC_NOERR) return stat;
1056   return NC_get_var(ncid,varid, (void *)ipNC_INT);
1057}
1058
1059int
1060nc_get_var_long(int ncid, int varid, long *ip)
1061{
1062   NCncp;
1063   int stat = NC_check_id(ncid, &ncp);
1064   if(stat != NC_NOERR) return stat;
1065   return NC_get_var(ncid,varid, (void *)iplongtype);
1066}
1067
1068int
1069nc_get_var_float(int ncid, int varid, float *ip)
1070{
1071   NCncp;
1072   int stat = NC_check_id(ncid, &ncp);
1073   if(stat != NC_NOERR) return stat;
1074   return NC_get_var(ncid,varid, (void *)ipNC_FLOAT);
1075}
1076
1077int
1078nc_get_var_double(int ncid, int varid, double *ip)
1079{
1080   NCncp;
1081   int stat = NC_check_id(ncid, &ncp);
1082   if(stat != NC_NOERR) return stat;
1083   return NC_get_var(ncid,varid, (void *)ipNC_DOUBLE);
1084}
1085
1086int
1087nc_get_var_ubyte(int ncid, int varid, unsigned char *ip)
1088{
1089   NCncp;
1090   int stat = NC_check_id(ncid, &ncp);
1091   if(stat != NC_NOERR) return stat;
1092   return NC_get_var(ncid,varid, (void *)ipNC_UBYTE);
1093}
1094
1095int
1096nc_get_var_ushort(int ncid, int varid, unsigned short *ip)
1097{
1098   NCncp;
1099   int stat = NC_check_id(ncid, &ncp);
1100   if(stat != NC_NOERR) return stat;
1101   return NC_get_var(ncid,varid, (void *)ipNC_USHORT);
1102}
1103
1104int
1105nc_get_var_uint(int ncid, int varid, unsigned int *ip)
1106{
1107   NCncp;
1108   int stat = NC_check_id(ncid, &ncp);
1109   if(stat != NC_NOERR) return stat;
1110   return NC_get_var(ncid,varid, (void *)ipNC_UINT);
1111}
1112
1113int
1114nc_get_var_longlong(int ncid, int varid, long long *ip)
1115{
1116   NCncp;
1117   int stat = NC_check_id(ncid, &ncp);
1118   if(stat != NC_NOERR) return stat;
1119   return NC_get_var(ncid,varid, (void *)ipNC_INT64);
1120}
1121
1122int
1123nc_get_var_ulonglong(int ncid, int varid, unsigned long long *ip)
1124{
1125   NCncp;
1126   int stat = NC_check_id(ncid, &ncp);
1127   if(stat != NC_NOERR) return stat;
1128   return NC_get_var(ncid,varid, (void *)ip,NC_UINT64);
1129}
1130
1131#ifdef USE_NETCDF4
1132int
1133nc_get_var_string(int ncid, int varid, char* *ip)
1134{
1135   NCncp;
1136   int stat = NC_check_id(ncid, &ncp);
1137   if(stat != NC_NOERR) return stat;
1138   return NC_get_var(ncid,varid, (void *)ip,NC_STRING);
1139}
1140#endif /*USE_NETCDF4*/
1141/** \} */
1142
1143/** \ingroup variables
1144Read a strided array from a variable.
1145
1146This function reads a subsampled (strided) array section of values
1147from a netCDF variable of an open netCDF dataset. The subsampled array
1148section is specified by giving a corner, a vector of edge lengths, and
1149a stride vector. The values are read with the last dimension of the
1150netCDF variable varying fastest. The netCDF dataset must be in data
1151mode.
1152
1153The nc_get_vars() function will read a variable of any type, including
1154user defined type. For this function, the type of the data in memory
1155must match the type of the variable - no data conversion is done.
1156
1157\param ncid NetCDF or group ID, from a previous call to nc_open(),
1158nc_create(), nc_def_grp(), or associated inquiry functions such as
1159nc_inq_ncid().
1160
1161\param varid Variable ID
1162
1163\param startp Start vector with one element for each dimension to \ref
1164specify_hyperslab.
1165
1166\param countp Count vector with one element for each dimension to \ref
1167specify_hyperslab.
1168
1169\param stridep Stride vector with one element for each dimension to
1170\ref specify_hyperslab.
1171
1172\param ip Pointer where the data will be copied. Memory must be
1173allocated by the user before this function is called.
1174
1175\returns ::NC_NOERR No error.
1176\returns ::NC_ENOTVAR Variable not found.
1177\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
1178\returns ::NC_ERANGE One or more of the values are out of range.
1179\returns ::NC_EINDEFINE Operation not allowed in define mode.
1180\returns ::NC_EBADID Bad ncid.
1181*/
1182/** \{ */
1183int
1184nc_get_vars (int ncid, int varid, const size_t * startp,
1185      const size_t * countp, const ptrdiff_t * stridep,
1186      void *ip)
1187{
1188   NCncp;
1189   int stat = NC_NOERR;
1190
1191   if ((stat = NC_check_id(ncid, &ncp)))
1192       return stat;
1193   return ncp->dispatch->get_vars(ncidvaridstartpcountpstridep,
1194       ipNC_NAT);
1195}
1196
1197int
1198nc_get_vars_text(int ncid, int varid, const size_t *startp,
1199  const size_t *countp, const ptrdiff_t * stridep,
1200  char *ip)
1201{
1202   NCncp;
1203   int stat = NC_check_id(ncid, &ncp);
1204   if(stat != NC_NOERR) return stat;
1205   return NC_get_vars(ncid,varid,startpcountpstridep,
1206       (void *)ipNC_CHAR);
1207}
1208
1209int
1210nc_get_vars_schar(int ncid, int varid, const size_t *startp,
1211   const size_t *countp, const ptrdiff_t * stridep,
1212   signed char *ip)
1213{
1214   NCncp;
1215   int stat = NC_check_id(ncid, &ncp);
1216   if(stat != NC_NOERR) return stat;
1217   return NC_get_vars(ncid,varid,startpcountpstridep,
1218       (void *)ipNC_BYTE);
1219}
1220
1221int
1222nc_get_vars_uchar(int ncid, int varid, const size_t *startp,
1223   const size_t *countp, const ptrdiff_t * stridep,
1224   unsigned char *ip)
1225{
1226   NCncp;
1227   int stat = NC_check_id(ncid, &ncp);
1228   if(stat != NC_NOERR) return stat;
1229   return NC_get_vars(ncid,varid,startpcountpstridep,
1230       (void *)ipT_uchar);
1231}
1232
1233int
1234nc_get_vars_short(int ncid, int varid, const size_t *startp,
1235   const size_t *countp, const ptrdiff_t *stridep,
1236   short *ip)
1237{
1238   NCncp;
1239   int stat = NC_check_id(ncid, &ncp);
1240   if(stat != NC_NOERR) return stat;
1241   return NC_get_vars(ncid,varid,startpcountpstridep,
1242       (void *)ipNC_SHORT);
1243}
1244
1245int
1246nc_get_vars_int(int ncid, int varid, const size_t *startp,
1247 const size_t *countp, const ptrdiff_t * stridep,
1248 int *ip)
1249{
1250   NCncp;
1251   int stat = NC_check_id(ncid, &ncp);
1252   if(stat != NC_NOERR) return stat;
1253   return NC_get_vars(ncid,varid,startpcountpstridep,
1254       (void *)ipNC_INT);
1255}
1256
1257int
1258nc_get_vars_long(int ncid, int varid, const size_t *startp,
1259  const size_t *countp, const ptrdiff_t * stridep,
1260  long *ip)
1261{
1262   NCncp;
1263   int stat = NC_check_id(ncid, &ncp);
1264   if(stat != NC_NOERR) return stat;
1265   return NC_get_vars(ncid,varid,startpcountpstridep,
1266       (void *)ipT_long);
1267}
1268
1269int
1270nc_get_vars_float(int ncid, int varid, const size_t *startp,
1271   const size_t *countp, const ptrdiff_t * stridep,
1272   float *ip)
1273{
1274   NCncp;
1275   int stat = NC_check_id(ncid, &ncp);
1276   if(stat != NC_NOERR) return stat;
1277   return NC_get_vars(ncid,varid,startpcountpstridep,
1278       (void *)ipT_float);
1279}
1280
1281int
1282nc_get_vars_double(int ncid, int varid, const size_t *startp,
1283    const size_t *countp, const ptrdiff_t * stridep,
1284    double *ip)
1285{
1286   NCncp;
1287   int stat = NC_check_id(ncid, &ncp);
1288   if(stat != NC_NOERR) return stat;
1289   return NC_get_vars(ncid,varid,startpcountpstridep,
1290       (void *)ipT_double);
1291}
1292
1293int
1294nc_get_vars_ubyte(int ncid, int varid, const size_t *startp,
1295   const size_t *countp, const ptrdiff_t * stridep,
1296   unsigned char *ip)
1297{
1298   NCncp;
1299   int stat = NC_check_id(ncid, &ncp);
1300   if(stat != NC_NOERR) return stat;
1301   return NC_get_vars(ncid,varidstartpcountpstridep,
1302       (void *)ipT_ubyte);
1303}
1304
1305int
1306nc_get_vars_ushort(int ncid, int varid, const size_t *startp,
1307    const size_t *countp, const ptrdiff_t * stridep,
1308    unsigned short *ip)
1309{
1310   NCncp;
1311   int stat = NC_check_id(ncid, &ncp);
1312   if(stat != NC_NOERR) return stat;
1313   return NC_get_vars(ncid,varid,startp,countpstridep,
1314       (void *)ipT_ushort);
1315}
1316
1317int
1318nc_get_vars_uint(int ncid, int varid, const size_t *startp,
1319  const size_t *countp, const ptrdiff_t * stridep,
1320  unsigned int *ip)
1321{
1322   NCncp;
1323   int stat = NC_check_id(ncid, &ncp);
1324   if(stat != NC_NOERR) return stat;
1325   return NC_get_vars(ncid,varid,startpcountpstridep,
1326       (void *)ipT_uint);
1327}
1328
1329int
1330nc_get_vars_longlong(int ncid, int varid, const size_t *startp,
1331      const size_t *countp, const ptrdiff_t * stridep,
1332      long long *ip)
1333{
1334   NCncp;
1335   int stat = NC_check_id(ncid, &ncp);
1336   if(stat != NC_NOERR) return stat;
1337   return NC_get_vars(ncidvaridstartpcountpstridep,
1338       (void *)ipT_longlong);
1339}
1340
1341int
1342nc_get_vars_ulonglong(int ncid, int varid, const size_t *startp,
1343       const size_t *countp, const ptrdiff_t * stridep,
1344       unsigned long long *ip)
1345{
1346   NCncp;
1347   int stat = NC_check_id(ncid, &ncp);
1348   if(stat != NC_NOERR) return stat;
1349   return NC_get_vars(ncidvaridstartpcountpstridep,
1350       (void *)ipNC_UINT64);
1351}
1352
1353#ifdef USE_NETCDF4
1354int
1355nc_get_vars_string(int ncid, int varid,
1356    const size_t *startp, const size_t *countp,
1357    const ptrdiff_t * stridep,
1358    char* *ip)
1359{
1360   NCncp;
1361   int stat = NC_check_id(ncid, &ncp);
1362   if(stat != NC_NOERR) return stat;
1363   return NC_get_vars(ncidvaridstartpcountpstridep,
1364       (void *)ipNC_STRING);
1365}
1366#endif /*USE_NETCDF4*/
1367/** \} */
1368
1369/** \ingroup variables
1370Read a mapped array from a variable.
1371
1372The nc_get_varm_ type family of functions reads a mapped array section
1373of values from a netCDF variable of an open netCDF dataset. The mapped
1374array section is specified by giving a corner, a vector of edge
1375lengths, a stride vector, and an index mapping vector. The index
1376mapping vector is a vector of integers that specifies the mapping
1377between the dimensions of a netCDF variable and the in-memory
1378structure of the internal data array. No assumptions are made about
1379the ordering or length of the dimensions of the data array. The netCDF
1380dataset must be in data mode.
1381
1382The functions for types ubyte, ushort, uint, longlong, ulonglong, and
1383string are only available for netCDF-4/HDF5 files.
1384
1385The nc_get_varm() function will only read a variable of an
1386atomic type; it will not read user defined types. For this
1387function, the type of the data in memory must match the type
1388of the variable - no data conversion is done.
1389
1390@deprecated Use of this family of functions is discouraged,
1391although it will continue to be supported.
1392The reason is the complexity of the
1393algorithm makes its use difficult for users to properly use.
1394
1395\param ncid NetCDF or group ID, from a previous call to nc_open(),
1396nc_create(), nc_def_grp(), or associated inquiry functions such as
1397nc_inq_ncid().
1398
1399\param varid Variable ID
1400
1401\param startp Start vector with one element for each dimension to \ref
1402specify_hyperslab.
1403
1404\param countp Count vector with one element for each dimension to \ref
1405specify_hyperslab.
1406
1407\param stridep Stride vector with one element for each dimension to
1408\ref specify_hyperslab.
1409
1410\param imapp Mapping vector with one element for each dimension to
1411\ref specify_hyperslab.
1412
1413\param ip Pointer where the data will be copied. Memory must be
1414allocated by the user before this function is called.
1415
1416\returns ::NC_NOERR No error.
1417\returns ::NC_ENOTVAR Variable not found.
1418\returns ::NC_EINVALCOORDS Index exceeds dimension bound.
1419\returns ::NC_ERANGE One or more of the values are out of range.
1420\returns ::NC_EINDEFINE Operation not allowed in define mode.
1421\returns ::NC_EBADID Bad ncid.
1422*/
1423/** \{ */
1424int
1425nc_get_varm(int ncid, int varid, const size_t * startp,
1426     const size_t * countp, const ptrdiff_t * stridep,
1427     const ptrdiff_t * imapp, void *ip)
1428{
1429   NCncp;
1430   int stat = NC_NOERR;
1431
1432   if ((stat = NC_check_id(ncid, &ncp)))
1433       return stat;
1434   return ncp->dispatch->get_varm(ncidvaridstartpcountp,
1435   stridepimappipNC_NAT);
1436}
1437
1438int
1439nc_get_varm_schar(int ncid, int varid,
1440   const size_t *startp, const size_t *countp,
1441   const ptrdiff_t *stridep,
1442   const ptrdiff_t *imapp, signed char *ip)
1443{
1444   NC *ncp;
1445   int stat = NC_check_id(ncid, &ncp);
1446   if(stat != NC_NOERR) return stat;
1447   return NC_get_varm(ncidvaridstartpcountp,
1448       stridepimapp, (void *)ipNC_BYTE);
1449}
1450
1451int
1452nc_get_varm_uchar(int ncid, int varid,
1453   const size_t *startp, const size_t *countp,
1454   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1455   unsigned char *ip)
1456{
1457   NC *ncp;
1458   int stat = NC_check_id(ncid, &ncp);
1459   if(stat != NC_NOERR) return stat;
1460   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_uchar);
1461}
1462
1463int
1464nc_get_varm_short(int ncid, int varid, const size_t *startp,
1465   const size_t *countp, const ptrdiff_t *stridep,
1466   const ptrdiff_t *imapp, short *ip)
1467{
1468   NC *ncp;
1469   int stat = NC_check_id(ncid, &ncp);
1470   if(stat != NC_NOERR) return stat;
1471   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,NC_SHORT);
1472}
1473
1474int
1475nc_get_varm_int(int ncid, int varid,
1476 const size_t *startp, const size_t *countp,
1477 const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1478 int *ip)
1479{
1480   NC *ncp;
1481   int stat = NC_check_id(ncid, &ncp);
1482   if(stat != NC_NOERR) return stat;
1483   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,NC_INT);
1484}
1485
1486int
1487nc_get_varm_long(int ncid, int varid,
1488  const size_t *startp, const size_t *countp,
1489  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1490  long *ip)
1491{
1492   NC *ncp;
1493   int stat = NC_check_id(ncid, &ncp);
1494   if(stat != NC_NOERR) return stat;
1495   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_long);
1496}
1497
1498int
1499nc_get_varm_float(int ncid, int varid,
1500   const size_t *startp, const size_t *countp,
1501   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1502   float *ip)
1503{
1504   NC *ncp;
1505   int stat = NC_check_id(ncid, &ncp);
1506   if(stat != NC_NOERR) return stat;
1507   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_float);
1508}
1509
1510int
1511nc_get_varm_double(int ncid, int varid,
1512    const size_t *startp, const size_t *countp,
1513    const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1514    double *ip)
1515{
1516   NC *ncp;
1517   int stat = NC_check_id(ncid, &ncp);
1518   if(stat != NC_NOERR) return stat;
1519   return NC_get_varm(ncid,varid,startp,countp,stridep,imapp, (void *)ip,T_double);
1520}
1521
1522int
1523nc_get_varm_ubyte(int ncid, int varid,
1524   const size_t *startp, const size_t *countp,
1525   const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1526   unsigned char *ip)
1527{
1528   NC *ncp;
1529   int stat = NC_check_id(ncid, &ncp);
1530   if(stat != NC_NOERR) return stat;
1531   return NC_get_varm(ncid,varid,startp,countp,stridep,
1532       imapp, (void *)ipT_ubyte);
1533}
1534
1535int
1536nc_get_varm_ushort(int ncid, int varid,
1537    const size_t *startp, const size_t *countp,
1538    const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1539    unsigned short *ip)
1540{
1541   NC *ncp;
1542   int stat = NC_check_id(ncid, &ncp);
1543   if(stat != NC_NOERR) return stat;
1544   return NC_get_varm(ncidvaridstartpcountpstridep,
1545       imapp, (void *)ipT_ushort);
1546}
1547
1548int
1549nc_get_varm_uint(int ncid, int varid,
1550  const size_t *startp, const size_t *countp,
1551  const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1552  unsigned int *ip)
1553{
1554   NC *ncp;
1555   int stat = NC_check_id(ncid, &ncp);
1556   if(stat != NC_NOERR) return stat;
1557   return NC_get_varm(ncidvaridstartpcountp,
1558       stridepimapp, (void *)ipT_uint);
1559}
1560
1561int
1562nc_get_varm_longlong(int ncid, int varid, const size_t *startp,
1563      const size_t *countp, const ptrdiff_t *stridep,
1564      const ptrdiff_t *imapp, long long *ip)
1565{
1566   NC *ncp;
1567   int stat = NC_check_id(ncid, &ncp);
1568   if(stat != NC_NOERR) return stat;
1569   return NC_get_varm(ncidvaridstartpcountpstridepimapp,
1570       (void *)ipT_longlong);
1571}
1572
1573int
1574nc_get_varm_ulonglong(int ncid, int varid,
1575       const size_t *startp, const size_t *countp,
1576       const ptrdiff_t *stridep, const ptrdiff_t *imapp,
1577       unsigned long long *ip)
1578{
1579   NC *ncp;
1580   int stat = NC_check_id(ncid, &ncp);
1581   if(stat != NC_NOERR) return stat;
1582   return NC_get_varm(ncidvaridstartpcountpstridepimapp,
1583       (void *)ipNC_UINT64);
1584}
1585
1586int
1587nc_get_varm_text(int ncid, int varid, const size_t *startp,
1588  const size_t *countp, const ptrdiff_t *stridep,
1589  const ptrdiff_t *imapp, char *ip)
1590{
1591   NC *ncp;
1592   int stat = NC_check_id(ncid, &ncp);
1593   if(stat != NC_NOERR) return stat;
1594   return NC_get_varm(ncidvaridstartpcountpstridepimapp,
1595       (void *)ipNC_CHAR);
1596}
1597
1598#ifdef USE_NETCDF4
1599int
1600nc_get_varm_string(int ncid, int varid, const size_t *startp,
1601    const size_t *countp, const ptrdiff_t *stridep,
1602    const ptrdiff_t *imapp, char **ip)
1603{
1604   NC *ncp;
1605   int stat = NC_check_id(ncid, &ncp);
1606   if(stat != NC_NOERR) return stat;
1607   return NC_get_varm(ncidvaridstartpcountpstridepimapp,
1608       (void *)ipNC_STRING);
1609}
1610/** \} */
1611#endif /*USE_NETCDF4*/
1612
1613
1614/*! \} */ /* 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