8 #include "ncdispatch.h"
208 int ndims,
const int *dimidsp,
int *varidp)
213 if ((stat = NC_check_id(ncid, &ncp)))
216 return ncp->dispatch->def_var(ncid, name, xtype, ndims,
284 int stat = NC_check_id(ncid, &ncp);
287 return ncp->dispatch->rename_var(ncid, varid, name);
295 NC_is_recvar(
int ncid,
int varid,
size_t* nrecs)
306 if(ndims == 0)
return 0;
309 status =
nc_inq_dim(ncid,dimset[0],NULL,nrecs);
311 return (dimset[0] == unlimid ? 1: 0);
331 NC_inq_recvar(
int ncid,
int varid,
int* nrecdimsp,
int *is_recdim)
341 if(status !=
NC_NOERR)
return status;
343 for(dim = 0; dim < nvardims; dim++)
346 if(status !=
NC_NOERR)
return status;
347 if(unlimid == -1)
return status;
354 if(status !=
NC_NOERR)
return status;
355 if(nunlimdims == 0)
return status;
357 if (!(unlimids = malloc(nunlimdims *
sizeof(
int))))
369 for (dim = 0; dim < nvardims; dim++) {
370 for(recdim = 0; recdim < nunlimdims; recdim++) {
371 if(dimset[dim] == unlimids[recdim]) {
381 if(status !=
NC_NOERR)
return status;
382 if(dimset[0] == unlimid) {
387 if(nrecdimsp) *nrecdimsp = nrecdims;
411 return ((
int)
sizeof(
char));
413 return ((
int)
sizeof(
signed char));
415 return ((
int)
sizeof(
short));
417 return ((
int)
sizeof(
int));
419 return ((
int)
sizeof(
float));
421 return ((
int)
sizeof(
double));
425 return ((
int)
sizeof(
unsigned char));
427 return ((
int)(
sizeof(
unsigned short)));
429 return ((
int)
sizeof(
unsigned int));
431 return ((
int)
sizeof(
signed long long));
433 return ((
int)
sizeof(
unsigned long long));
436 return ((
int)
sizeof(
char*));
448 NC_atomictypelen(
nc_type xtype)
452 case NC_NAT: sz = 0;
break;
453 case NC_BYTE: sz =
sizeof(
signed char);
break;
454 case NC_CHAR: sz =
sizeof(char);
break;
455 case NC_SHORT: sz =
sizeof(short);
break;
456 case NC_INT: sz =
sizeof(int);
break;
457 case NC_FLOAT: sz =
sizeof(float);
break;
458 case NC_DOUBLE: sz =
sizeof(double);
break;
459 case NC_INT64: sz =
sizeof(
signed long long);
break;
460 case NC_UBYTE: sz =
sizeof(
unsigned char);
break;
461 case NC_USHORT: sz =
sizeof(
unsigned short);
break;
462 case NC_UINT: sz =
sizeof(
unsigned int);
break;
463 case NC_UINT64: sz =
sizeof(
unsigned long long);
break;
465 case NC_STRING: sz =
sizeof(
char*);
break;
476 NC_atomictypename(
nc_type xtype)
480 case NC_NAT: nm =
"undefined";
break;
481 case NC_BYTE: nm =
"byte";
break;
482 case NC_CHAR: nm =
"char";
break;
484 case NC_INT: nm =
"int";
break;
490 case NC_UINT: nm =
"uint";
break;
505 NC_getshape(
int ncid,
int varid,
int ndims,
size_t* shape)
513 for(i = 0; i < ndims; i++)
551 int stat = NC_check_id(ncid, &ncp);
553 return ncp->dispatch->set_var_chunk_cache(ncid, varid, size,
589 int stat = NC_check_id(ncid, &ncp);
591 return ncp->dispatch->get_var_chunk_cache(ncid, varid, sizep,
592 nelemsp, preemptionp);
612 for (i = 0; i < len; i++)
618 nc_def_var_deflate(
int ncid,
int varid,
int shuffle,
int deflate,
int deflate_level)
621 int stat = NC_check_id(ncid,&ncp);
623 return ncp->dispatch->def_var_deflate(ncid,varid,shuffle,deflate,deflate_level);
627 nc_def_var_fletcher32(
int ncid,
int varid,
int fletcher32)
630 int stat = NC_check_id(ncid,&ncp);
632 return ncp->dispatch->def_var_fletcher32(ncid,varid,fletcher32);
636 nc_def_var_chunking(
int ncid,
int varid,
int storage,
637 const size_t *chunksizesp)
640 int stat = NC_check_id(ncid, &ncp);
642 return ncp->dispatch->def_var_chunking(ncid, varid, storage,
647 nc_def_var_fill(
int ncid,
int varid,
int no_fill,
const void *fill_value)
650 int stat = NC_check_id(ncid,&ncp);
652 return ncp->dispatch->def_var_fill(ncid,varid,no_fill,fill_value);
656 nc_def_var_endian(
int ncid,
int varid,
int endian)
659 int stat = NC_check_id(ncid,&ncp);
661 return ncp->dispatch->def_var_endian(ncid,varid,endian);
#define NC_ENOMEM
Memory allocation (malloc) failure.
#define NC_CHAR
ISO/ASCII character.
int nc_get_var_chunk_cache(int ncid, int varid, size_t *sizep, size_t *nelemsp, float *preemptionp)
EXTERNL int nc_inq_vardimid(int ncid, int varid, int *dimidsp)
Learn the dimension IDs associated with a variable.
int nc_def_var(int ncid, const char *name, nc_type xtype, int ndims, const int *dimidsp, int *varidp)
Define a new variable.
#define NC_UBYTE
unsigned 1 byte int
#define NC_MAX_VAR_DIMS
max per variable dimensions
#define NC_UINT
unsigned 4-byte int
#define NC_INT64
signed 8-byte int
#define NC_DOUBLE
double precision floating point number
EXTERNL int nc_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
Find the name and length of a dimension.
EXTERNL int nc_inq_varndims(int ncid, int varid, int *ndimsp)
Learn how many dimensions are associated with a variable.
int nc_type
The nc_type type is just an int.
#define NC_BYTE
signed 1 byte integer
int nc_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
int nc_rename_var(int ncid, int varid, const char *name)
Rename a variable.
EXTERNL int nc_inq_dimlen(int ncid, int dimid, size_t *lenp)
Find the length of a dimension.
#define NC_INT
signed 4 byte integer
#define NC_NAT
Not A Type.
int nc_free_string(size_t len, char **data)
Free string space allocated by the library.
#define NC_USHORT
unsigned 2-byte int
EXTERNL int nc_inq_unlimdim(int ncid, int *unlimdimidp)
Find the ID of the unlimited dimension.
#define NC_SHORT
signed 2 byte integer
EXTERNL int nc_inq_unlimdims(int ncid, int *nunlimdimsp, int *unlimdimidsp)
Return number and list of unlimited dimensions.
#define NC_NOERR
No Error.
#define NC_FLOAT
single precision floating point number
#define NC_UINT64
unsigned 8-byte int