mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-11-21 03:13:42 +08:00
Code Issues Packages Projects Releases Wiki Activity
d8cdc2085d
netcdf-c/libdispatch/var.c
Ed Hartnett 60a6253832 fixed NC_SHORT conversion bug
2010-10-06 15:50:42 +00:00

2421 lines
61 KiB
C
Raw Blame History

/*
Copyright 2010 University Corporation for Atmospheric
Research/Unidata. See COPYRIGHT file for more info.
This file defines the variable functions.
"$Id: nc4.c,v 1.1 2010/06/01 15:46:50 ed Exp $"
*/
#include "ncdispatch.h"
#if defined(__cplusplus)
/* C++ consts default to internal linkage and must be initialized */
const size_t coord_zero[NC_MAX_VAR_DIMS] = {0};
const size_t coord_one[NC_MAX_VAR_DIMS] = {1};
#else
static const size_t coord_zero[NC_MAX_VAR_DIMS];
/* initialized int put/get_var1 below */
static size_t coord_one[NC_MAX_VAR_DIMS];
#endif
#define INITCOORD1 if(coord_one[0] != 1) {int i; for(i=0;i<NC_MAX_VAR_DIMS;i++) coord_one[i] = 1;}
static nc_type longtype = (sizeof(long) == sizeof(int) ? NC_INT : NC_INT64);
static int
getshape(int ncid, int varid, int ndims, size_t* shape)
{
int dimids[NC_MAX_VAR_DIMS];
int i;
int status;
if ((status = nc_inq_vardimid(ncid, varid, dimids)))
return status;
for(i = 0; i < ndims; i++)
if ((status = nc_inq_dimlen(ncid, dimids[i], &shape[i])))
break;
return status;
}
int
nc_def_var(int ncid, const char *name, nc_type xtype,
int ndims, const int *dimidsp, int *varidp)
{
NC* ncp;
int stat;
if ((stat = NC_check_id(ncid, &ncp)))
return stat;
return ncp->dispatch->def_var(ncid, name, xtype, ndims,
dimidsp, varidp);
}
int
nc_inq_varid(int ncid, const char *name, int *varidp)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->inq_varid(ncid, name, varidp);
}
int
nc_rename_var(int ncid, int varid, const char *name)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->rename_var(ncid, varid, name);
}
int
nc_inq_varname(int ncid, int varid, char *name)
{
return nc_inq_var(ncid, varid, name, NULL, NULL,
NULL, NULL);
}
int
nc_inq_vartype(int ncid, int varid, nc_type *typep)
{
return nc_inq_var(ncid, varid, NULL, typep, NULL,
NULL, NULL);
}
int
nc_inq_varndims(int ncid, int varid, int *ndimsp)
{
return nc_inq_var(ncid, varid, NULL, NULL, ndimsp, NULL, NULL);
}
int
nc_inq_vardimid(int ncid, int varid, int *dimids)
{
return nc_inq_var(ncid, varid, NULL, NULL, NULL,
dimids, NULL);
}
int
nc_inq_varnatts(int ncid, int varid, int *nattsp)
{
if (varid == NC_GLOBAL)
return nc_inq_natts(ncid,nattsp);
/*else*/
return nc_inq_var(ncid, varid, NULL, NULL, NULL, NULL,
nattsp);
}
int
nc_inq_nvars(int ncid, int *nvarsp)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->inq(ncid, NULL, nvarsp, NULL, NULL);
}
int
nc_inq_var(int ncid, int varid, char *name, nc_type *xtypep,
int *ndimsp, int *dimidsp, int *nattsp)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->inq_var_all(ncid, varid, name, xtypep, ndimsp,
dimidsp, nattsp, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
}
int
NC_put_vara(int ncid, int varid, const size_t *start,
const size_t *edges, const void *value, nc_type memtype)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
if(edges == NULL) {
size_t shape[NC_MAX_VAR_DIMS];
int ndims;
stat = nc_inq_varndims(ncid, varid, &ndims);
if(stat != NC_NOERR) return stat;
stat = getshape(ncid,varid,ndims,shape);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->put_vara(ncid,varid,start,shape,value,memtype);
} else
return ncp->dispatch->put_vara(ncid,varid,start,edges,value,memtype);
}
int
NC_get_vara(int ncid, int varid,
const size_t *start, const size_t *edges,
void *value, nc_type memtype)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
#ifdef USE_NETCDF4
if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT;
#endif
if(edges == NULL) {
size_t shape[NC_MAX_VAR_DIMS];
int ndims;
stat = nc_inq_varndims(ncid, varid, &ndims);
if(stat != NC_NOERR) return stat;
stat = getshape(ncid,varid,ndims,shape);
if(stat != NC_NOERR) return stat;
return ncp->dispatch->get_vara(ncid,varid,start,shape,value,memtype);
} else
return ncp->dispatch->get_vara(ncid,varid,start,edges,value,memtype);
}
int
NC_get_var(int ncid, int varid, void *value, nc_type memtype)
{
int ndims;
size_t shape[NC_MAX_VAR_DIMS];
int stat = nc_inq_varndims(ncid,varid, &ndims);
if(stat) return stat;
stat = getshape(ncid,varid, ndims, shape);
if(stat) return stat;
return NC_get_vara(ncid, varid, coord_zero, shape, value, memtype);
}
int
NC_put_var(int ncid, int varid, const void *value, nc_type memtype)
{
int ndims;
size_t shape[NC_MAX_VAR_DIMS];
int stat = nc_inq_varndims(ncid,varid, &ndims);
if(stat) return stat;
stat = getshape(ncid,varid, ndims, shape);
if(stat) return stat;
return NC_put_vara(ncid, varid, coord_zero, shape, value, memtype);
}
int
NC_get_var1(int ncid, int varid, const size_t *coord, void* value,
nc_type memtype)
{
INITCOORD1;
return NC_get_vara(ncid, varid, coord, coord_one, value, memtype);
}
int
NC_put_var1(int ncid, int varid, const size_t *coord, const void* value,
nc_type memtype)
{
INITCOORD1;
return NC_put_vara(ncid, varid, coord, coord_one, value, memtype);
}
static int
is_recvar(int ncid, int varid, size_t* nrecs)
{
int status;
int unlimid;
int ndims;
int dimset[NC_MAX_VAR_DIMS];
status = nc_inq_unlimdim(ncid,&unlimid);
if(status != NC_NOERR) return 0; /* no unlimited defined */
status = nc_inq_varndims(ncid,varid,&ndims);
if(status != NC_NOERR) return 0; /* no unlimited defined */
if(ndims == 0) return 0; /* scalar */
status = nc_inq_vardimid(ncid,varid,dimset);
if(status != NC_NOERR) return 0; /* no unlimited defined */
status = nc_inq_dim(ncid,dimset[0],NULL,nrecs);
if(status != NC_NOERR) return 0;
return (dimset[0] == unlimid ? 1: 0);
}
static int
NC_get_varm(int ncid, int varid, const size_t *start,
const size_t *edges, const ptrdiff_t *stride,
const ptrdiff_t *imapp, void *value0, nc_type memtype)
{
int status;
nc_type vartype;
int varndims,maxidim;
NC* ncp;
size_t memtypelen;
ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
char* value = (char*)value0;
status = NC_check_id (ncid, &ncp);
if(status != NC_NOERR) return status;
/*
if(NC_indef(ncp)) return NC_EINDEFINE;
*/
status = nc_inq_vartype(ncid, varid, &vartype);
if(status != NC_NOERR) return status;
status = nc_inq_varndims(ncid, varid, &varndims);
if(status != NC_NOERR) return status;
if(memtype == NC_NAT) {
if(imapp != NULL && varndims != 0) {
/*
* convert map units from bytes to units of sizeof(type)
*/
size_t ii;
const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
for(ii = 0; ii < varndims; ii++) {
if(imapp[ii] % szof != 0) {
/*free(cvtmap);*/
return NC_EINVAL;
}
cvtmap[ii] = imapp[ii] / szof;
}
imapp = cvtmap;
}
memtype = vartype;
}
if(memtype == NC_CHAR && vartype != NC_CHAR)
return NC_ECHAR;
else if(memtype != NC_CHAR && vartype == NC_CHAR)
return NC_ECHAR;
memtypelen = nctypelen(memtype);
maxidim = (int) varndims - 1;
if (maxidim < 0)
{
/*
* The variable is a scalar; consequently,
* there s only one thing to get and only one place to put it.
* (Why was I called?)
*/
size_t edge1[1] = {1};
return NC_get_vara(ncid, varid, start, edge1, value, memtype);
}
/*
* else
* The variable is an array.
*/
{
int idim;
size_t *mystart = NULL;
size_t *myedges;
size_t *iocount; /* count vector */
size_t *stop; /* stop indexes */
size_t *length; /* edge lengths in bytes */
ptrdiff_t *mystride;
ptrdiff_t *mymap;
size_t varshape[NC_MAX_VAR_DIMS];
int isrecvar;
size_t numrecs;
/* Compute some dimension related values */
isrecvar = is_recvar(ncid,varid,&numrecs);
getshape(ncid,varid,varndims,varshape);
/*
* Verify stride argument.
*/
if(stride != NULL)
for (idim = 0; idim <= maxidim; ++idim)
{
if (stride[idim] == 0
/* cast needed for braindead systems with signed size_t */
|| ((unsigned long) stride[idim] >= X_INT_MAX))
{
return NC_ESTRIDE;
}
}
/* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
/* Allocate space for mystart,mystride,mymap etc.all at once */
mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t));
if(mystart == NULL) return NC_ENOMEM;
myedges = mystart + varndims;
iocount = myedges + varndims;
stop = iocount + varndims;
length = stop + varndims;
mystride = (ptrdiff_t *)(length + varndims);
mymap = mystride + varndims;
/*
* Initialize I/O parameters.
*/
for (idim = maxidim; idim >= 0; --idim)
{
mystart[idim] = start != NULL
? start[idim]
: 0;
if (edges != NULL && edges[idim] == 0)
{
status = NC_NOERR; /* read/write no data */
goto done;
}
#ifdef COMPLEX
myedges[idim] = edges != NULL
? edges[idim]
: idim == 0 && isrecvar
? numrecs - mystart[idim]
: varshape[idim] - mystart[idim];
#else
if(edges != NULL)
myedges[idim] = edges[idim];
else if (idim == 0 && isrecvar)
myedges[idim] = numrecs - mystart[idim];
else
myedges[idim] = varshape[idim] - mystart[idim];
#endif
mystride[idim] = stride != NULL
? stride[idim]
: 1;
/* Remember: imapp is byte oriented, not index oriented */
#ifdef COMPLEX
mymap[idim] = (imapp != NULL
? imapp[idim]
: (idim == maxidim ? 1
: mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]));
#else
if(imapp != NULL)
mymap[idim] = imapp[idim];
else if (idim == maxidim)
mymap[idim] = 1;
else
mymap[idim] =
mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
#endif
iocount[idim] = 1;
length[idim] = mymap[idim] * myedges[idim];
stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
}
/*
* Check start, edges
*/
for (idim = maxidim; idim >= 0; --idim)
{
size_t dimlen =
idim == 0 && isrecvar
? numrecs
: varshape[idim];
if (mystart[idim] >= dimlen)
{
status = NC_EINVALCOORDS;
goto done;
}
if (mystart[idim] + myedges[idim] > dimlen)
{
status = NC_EEDGE;
goto done;
}
}
/* Lower body */
/*
* As an optimization, adjust I/O parameters when the fastest
* dimension has unity stride both externally and internally.
* In this case, the user could have called a simpler routine
* (i.e. ncvar$1()
*/
if (mystride[maxidim] == 1
&& mymap[maxidim] == 1)
{
iocount[maxidim] = myedges[maxidim];
mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
mymap[maxidim] = (ptrdiff_t) length[maxidim];
}
/*
* Perform I/O. Exit when done.
*/
for (;;)
{
/* TODO: */
int lstatus = NC_get_vara(ncid, varid, mystart, iocount,
value, memtype);
if (lstatus != NC_NOERR) {
if(status == NC_NOERR || lstatus != NC_ERANGE)
status = lstatus;
}
/*
* The following code permutes through the variable s
* external start-index space and it s internal address
* space. At the UPC, this algorithm is commonly
* called "odometer code".
*/
idim = maxidim;
carry:
value += (mymap[idim] * memtypelen);
mystart[idim] += mystride[idim];
if (mystart[idim] == stop[idim])
{
mystart[idim] = start[idim];
value -= (length[idim] * memtypelen);
if (--idim < 0)
break; /* normal return */
goto carry;
}
} /* I/O loop */
done:
free(mystart);
} /* variable is array */
return status;
}
static int
NC_put_varm(
int ncid,
int varid,
const size_t * start,
const size_t * edges,
const ptrdiff_t * stride,
const ptrdiff_t * imapp,
const void *value0,
nc_type memtype)
{
int status;
nc_type vartype;
int varndims,maxidim;
NC* ncp;
size_t memtypelen;
ptrdiff_t cvtmap[NC_MAX_VAR_DIMS];
const char* value = (char*)value0;
status = NC_check_id (ncid, &ncp);
if(status != NC_NOERR) return status;
/*
if(NC_indef(ncp)) return NC_EINDEFINE;
if(NC_readonly (ncp)) return NC_EPERM;
*/
/* mid body */
status = nc_inq_vartype(ncid, varid, &vartype);
if(status != NC_NOERR) return status;
status = nc_inq_varndims(ncid, varid, &varndims);
if(status != NC_NOERR) return status;
if(memtype == NC_NAT) {
if(imapp != NULL && varndims != 0) {
/*
* convert map units from bytes to units of sizeof(type)
*/
size_t ii;
const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype);
for(ii = 0; ii < varndims; ii++) {
if(imapp[ii] % szof != 0) {
/*free(cvtmap);*/
return NC_EINVAL;
}
cvtmap[ii] = imapp[ii] / szof;
}
imapp = cvtmap;
}
memtype = vartype;
}
if(memtype == NC_CHAR && vartype != NC_CHAR)
return NC_ECHAR;
else if(memtype != NC_CHAR && vartype == NC_CHAR)
return NC_ECHAR;
memtypelen = nctypelen(memtype);
maxidim = (int) varndims - 1;
if (maxidim < 0)
{
/*
* The variable is a scalar; consequently,
* there s only one thing to get and only one place to put it.
* (Why was I called?)
*/
size_t edge1[1] = {1};
return NC_put_vara(ncid, varid, start, edge1, value, memtype);
}
/*
* else
* The variable is an array.
*/
{
int idim;
size_t *mystart = NULL;
size_t *myedges;
size_t *iocount; /* count vector */
size_t *stop; /* stop indexes */
size_t *length; /* edge lengths in bytes */
ptrdiff_t *mystride;
ptrdiff_t *mymap;
size_t varshape[NC_MAX_VAR_DIMS];
int isrecvar;
size_t numrecs;
/* Compute some dimension related values */
isrecvar = is_recvar(ncid,varid,&numrecs);
getshape(ncid,varid,varndims,varshape);
/*
* Verify stride argument.
*/
if(stride != NULL)
for (idim = 0; idim <= maxidim; ++idim)
{
if ((stride[idim] == 0)
/* cast needed for braindead systems with signed size_t */
|| ((unsigned long) stride[idim] >= X_INT_MAX))
{
return NC_ESTRIDE;
}
}
/* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */
mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t));
if(mystart == NULL) return NC_ENOMEM;
myedges = mystart + varndims;
iocount = myedges + varndims;
stop = iocount + varndims;
length = stop + varndims;
mystride = (ptrdiff_t *)(length + varndims);
mymap = mystride + varndims;
/*
* Initialize I/O parameters.
*/
for (idim = maxidim; idim >= 0; --idim)
{
mystart[idim] = start != NULL
? start[idim]
: 0;
if (edges != NULL && edges[idim] == 0)
{
status = NC_NOERR; /* read/write no data */
goto done;
}
myedges[idim] = edges != NULL
? edges[idim]
: idim == 0 && isrecvar
? numrecs - mystart[idim]
: varshape[idim] - mystart[idim];
mystride[idim] = stride != NULL
? stride[idim]
: 1;
mymap[idim] = imapp != NULL
? imapp[idim]
: idim == maxidim
? 1
: mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1];
iocount[idim] = 1;
length[idim] = mymap[idim] * myedges[idim];
stop[idim] = mystart[idim] + myedges[idim] * mystride[idim];
}
/*
* Check start, edges
*/
for (idim = isrecvar; idim < maxidim; ++idim)
{
if (mystart[idim] > varshape[idim])
{
status = NC_EINVALCOORDS;
goto done;
}
if (mystart[idim] + myedges[idim] > varshape[idim])
{
status = NC_EEDGE;
goto done;
}
}
/* Lower body */
/*
* As an optimization, adjust I/O parameters when the fastest
* dimension has unity stride both externally and internally.
* In this case, the user could have called a simpler routine
* (i.e. ncvar$1()
*/
if (mystride[maxidim] == 1
&& mymap[maxidim] == 1)
{
iocount[maxidim] = myedges[maxidim];
mystride[maxidim] = (ptrdiff_t) myedges[maxidim];
mymap[maxidim] = (ptrdiff_t) length[maxidim];
}
/*
* Perform I/O. Exit when done.
*/
for (;;)
{
/* TODO: */
int lstatus = NC_put_vara(ncid, varid, mystart, iocount,
value, memtype);
if (lstatus != NC_NOERR) {
if(status == NC_NOERR || lstatus != NC_ERANGE)
status = lstatus;
}
/*
* The following code permutes through the variable s
* external start-index space and it s internal address
* space. At the UPC, this algorithm is commonly
* called "odometer code".
*/
idim = maxidim;
carry:
value += (mymap[idim] * memtypelen);
mystart[idim] += mystride[idim];
if (mystart[idim] == stop[idim])
{
mystart[idim] = start[idim];
value -= (length[idim] * memtypelen);
if (--idim < 0)
break; /* normal return */
goto carry;
}
} /* I/O loop */
done:
free(mystart);
} /* variable is array */
return status;
}
int
NC_get_vars(int ncid, int varid, const size_t *start,
const size_t *edges, const ptrdiff_t *stride, void *value,
nc_type memtype)
{
return NC_get_varm(ncid, varid, start, edges, stride, 0,
value, memtype);
}
int
NC_put_vars(int ncid, int varid, const size_t *start,
const size_t *edges, const ptrdiff_t *stride,
const void *value, nc_type memtype)
{
return NC_put_varm(ncid, varid, start, edges,
stride, 0, value, memtype);
}
/* Ok to use NC pointers because
all IOSP's will use that structure,
but not ok to use e.g. NC_Var pointers
because they may be different structure
entirely.
*/
/*
* This is how much space is required by the user, as in
*
* vals = malloc(nel * nctypelen(var.type));
* ncvarget(cdfid, varid, cor, edg, vals);
*/
int
nctypelen(nc_type type)
{
switch(type){
case NC_CHAR :
return((int)sizeof(char));
case NC_BYTE :
return((int)sizeof(signed char));
case NC_SHORT :
return(int)(sizeof(short));
case NC_INT :
return((int)sizeof(int));
case NC_FLOAT :
return((int)sizeof(float));
case NC_DOUBLE :
return((int)sizeof(double));
/* These can occur in netcdf-3 code */
case NC_UBYTE :
return((int)sizeof(unsigned char));
case NC_USHORT :
return((int)(sizeof(unsigned short)));
case NC_UINT :
return((int)sizeof(unsigned int));
case NC_INT64 :
return((int)sizeof(signed long long));
case NC_UINT64 :
return((int)sizeof(unsigned long long));
#ifdef USE_NETCDF4
case NC_STRING :
return((int)sizeof(char*));
#endif /*USE_NETCDF4*/
default:
return -1;
}
}
/* utility functions */
/* Redunant over nctypelen above */
int
NC_atomictypelen(nc_type xtype)
{
int sz = 0;
switch(xtype) {
case NC_NAT: sz = 0; break;
case NC_BYTE: sz = sizeof(signed char); break;
case NC_CHAR: sz = sizeof(char); break;
case NC_SHORT: sz = sizeof(short); break;
case NC_INT: sz = sizeof(int); break;
case NC_FLOAT: sz = sizeof(float); break;
case NC_DOUBLE: sz = sizeof(double); break;
case NC_INT64: sz = sizeof(signed long long); break;
case NC_UBYTE: sz = sizeof(unsigned char); break;
case NC_USHORT: sz = sizeof(unsigned short); break;
case NC_UINT: sz = sizeof(unsigned int); break;
case NC_UINT64: sz = sizeof(unsigned long long); break;
#ifdef USE_NETCDF4
case NC_STRING: sz = sizeof(char*); break;
#endif
default: break;
}
return sz;
}
char*
NC_atomictypename(nc_type xtype)
{
char* nm = NULL;
switch(xtype) {
case NC_NAT: nm = "undefined"; break;
case NC_BYTE: nm = "byte"; break;
case NC_CHAR: nm = "char"; break;
case NC_SHORT: nm = "short"; break;
case NC_INT: nm = "int"; break;
case NC_FLOAT: nm = "float"; break;
case NC_DOUBLE: nm = "double"; break;
case NC_INT64: nm = "int64"; break;
case NC_UBYTE: nm = "ubyte"; break;
case NC_USHORT: nm = "ushort"; break;
case NC_UINT: nm = "uint"; break;
case NC_UINT64: nm = "uint64"; break;
#ifdef USE_NETCDF4
case NC_STRING: nm = "string"; break;
#endif
default: break;
}
return nm;
}
int
nc_put_vara(int ncid, int varid,
const size_t *start, const size_t *edges,
const void *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
nc_type xtype;
if(stat != NC_NOERR) return stat;
stat = nc_inq_vartype(ncid, varid, &xtype);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,value,xtype);
}
int
nc_get_vara(int ncid, int varid,
const size_t *start, const size_t *edges,
void *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
nc_type xtype;
if(stat != NC_NOERR) return stat;
stat = nc_inq_vartype(ncid, varid, &xtype);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,value,xtype);
}
int
nc_get_var(int ncid, int varid, void *value)
{
return NC_get_var(ncid, varid, value, NC_NAT);
}
int
nc_put_var(int ncid, int varid, const void *value)
{
return NC_put_var(ncid, varid, value, NC_NAT);
}
int
nc_get_var1(int ncid, int varid, const size_t *coord, void *value)
{
return NC_get_var1(ncid, varid, coord, value, NC_NAT);
}
int
nc_put_var1(int ncid, int varid, const size_t *coord, const void *value)
{
return NC_put_var1(ncid, varid, coord, value, NC_NAT);
}
int
nc_get_varm(int ncid, int varid, const size_t * start,
const size_t * edges, const ptrdiff_t * stride,
const ptrdiff_t * imapp, void *value)
{
return NC_get_varm(ncid, varid, start, edges, stride, imapp,
value, NC_NAT);
}
int
nc_put_varm (int ncid, int varid, const size_t * start,
const size_t * edges, const ptrdiff_t * stride,
const ptrdiff_t * imapp, const void *value)
{
return NC_put_varm(ncid, varid, start, edges, stride, imapp,
value, NC_NAT);
}
int
nc_get_vars(int ncid, int varid, const size_t * start,
const size_t * edges, const ptrdiff_t * stride,
void *value)
{
return nc_get_varm(ncid, varid, start, edges,
stride, NULL, value);
}
int
nc_put_vars (int ncid, int varid, const size_t * start,
const size_t * edges, const ptrdiff_t * stride,
const void *value)
{
return nc_put_varm(ncid, varid, start, edges,
stride, NULL, value);
}
int
nc_get_var1_text(int ncid, int varid, const size_t *coord, char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid, varid, coord, (void*)value, NC_CHAR);
}
int
nc_get_var1_schar(int ncid, int varid, const size_t *coord, signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid, varid, coord, (void*)value, NC_BYTE);
}
int
nc_get_var1_uchar(int ncid, int varid, const size_t *coord, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid, varid, coord, (void*)value, NC_UBYTE);
}
int
nc_get_var1_short(int ncid, int varid, const size_t *coord, short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid, varid, coord, (void*)value, NC_SHORT);
}
int
nc_get_var1_int(int ncid, int varid, const size_t *coord, int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid, varid, coord, (void*)value, NC_INT);
}
int
nc_get_var1_long(int ncid, int varid, const size_t *coord, long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, longtype);
}
int
nc_get_var1_float(int ncid, int varid, const size_t *coord, float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_FLOAT);
}
int
nc_get_var1_double(int ncid, int varid, const size_t *coord, double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_DOUBLE);
}
int
nc_get_var1_ubyte(int ncid, int varid, const size_t *coord, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
}
int
nc_get_var1_ushort(int ncid, int varid, const size_t *coord,
unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_USHORT);
}
int
nc_get_var1_uint(int ncid, int varid, const size_t *coord, unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_INT);
}
int
nc_get_var1_longlong(int ncid, int varid, const size_t *coord, long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_INT64);
}
int
nc_get_var1_ulonglong(int ncid, int varid, const size_t *coord, unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_get_var1_string(int ncid, int varid, const size_t *coord, char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_get_var1(ncid,varid,coord,(void*)value, NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_put_var1_text(int ncid, int varid, const size_t *coord, const char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_CHAR);
}
int
nc_put_var1_schar(int ncid, int varid, const size_t *coord, const signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_BYTE);
}
int
nc_put_var1_uchar(int ncid, int varid, const size_t *coord, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
}
int
nc_put_var1_short(int ncid, int varid, const size_t *coord, const short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_SHORT);
}
int
nc_put_var1_int(int ncid, int varid, const size_t *coord, const int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_INT);
}
int
nc_put_var1_long(int ncid, int varid, const size_t *coord, const long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, longtype);
}
int
nc_put_var1_float(int ncid, int varid, const size_t *coord, const float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_FLOAT);
}
int
nc_put_var1_double(int ncid, int varid, const size_t *coord, const double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_DOUBLE);
}
int
nc_put_var1_ubyte(int ncid, int varid, const size_t *coord, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_UBYTE);
}
int
nc_put_var1_ushort(int ncid, int varid, const size_t *coord, const unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_USHORT);
}
int
nc_put_var1_uint(int ncid, int varid, const size_t *coord, const unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_UINT);
}
int
nc_put_var1_longlong(int ncid, int varid, const size_t *coord, const long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_INT64);
}
int
nc_put_var1_ulonglong(int ncid, int varid, const size_t *coord, const unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid,varid,coord,(void*)value, NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_put_var1_string(int ncid, int varid, const size_t *coord, const char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
INITCOORD1;
return NC_put_var1(ncid, varid, coord, (void*)value, NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_get_var_text(int ncid, int varid, char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid, varid, (void*)value, NC_CHAR);
}
int
nc_get_var_schar(int ncid, int varid, signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_BYTE);
}
int
nc_get_var_uchar(int ncid, int varid, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_UBYTE);
}
int
nc_get_var_short(int ncid, int varid, short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_SHORT);
}
int
nc_get_var_int(int ncid, int varid, int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_INT);
}
int
nc_get_var_long(int ncid, int varid, long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, longtype);
}
int
nc_get_var_float(int ncid, int varid, float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_FLOAT);
}
int
nc_get_var_double(int ncid, int varid, double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_DOUBLE);
}
int
nc_get_var_ubyte(int ncid, int varid, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_UBYTE);
}
int
nc_get_var_ushort(int ncid, int varid, unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_USHORT);
}
int
nc_get_var_uint(int ncid, int varid, unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_UINT);
}
int
nc_get_var_longlong(int ncid, int varid, long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value, NC_INT64);
}
int
nc_get_var_ulonglong(int ncid, int varid, unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_get_var_string(int ncid, int varid, char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_var(ncid,varid,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_put_var_text(int ncid, int varid, const char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_CHAR);
}
int
nc_put_var_schar(int ncid, int varid, const signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_BYTE);
}
int
nc_put_var_uchar(int ncid, int varid, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_uchar);
}
int
nc_put_var_short(int ncid, int varid, const short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_SHORT);
}
int
nc_put_var_int(int ncid, int varid, const int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_INT);
}
int
nc_put_var_long(int ncid, int varid, const long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_long);
}
int
nc_put_var_float(int ncid, int varid, const float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_float);
}
int
nc_put_var_double(int ncid, int varid, const double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_double);
}
int
nc_put_var_ubyte(int ncid, int varid, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_ubyte);
}
int
nc_put_var_ushort(int ncid, int varid, const unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_ushort);
}
int
nc_put_var_uint(int ncid, int varid, const unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_uint);
}
int
nc_put_var_longlong(int ncid, int varid, const long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,T_longlong);
}
int
nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_put_var_string(int ncid, int varid, const char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_var(ncid,varid,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_put_vara_text(int ncid, int varid, const size_t *start,
const size_t *edges, const char *value)
{
return NC_put_vara(ncid, varid, start, edges,
(void*)value, NC_CHAR);
}
int
nc_put_vara_schar(int ncid, int varid,
const size_t *start, const size_t *edges, const signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_BYTE);
}
int
nc_put_vara_uchar(int ncid, int varid,
const size_t *start, const size_t *edges, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_uchar);
}
int
nc_put_vara_short(int ncid, int varid,
const size_t *start, const size_t *edges, const short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_SHORT);
}
int
nc_put_vara_int(int ncid, int varid,
const size_t *start, const size_t *edges, const int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_INT);
}
int
nc_put_vara_long(int ncid, int varid,
const size_t *start, const size_t *edges, const long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_long);
}
int
nc_put_vara_float(int ncid, int varid,
const size_t *start, const size_t *edges, const float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_float);
}
int
nc_put_vara_double(int ncid, int varid,
const size_t *start, const size_t *edges, const double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_double);
}
int
nc_put_vara_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges, const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_ubyte);
}
int
nc_put_vara_ushort(int ncid, int varid,
const size_t *start, const size_t *edges, const unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_ushort);
}
int
nc_put_vara_uint(int ncid, int varid,
const size_t *start, const size_t *edges, const unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_uint);
}
int
nc_put_vara_longlong(int ncid, int varid,
const size_t *start, const size_t *edges, const long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,T_longlong);
}
int
nc_put_vara_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges, const unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_put_vara_string(int ncid, int varid,
const size_t *start, const size_t *edges, const char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vara(ncid,varid,start,edges,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_get_vara_text(int ncid, int varid,
const size_t *start, const size_t *edges, char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_CHAR);
}
int
nc_get_vara_schar(int ncid, int varid,
const size_t *start, const size_t *edges, signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_BYTE);
}
int
nc_get_vara_uchar(int ncid, int varid,
const size_t *start, const size_t *edges, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_uchar);
}
int
nc_get_vara_short(int ncid, int varid,
const size_t *start, const size_t *edges, short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_SHORT);
}
int
nc_get_vara_int(int ncid, int varid,
const size_t *start, const size_t *edges, int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_INT);
}
int
nc_get_vara_long(int ncid, int varid,
const size_t *start, const size_t *edges, long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_long);
}
int
nc_get_vara_float(int ncid, int varid,
const size_t *start, const size_t *edges, float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_float);
}
int
nc_get_vara_double(int ncid, int varid,
const size_t *start, const size_t *edges, double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_double);
}
int
nc_get_vara_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges, unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_ubyte);
}
int
nc_get_vara_ushort(int ncid, int varid,
const size_t *start, const size_t *edges, unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_ushort);
}
int
nc_get_vara_uint(int ncid, int varid,
const size_t *start, const size_t *edges, unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_uint);
}
int
nc_get_vara_longlong(int ncid, int varid,
const size_t *start, const size_t *edges, long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,T_longlong);
}
int
nc_get_vara_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges, unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_get_vara_string(int ncid, int varid,
const size_t *start, const size_t *edges, char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vara(ncid,varid,start,edges,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_put_varm_text(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_CHAR);
}
int
nc_put_varm_schar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_BYTE);
}
int
nc_put_varm_uchar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uchar);
}
int
nc_put_varm_short(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_SHORT);
}
int
nc_put_varm_int(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_INT);
}
int
nc_put_varm_long(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_long);
}
int
nc_put_varm_float(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_float);
}
int
nc_put_varm_double(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_double);
}
int
nc_put_varm_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ubyte);
}
int
nc_put_varm_ushort(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ushort);
}
int
nc_put_varm_uint(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uint);
}
int
nc_put_varm_longlong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_longlong);
}
int
nc_put_varm_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_put_varm_string(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
const char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_get_varm_text(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_CHAR);
}
int
nc_get_varm_schar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_BYTE);
}
int
nc_get_varm_uchar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uchar);
}
int
nc_get_varm_short(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_SHORT);
}
int
nc_get_varm_int(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_INT);
}
int
nc_get_varm_long(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_long);
}
int
nc_get_varm_float(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_float);
}
int
nc_get_varm_double(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_double);
}
int
nc_get_varm_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ubyte);
}
int
nc_get_varm_ushort(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_ushort);
}
int
nc_get_varm_uint(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_uint);
}
int
nc_get_varm_longlong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,T_longlong);
}
int
nc_get_varm_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_get_varm_string(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride, const ptrdiff_t * imapp,
char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_varm(ncid,varid,start,edges,stride,imapp,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_put_vars_text(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_CHAR);
}
int
nc_put_vars_schar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_BYTE);
}
int
nc_put_vars_uchar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_uchar);
}
int
nc_put_vars_short(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_SHORT);
}
int
nc_put_vars_int(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_INT);
}
int
nc_put_vars_long(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_long);
}
int
nc_put_vars_float(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_float);
}
int
nc_put_vars_double(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_double);
}
int
nc_put_vars_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_ubyte);
}
int
nc_put_vars_ushort(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_ushort);
}
int
nc_put_vars_uint(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_uint);
}
int
nc_put_vars_longlong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,T_longlong);
}
int
nc_put_vars_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_put_vars_string(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
const char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_put_vars(ncid,varid,start,edges,stride,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
int
nc_get_vars_text(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_CHAR);
}
int
nc_get_vars_schar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
signed char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_BYTE);
}
int
nc_get_vars_uchar(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_uchar);
}
int
nc_get_vars_short(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_SHORT);
}
int
nc_get_vars_int(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_INT);
}
int
nc_get_vars_long(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_long);
}
int
nc_get_vars_float(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
float *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_float);
}
int
nc_get_vars_double(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
double *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_double);
}
int
nc_get_vars_ubyte(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
unsigned char *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_ubyte);
}
int
nc_get_vars_ushort(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
unsigned short *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_ushort);
}
int
nc_get_vars_uint(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
unsigned int *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_uint);
}
int
nc_get_vars_longlong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,T_longlong);
}
int
nc_get_vars_ulonglong(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
unsigned long long *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_UINT64);
}
#ifdef USE_NETCDF4
int
nc_get_vars_string(int ncid, int varid,
const size_t *start, const size_t *edges,
const ptrdiff_t * stride,
char* *value)
{
NC* ncp;
int stat = NC_check_id(ncid, &ncp);
if(stat != NC_NOERR) return stat;
return NC_get_vars(ncid,varid,start,edges,stride,(void*)value,NC_STRING);
}
#endif /*USE_NETCDF4*/
Reference in New Issue View Git Blame Copy Permalink