1/*********************************************************************
2  *   Copyright 1993, UCAR/Unidata
3  *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
4  *********************************************************************/
5
6#ifndef NCCOMMON_H
7#define NCCOMMON_H 1
8
9/* Mnemonics */
10#ifndef BOOL
11#define BOOL int
12#endif
13#ifndef TRUE
14#define TRUE 1
15#define FALSE 0
16#endif
17
18#ifndef nullfree
19#define nullfree(m) {if((m)!=NULL) {free(m);} else {}}
20#endif
21
22/* Misc. code controls */
23#define FILLCONSTRAINT TRUE
24
25/* Hopefully, this flag will someday not  be needed */
26#define COLUMBIA_HACK "columbia.edu"
27
28/* Use an extended version of the netCDF-4 type system */
29#define NC_URL 50
30#define NC_SET 51
31/* Merge relevant translations of OC types */
32#define NC_Dataset 52
33#define NC_Sequence 53
34#define NC_Structure 54
35#define NC_Grid 55
36#define NC_Dimension 56
37#define NC_Atomic 57
38
39#undef OCCOMPILEBYDEFAULT
40
41#define DEFAULTSTRINGLENGTH 64
42/* The sequence limit default is zero because
43   most servers do not implement projections
44   on sequences.
45*/
46#define DEFAULTSEQLIMIT 0
47
48/**************************************************/
49/* sigh, do the forwards */
50struct NCDAPCOMMON;
51struct NCprojection;
52struct NCselection;
53struct Getvara;
54struct NCcachenode;
55struct NCcache;
56struct NCslice;
57struct NCsegment;
58struct OClist;
59/**************************************************/
60/*
61Collect single bit flags that
62affect the operation of the system.
63*/
64
65typedef unsigned int NCFLAGS;
66#  define SETFLAG(controls,flag) ((controls.flags) |= (flag))
67#  define CLRFLAG(controls,flag) ((controls.flags) &= ~(flag))
68#  define FLAGSET(controls,flag) (((controls.flags) & (flag)) != 0)
69
70/* Defined flags */
71#define NCF_NC3             (0x0001) /* DAP->netcdf-3 */
72#define NCF_NC4             (0x0002) /* DAP->netcdf-4 */
73#define NCF_NCDAP           (0x0004) /* Do libnc-dap mimic */
74#define NCF_CACHE           (0x0008) /* Cache enabled/disabled */
75#define NCF_UPGRADE         (0x0010) /* Do proper type upgrades */
76#define NCF_UNCONSTRAINABLE (0x0020) /* Not a constrainable URL */
77#define NCF_SHOWFETCH       (0x0040) /* show fetch calls */
78#define NCF_ONDISK          (0x0080) /* cause oc to store data on disk */
79#define NCF_WHOLEVAR        (0x0100) /* retrieve only whole variables (as opposed to partial variable) into cache */
80#define NCF_PREFETCH        (0x0200) /* Cache prefetch enabled/disabled */
81#define NCF_PREFETCH_EAGER  (0x0400) /* Do eager prefetch; 0=>lazy */
82#define NCF_PREFETCH_ALL    (0x0800) /* Prefetch all variables */
83#ifdef COLUMBIA_HACK
84#define NCF_COLUMBIA        (0x80000000) /* Hack for columbia server */
85#endif
86
87/* Define all the default on flags */
88#define DFALT_ON_FLAGS (NCF_CACHE|NCF_PREFETCH)
89
90typedef struct NCCONTROLS {
91    NCFLAGS  flags;
92NCCONTROLS;
93
94struct NCTMODEL {
95    int translation;
96    char* model;
97    unsigned int flags;
98};
99
100/* Define the cache control flags */
101
102
103/* Detail information about each cache item */
104typedef struct NCcachenode {
105    int wholevariable; /* does this cache node only have wholevariables? */
106    int isprefetch;
107    off_t xdrsize;
108    DCEconstraintconstraint; /* as used to create this node */
109    NClistvars; /* vars potentially covered by this cache node */
110    struct CDFnodedatadds;
111    OCddsnode ocroot;
112    OCdatanode content;
113NCcachenode;
114
115
116/* All cache info */
117typedef struct NCcache {
118    size_t cachelimit; /* max total size for all cached entries */
119    size_t cachesize; /* current size */
120    size_t cachecount; /* max # nodes in cache */
121    NCcachenodeprefetch;
122    NClistnodes; /* cache nodes other than prefetch */
123NCcache;
124
125/**************************************************/
126/* The DAP packet info from OC */
127typedef struct NCOC {
128    OClink conn;
129    char* rawurltext; /* as given to nc3d_open */
130    char* urltext;    /* as modified by nc3d_open */
131    NCURIurl;      /* parse of rawuritext */
132    OCdasnode ocdasroot;
133    DCEconstraintdapconstraint; /* from url */
134    int inmemory; /* store fetched data in memory? */
135NCOC;
136
137typedef struct NCCDF {
138    struct CDFnodeddsroot; /* constrained dds */
139    struct CDFnodefullddsroot; /* unconstrained dds */
140    NClist*  projectedvars; /* vars appearing in nc_open url projections */
141    unsigned int defaultstringlength;
142    unsigned int defaultsequencelimit; /* global sequence limit;0=>no limit */
143    struct NCcachecache;
144    size_t fetchlimit;
145    size_t smallsizelimit; /* what constitutes a small object? */
146    size_t totalestimatedsize;
147    const char* separator; /* constant; do not free */
148    /* global string dimension */
149    struct CDFnodeglobalstringdim;
150    char* recorddimname; /* From DODS_EXTRA */
151    struct CDFnoderecorddim;
152#if 0
153    /* libncdap4 only */
154    NClist*  usertypes; /* nodes which will represent netcdf types */
155#endif
156NCCDF;
157
158/* Define a structure holding common info for NCDAP */
159
160typedef struct NCDAPCOMMON {
161    NC*   controller; /* Parent instance of NCDAPCOMMON */
162    NCCDF cdf;
163    NCOC oc;
164    NCCONTROLS controls; /* Control flags and parameters */
165    int nc3id; /* nc3 file ncid used to hold metadata */
166NCDAPCOMMON;
167
168/**************************************************/
169/* Create our own node tree to mimic ocnode trees*/
170
171/* Each root CDFnode contains info about the whole tree */
172typedef struct CDFtree {
173    OCddsnode ocroot;
174    OCdxd occlass;
175    NClistnodes; /* all nodes in tree*/
176    struct CDFnoderoot; /* cross link */
177    struct NCDAPCOMMON*          owner;
178    /* Collected sets of useful nodes */
179    NClist*  varnodes; /* nodes which can represent netcdf variables */
180    NClist*  seqnodes; /* sequence nodes; */
181    NClist*  gridnodes; /* grid nodes */
182    NClist*  dimnodes; /* (base) dimension nodes */
183    /* Classification flags */
184    int restructed; /* Was this tree passed thru restruct? */
185CDFtree;
186
187/* Track the kinds of dimensions */
188typedef int CDFdimflags;
189#define CDFDIMNORMAL 0x0
190#define CDFDIMSEQ 0x1
191#define CDFDIMSTRING 0x2
192#define CDFDIMCLONE 0x4
193#define CDFDIMRECORD 0x20
194
195#define DIMFLAG(d,flag) ((d)->dim.dimflags & (flag))
196#define DIMFLAGSET(d,flag) ((d)->dim.dimflags |= (flag))
197#define DIMFLAGCLR(d,flag) ((d)->dim.dimflags &= ~(flag))
198
199typedef struct CDFdim {
200    CDFdimflags    dimflags;
201    struct CDFnodebasedim; /* for duplicate dimensions*/
202    struct CDFnodearray; /* parent array node */
203    size_t declsize;     /* from constrained DDS*/
204    size_t declsize0;     /* from unconstrained DDS*/
205    int    index1;          /* dimension name index +1; 0=>no index */
206CDFdim;
207
208typedef struct CDFarray {
209    NClist*  dimsetall;   /* dimsetplus + inherited */
210    NClist*  dimsettrans; /* dimset0 plus inherited(transitive closure) */
211    NClist*  dimsetplus;  /* dimset0 + pseudo */
212    NClist*  dimset0;     /* original dims from the dds */
213    struct CDFnodestringdim;
214    /* Track sequence related information */
215    struct CDFnodeseqdim; /* if this node is a sequence */
216    /* note: unlike string dim; seqdim is also stored in dimensions vector */
217    struct CDFnodesequence; /* containing usable sequence, if any */
218    struct CDFnodebasevar; /* for duplicate grid variables*/
219CDFarray;
220
221typedef struct NCattribute {
222    char*   name;
223    nc_type etype; /* dap type of the attribute */
224    NClistvalues; /* strings come from the oc values */
225    int     invisible; /* Do not materialize to the user */
226NCattribute;
227
228/* Extend as additional DODS attribute values are defined */
229typedef struct NCDODS {
230    size_t maxstrlen;
231    char* dimname;
232NCDODS;
233
234typedef struct NCalignment {
235    unsigned long    size; /* size of single instance of this type*/
236    unsigned long    alignment; /* alignment of this field */
237    unsigned long    offset;    /* offset of this field in parent */
238NCalignment;
239
240typedef struct NCtypesize {
241    BOOL             aligned; /*  have instance and field been defined? */
242    NCalignment      instance; /* Alignment, etc for instance data */
243    NCalignment      field; /* Alignment, etc WRT to parent */
244NCtypesize;
245
246/* Closely mimics struct OCnode*/
247typedef struct CDFnode {
248    nc_type          nctype;     /* e.g. var, dimension  */
249    nc_type          etype;      /* e.g. NC_INT, NC_FLOAT if applicable,*/
250    char*            ocname;     /* oc base name */
251    char*            ncbasename; /* generally cdflegalname(ocname) */
252    char*            ncfullname; /* complete path name from root to this node*/
253    OCddsnode        ocnode;     /* oc mirror node*/
254    struct CDFnode*  group;  /* null => in root group */
255    struct CDFnode*  container;  /* e.g. struct or sequence, but not group */
256    struct CDFnode*  root;
257    CDFtree*         tree;       /* root level metadata;only defined if root*/
258    CDFdim           dim;        /* nctype == dimension */
259    CDFarray         array;      /* nctype == grid,var,etc. with dimensions */
260    NClist*          subnodes;      /* if nctype == grid, sequence, etc. */
261    NClist*          attributes;    /*NClist<NCattribute*>*/
262    NCDODS           dodsspecial;   /* special attributes like maxStrlen */
263    nc_type          externaltype;  /* the type as represented to nc_inq*/
264    int              ncid;          /* relevant NC id for this object*/
265    unsigned long    maxstringlength;
266    unsigned long    sequencelimit; /* 0=>unlimited */
267    BOOL      usesequence;   /* If this sequence is usable */
268    BOOL             elided;        /* 1 => node does not partipate in naming*/
269    struct CDFnode*  basenode;      /* derived tree map to pattern tree */
270    BOOL      invisible;     /* 1 => do not show to user */
271    BOOL      zerodim;       /* 1 => node has a zero dimension */
272    /* These two flags track the effects on grids of constraints */
273    BOOL             nc_virtual;       /* node added by regrid */
274    struct CDFnodeattachment;     /* DDS<->DATADDS cross link*/
275    struct CDFnodepattern;       /* temporary field for regridding */
276    /* Fields for use by libncdap4 */
277    NCtypesize       typesize;
278    int              typeid;        /* when treating field as type */
279    int              basetypeid;    /* when typeid is vlen */
280    char*            typename;
281    char*            vlenname;      /* for sequence types */
282    int              singleton;     /* for singleton sequences */
283    unsigned long    estimatedsize; /* > 0 Only for var nodes */
284    BOOL             whole;         /* projected as whole node */
285    BOOL             prefetchable;  /* eligible to be prefetched (if whole) */
286CDFnode;
287
288/**************************************************/
289/* Shared procedures */
290
291/* From error.c*/
292extern NCerror ocerrtoncerr(OCerror);
293
294extern NCerror attach(CDFnodexrootCDFnodeddstarget);
295extern void unattach(CDFnode*);
296extern int nodematch(CDFnodenode1CDFnodenode2);
297extern int simplenodematch(CDFnodenode1CDFnodenode2);
298extern CDFnodefindxnode(CDFnodetargetCDFnodexroot);
299extern int constrainable(NCURI*);
300extern char* makeconstraintstring(DCEconstraint*);
301extern size_t estimatedataddssize(CDFnodedatadds);
302extern void canonicalprojection(NClist*, NClist*);
303extern NClistgetalldims(NCDAPCOMMONnccomm, int visibleonly);
304
305/* From cdf.c */
306extern NCerror fixgrid(NCDAPCOMMONdrnoCDFnodegrid);
307extern NCerror computecdfinfo(NCDAPCOMMON*, NClist*);
308extern char* cdfname(char* basename);
309extern NCerror augmentddstree(NCDAPCOMMON*, NClist*);
310extern NCerror computecdfdimnames(NCDAPCOMMON*);
311extern NCerror buildcdftree(NCDAPCOMMON*, OCddsnodeOCdxdCDFnode**);
312extern CDFnodemakecdfnode(NCDAPCOMMON*, char* nmOCtype,
313     /*optional*/ OCddsnode ocnodeCDFnodecontainer);
314extern void freecdfroot(CDFnode*);
315
316extern NCerror dimimprint(NCDAPCOMMON*);
317extern NCerror definedimsets(NCDAPCOMMON*,CDFtree*);
318extern NCerror definedimsettrans(NCDAPCOMMON*,CDFtree*);
319
320/* From cache.c */
321extern int iscached(NCDAPCOMMON*, CDFnodetargetNCcachenode** cachenodep);
322extern NCerror prefetchdata(NCDAPCOMMON*);
323extern NCerror markprefetch(NCDAPCOMMON*);
324extern NCerror buildcachenode(NCDAPCOMMON*,
325         DCEconstraintconstraint,
326 NClistvarlist,
327 NCcachenode** cachep,
328 NCFLAGS flags);
329extern NCcachenodecreatenccachenode(void);
330extern void freenccachenode(NCDAPCOMMON*, NCcachenodenode);
331extern NCcachecreatenccache(void);
332extern void freenccache(NCDAPCOMMON*, NCcachecache);
333
334/* Add an extra function whose sole purpose is to allow
335   configure(.ac) to test for the presence of thiscode.
336*/
337extern int nc__opendap(void);
338
339/* Define accessors for the dispatchdata */
340#define NCD2_DATA(nc) ((NCDAPCOMMON*)(nc)->dispatchdata)
341#define NCD2_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
342
343#define getncid(drno) (((NC*)drno)->ext_ncid)
344#define getdap(drno) ((NCDAPCOMMON*)((NC*)drno)->dispatchdata)
345#define getnc3id(drno) (getdap(drno)->nc3id)
346
347#endif /*NCCOMMON_H*/


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