mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-12-27 08:49:16 +08:00
9380790ea8
re: The current netcdf-c release has some problems with the mingw platform on windows. Mostly they are path issues. Changes to support mingw+msys2: ------------------------------- * Enable option of looking into the windows registry to find the mingw root path. In aid of proper path handling. * Add mingw+msys as a specific platform in configure.ac and move testing of the platform to the front so it is available early. * Handle mingw X libncpoco (dynamic loader) properly even though mingw does not yet support it. * Handle mingw X plugins properly even though mingw does not yet support it. * Alias pwd='pwd -W' to better handle paths in shell scripts. * Plus a number of other minor compile irritations. * Disallow the use of multiple nc_open's on the same file for windows (and mingw) because windows does not seem to handle these properly. Not sure why we did not catch this earlier. * Add mountpoint info to dpathmgr.c to help support mingw. * Cleanup dpathmgr conversions. Known problems: --------------- * I have not been able to get shared libraries to work, so plugins/filters must be disabled. * There is some kind of problem with libcurl that I have not solved, so all uses of libcurl (currently DAP+Byterange) must be disabled. Misc. other fixes: ------------------ * Cleanup the relationship between ENABLE_PLUGINS and various other flags in CMakeLists.txt and configure.ac. * Re-arrange the TESTDIRS order in Makefile.am. * Add pseudo-breakpoint to nclog.[ch] for debugging. * Improve the documentation of the path manager code in ncpathmgr.h * Add better support for relative paths in dpathmgr.c * Default the mode args to NCfopen to include "b" (binary) for windows. * Add optional debugging output in various places. * Make sure that everything builds with plugins disabled. * Fix numerous (s)printf inconsistencies betweenb the format spec and the arguments.
573 lines
16 KiB
C
573 lines
16 KiB
C
/* Copyright 2005-2018 University Corporation for Atmospheric
|
|
Research/Unidata. */
|
|
|
|
/**
|
|
* @file
|
|
* @internal This header file contains prototypes and initialization
|
|
* for the ZARR dispatch layer.
|
|
*
|
|
* @author Dennis Heimbigner, Ed Hartnett
|
|
*/
|
|
|
|
#include "zincludes.h"
|
|
|
|
static int NCZTR_create(const char *path, int cmode, size_t initialsz, int basepe, size_t *chunksizehintp, void *parameters, const struct NC_Dispatch *table, int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_create(path,cmode,initialsz,basepe,chunksizehintp,parameters,table,ncid);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_open(const char *path, int mode, int basepe, size_t *chunksizehintp,void *parameters, const struct NC_Dispatch *table, int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_open(path,mode,basepe,chunksizehintp,parameters,table,ncid);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_redef(int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_redef(ncid)");
|
|
stat = NCZ_redef(ncid);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR__enddef(int ncid,size_t h_minfree,size_t v_align,size_t v_minfree,size_t r_align)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ__enddef(ncid,h_minfree,v_align,v_minfree,r_align);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_sync(int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_sync(ncid);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_abort(int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_abort(ncid);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_close(int ncid, void* params)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_close(ncid,params);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_set_fill(int ncid, int fillmode, int *old)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_set_fill(ncid,fillmode,old)");
|
|
stat = NCZ_set_fill(ncid,fillmode,old);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_format(int ncid, int* formatp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_format(ncid,formatp)");
|
|
stat = NC4_inq_format(ncid,formatp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_format_extended(int ncid, int *formatp, int *modep)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_format_extended(ncid,formatp,modep)");
|
|
stat = NCZ_inq_format_extended(ncid,formatp,modep);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq(int ncid, int *ndimsp, int *nvarsp, int *nattsp, int *udimp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq(ncid,ndimsp,nvarsp,nattsp,udimp)");
|
|
stat = NCZ_inq(ncid,ndimsp,nvarsp,nattsp,udimp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_type(int ncid, nc_type xtype, char *name, size_t *size)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_type(ncid,xtype,name,size)");
|
|
stat = NC4_inq_type(ncid,xtype,name,size);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_dim(int ncid, const char *name, size_t len, int *idp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_dim(ncid,name,len,idp)");
|
|
stat = NCZ_def_dim(ncid,name,len,idp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_dimid(int ncid, const char *name, int *idp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_dimid(ncid,name,idp)");
|
|
stat = NC4_inq_dimid(ncid,name,idp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_dim(int ncid, int dimid, char *name, size_t *lenp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_dim(ncid,dimid,name,lenp)");
|
|
stat = NCZ_inq_dim(ncid,dimid,name,lenp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_unlimdim(int ncid, int *unlimdimidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_unlimdim(ncid,unlimdimidp)");
|
|
stat = NC4_inq_unlimdim(ncid,unlimdimidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_rename_dim(int ncid, int dimid, const char *name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_rename_dim(ncid,dimid,name)");
|
|
stat = NCZ_rename_dim(ncid,dimid,name);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_att(int ncid, int varid, const char *name, nc_type *xtypep, size_t *lenp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_att(ncid,varid,name,xtypep,lenp)");
|
|
stat = NCZ_inq_att(ncid,varid,name,xtypep,lenp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_attid(int ncid, int varid, const char* name, int *idp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_attid(ncid,varid,name,idp)");
|
|
stat = NCZ_inq_attid(ncid,varid,name,idp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_attname(int ncid, int varid, int attnum, char *name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_attname(ncid,varid,attnum,name)");
|
|
stat = NCZ_inq_attname(ncid,varid,attnum,name);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_rename_att(int ncid, int varid, const char* name, const char *newname)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_rename_att(ncid,varid,name,newname)");
|
|
stat = NCZ_rename_att(ncid,varid,name,newname);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_del_att(int ncid, int varid, const char *name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_del_att(ncid,varid,name)");
|
|
stat = NCZ_del_att(ncid,varid,name);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_get_att(int ncid, int varid, const char* name, void *data, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_get_att(ncid,varid,name,data,memtype)");
|
|
stat = NCZ_get_att(ncid,varid,name,data,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_put_att(int ncid, int varid, const char* name, nc_type filetype, size_t len, const void *data, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_put_att(ncid,varid,name,filetype,len,data,memtype)");
|
|
stat = NCZ_put_att(ncid,varid,name,filetype,len,data,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var(int ncid, const char* name, nc_type xtype, int ndims, const int *dimidsp, int *varidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_def_var(ncid,name,xtype,ndims,dimidsp,varidp);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_inq_varid(int ncid, const char* name, int *varidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_varid(ncid,name,varidp)");
|
|
stat = NC4_inq_varid(ncid,name,varidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_rename_var(int ncid, int varid, const char *name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_rename_var(ncid,varid,name);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_get_vara(int ncid, int varid, const size_t *startp, const size_t *countp, void *ip, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_get_vara(ncid,varid,startp,countp,ip,memtype)");
|
|
stat = NCZ_get_vara(ncid,varid,startp,countp,ip,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_put_vara(int ncid, int varid, const size_t *startp, const size_t *countp, const void *ip, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_put_vara(ncid,varid,startp,countp,ip,memtype)");
|
|
stat = NCZ_put_vara(ncid,varid,startp,countp,ip,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_var_all(int ncid, int varid, char *name, nc_type *xtypep, int *ndimsp, int *dimidsp, int *nattsp, int *shufflep, int *deflatep, int *deflate_levelp, int *fletcher32p, int *contiguousp, size_t *chunksizesp, int *no_fill, void *fill_valuep, int *endiannessp, unsigned int *idp, size_t *nparamsp, unsigned int *params)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_inq_var_all(ncid,varid,name,xtypep,ndimsp,dimidsp,nattsp,shufflep,deflatep,deflate_levelp,fletcher32p,contiguousp,chunksizesp,no_fill,fill_valuep,endiannessp,idp,nparamsp,params);
|
|
return stat;
|
|
}
|
|
|
|
static int NCZTR_var_par_access(int ncid, int varid, int par_access)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_var_par_access(ncid,varid,par_access)");
|
|
stat = NCZ_var_par_access(ncid,varid,par_access);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var_fill(int ncid, int varid, int no_fill, const void *fill_value)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_var_fill(ncid,varid,no_fill,fill_value)");
|
|
stat = NCZ_def_var_fill(ncid,varid,no_fill,fill_value);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_show_metadata(int ncid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_show_metadata(ncid)");
|
|
stat = NCZ_show_metadata(ncid);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_unlimdims(int ncid, int* n, int* uidsp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_unlimdims(ncid,n,uidsp)");
|
|
stat = NCZ_inq_unlimdims(ncid,n,uidsp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_ncid(int ncid, const char* name, int* grpidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_ncid(ncid,name,grpidp)");
|
|
stat = NC4_inq_ncid(ncid,name,grpidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_grps(int ncid, int* n, int* ncids)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_grps(ncid,n,ncids)");
|
|
stat = NC4_inq_grps(ncid,n,ncids);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_grpname(int ncid, char* name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_grpname(ncid,name)");
|
|
stat = NC4_inq_grpname(ncid,name);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_grpname_full(int ncid, size_t* lenp, char* fullname)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_grpname_full(ncid,lenp,fullname)");
|
|
stat = NC4_inq_grpname_full(ncid,lenp,fullname);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_grp_parent(int ncid, int* parentidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_grp_parent(ncid,parentidp)");
|
|
stat = NC4_inq_grp_parent(ncid,parentidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_grp_full_ncid(int ncid, const char* fullname, int* grpidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_grp_full_ncid(ncid,fullname,grpidp)");
|
|
stat = NC4_inq_grp_full_ncid(ncid,fullname,grpidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_varids(int ncid, int* nvars, int* varids)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_varids(ncid,nvars,varids)");
|
|
stat = NC4_inq_varids(ncid,nvars,varids);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_dimids(int ncid, int* ndims, int* dimids, int inclparents)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_dimids(ncid,ndims,dimids,inclparents)");
|
|
stat = NC4_inq_dimids(ncid,ndims,dimids,inclparents);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_typeids(int ncid, int* ntypes, int* typeids)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_typeids(ncid,ntypes,typeids)");
|
|
stat = NCZ_inq_typeids(ncid,ntypes,typeids);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_type_equal(int ncid1, nc_type tid1, int ncid2, nc_type tid2, int* eq)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_type_equal(ncid1,tid1,ncid2,tid2,eq)");
|
|
stat = NCZ_inq_type_equal(ncid1,tid1,ncid2,tid2,eq);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_grp(int parent, const char* name, int* grpid)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_grp(parent,name,grpid)");
|
|
stat = NCZ_def_grp(parent,name,grpid);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_rename_grp(int ncid, const char* name)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_rename_grp(ncid,name)");
|
|
stat = NCZ_rename_grp(ncid,name);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_user_type(int ncid, nc_type xtype, char* name, size_t* size, nc_type* basetid, size_t* nfields, int* classp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_inq_user_type(ncid,xtype,name,size,basetid,nfields,classp)");
|
|
stat = NC4_inq_user_type(ncid,xtype,name,size,basetid,nfields,classp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_typeid(int ncid, const char* name, nc_type* tidp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_typeid(ncid,name,tidp)");
|
|
stat = NCZ_inq_typeid(ncid,name,tidp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var_chunking(int ncid, int varid, int storage, const size_t *chunksizes)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_var_chunking(ncid,varid,storage,chunksizes)");
|
|
stat = NCZ_def_var_chunking(ncid,varid,storage,chunksizes);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var_endian(int ncid, int varid, int endian)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_var_endian(ncid,varid,endian)");
|
|
stat = NCZ_def_var_endian(ncid,varid,endian);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_set_var_chunk_cache(int ncid, int varid, size_t size, size_t nelems, float preemption)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_set_var_chunk_cache(ncid,varid,size,nelems,preemption)");
|
|
stat = NCZ_set_var_chunk_cache(ncid,varid,size,nelems,preemption);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_get_var_chunk_cache(int ncid, int varid, size_t *sizep, size_t *nelemsp, float *preemptionp)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NC4_get_var_chunk_cache(ncid,varid,sizep,nelemsp,preemptionp)");
|
|
stat = NC4_get_var_chunk_cache(ncid,varid,sizep,nelemsp,preemptionp);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_var_filter_ids(int ncid, int varid, size_t* nfilters, unsigned int* filterids)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_var_filter_ids(ncid,varid,nfilters,filterids)");
|
|
stat = NCZ_inq_var_filter_ids(ncid,varid,nfilters,filterids);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_inq_var_filter_info(int ncid, int varid, unsigned int id, size_t* nparams, unsigned int* params)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_inq_var_filter_info(ncid,varid,id,nparams,params)");
|
|
stat = NCZ_inq_var_filter_info(ncid,varid,id,nparams,params);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
|
|
static int NCZTR_get_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, void *ip, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_get_vars(ncid,varid,startp,countp,stridep,ip,memtype)");
|
|
stat = NCZ_get_vars(ncid,varid,startp,countp,stridep,ip,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_put_vars(int ncid, int varid, const size_t *startp, const size_t *countp, const ptrdiff_t *stridep, const void *ip, nc_type memtype)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_put_vars(ncid,varid,startp,countp,stridep,ip,memtype)");
|
|
stat = NCZ_put_vars(ncid,varid,startp,countp,stridep,ip,memtype);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
#if 0
|
|
static int NCZTR_def_var_deflate(int ncid, int varid, int shuffle, int deflate, int level)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_var_deflate(ncid,varid,shuffle,deflate,level)");
|
|
stat = NCZ_def_var_deflate(ncid,varid,shuffle,deflate,level);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var_fletcher32(int ncid, int varid, int fletcher32)
|
|
{
|
|
int stat = NC_NOERR;
|
|
ZTRACE(0,"NCZ_def_var_fletcher32(ncid,varid,fletcher32)");
|
|
stat = NCZ_def_var_fletcher32(ncid,varid,fletcher32);
|
|
return ZUNTRACE(stat);
|
|
}
|
|
|
|
static int NCZTR_def_var_filter(int ncid, int varid, unsigned int id, size_t nparams, const unsigned int *params)
|
|
{
|
|
int stat = NC_NOERR;
|
|
stat = NCZ_def_var_filter(ncid,varid,id,nparams,params);
|
|
return (stat);
|
|
}
|
|
|
|
#endif
|
|
|
|
static const NC_Dispatch NCZ_dispatcher_trace = {
|
|
|
|
NC_FORMATX_NCZARR,
|
|
NC_DISPATCH_VERSION,
|
|
|
|
NCZTR_create,
|
|
NCZTR_open,
|
|
|
|
NCZTR_redef,
|
|
NCZTR__enddef,
|
|
NCZTR_sync,
|
|
NCZTR_abort,
|
|
NCZTR_close,
|
|
NCZTR_set_fill,
|
|
NCZTR_inq_format,
|
|
NCZTR_inq_format_extended,
|
|
|
|
NCZTR_inq,
|
|
NCZTR_inq_type,
|
|
|
|
NCZTR_def_dim,
|
|
NCZTR_inq_dimid,
|
|
NCZTR_inq_dim,
|
|
NCZTR_inq_unlimdim,
|
|
NCZTR_rename_dim,
|
|
|
|
NCZTR_inq_att,
|
|
NCZTR_inq_attid,
|
|
NCZTR_inq_attname,
|
|
NCZTR_rename_att,
|
|
NCZTR_del_att,
|
|
NCZTR_get_att,
|
|
NCZTR_put_att,
|
|
|
|
NCZTR_def_var,
|
|
NCZTR_inq_varid,
|
|
NCZTR_rename_var,
|
|
NCZTR_get_vara,
|
|
NCZTR_put_vara,
|
|
NCZTR_get_vars,
|
|
NCZTR_put_vars,
|
|
NCDEFAULT_get_varm,
|
|
NCDEFAULT_put_varm,
|
|
|
|
NCZTR_inq_var_all,
|
|
|
|
NCZTR_var_par_access,
|
|
NCZTR_def_var_fill,
|
|
|
|
NCZTR_show_metadata,
|
|
NCZTR_inq_unlimdims,
|
|
|
|
NCZTR_inq_ncid,
|
|
NCZTR_inq_grps,
|
|
NCZTR_inq_grpname,
|
|
NCZTR_inq_grpname_full,
|
|
NCZTR_inq_grp_parent,
|
|
NCZTR_inq_grp_full_ncid,
|
|
NCZTR_inq_varids,
|
|
NCZTR_inq_dimids,
|
|
NCZTR_inq_typeids,
|
|
NCZTR_inq_type_equal,
|
|
NCZTR_def_grp,
|
|
NCZTR_rename_grp,
|
|
NCZTR_inq_user_type,
|
|
NCZTR_inq_typeid,
|
|
|
|
NC_NOTNC4_def_compound,
|
|
NC_NOTNC4_insert_compound,
|
|
NC_NOTNC4_insert_array_compound,
|
|
NC_NOTNC4_inq_compound_field,
|
|
NC_NOTNC4_inq_compound_fieldindex,
|
|
NC_NOTNC4_def_vlen,
|
|
NC_NOTNC4_put_vlen_element,
|
|
NC_NOTNC4_get_vlen_element,
|
|
NC_NOTNC4_def_enum,
|
|
NC_NOTNC4_insert_enum,
|
|
NC_NOTNC4_inq_enum_member,
|
|
NC_NOTNC4_inq_enum_ident,
|
|
NC_NOTNC4_def_opaque,
|
|
NC_NOTNC4_def_var_deflate,
|
|
NC_NOTNC4_def_var_fletcher32,
|
|
NCZTR_def_var_chunking,
|
|
NCZTR_def_var_endian,
|
|
NCZ_def_var_filter,
|
|
NCZTR_set_var_chunk_cache,
|
|
NCZTR_get_var_chunk_cache,
|
|
NCZTR_inq_var_filter_ids,
|
|
NCZTR_inq_var_filter_info,
|
|
NC_NOTNC4_def_var_quantize,
|
|
NC_NOTNC4_inq_var_quantize,
|
|
};
|
|
|