1/*
2 * Copyright 1996, University Corporation for Atmospheric Research
3 *      See netcdf/COPYRIGHT file for copying and redistribution conditions.
4 */
5#ifndef _NC3INTERNAL_
6#define _NC3INTERNAL_
7
8/*
9 * netcdf library 'private' data structures, objects and interfaces
10 */
11#include <config.h>
12#include <stddef.h> /* size_t */
13#ifndef HAVE_STDINT_H
14#  include "pstdint.h" /* attempts to define uint32_t etc portably */
15#else
16#  include <stdint.h>
17#endif /* HAVE_STDINT_H */
18#include <sys/types.h> /* off_t */
19#ifdef USE_PARALLEL
20#include <netcdf_par.h>
21#else
22#include <netcdf.h>
23#endif /* USE_PARALLEL */
24
25/* Always needed */
26#include "nc.h"
27
28#ifndef NC_ARRAY_GROWBY
29#define NC_ARRAY_GROWBY 4
30#endif
31
32/*
33 * The extern size of an empty
34 * netcdf version 1 file.
35 * The initial value of ncp->xsz.
36 */
37/* For classic */
38#define MIN_NC3_XSZ 32
39/* For cdf5 */
40#define MIN_NC5_XSZ 48
41
42/* Forward */
43struct ncio;
44typedef struct NC3_INFO NC3_INFO;
45
46/*
47 *  The internal data types
48 */
49typedef enum {
50 NC_UNSPECIFIED = 0,
51/* future NC_BITFIELD = 7, */
52/* NC_STRING = 8, */
53 NC_DIMENSION = 10,
54 NC_VARIABLE = 11,
55 NC_ATTRIBUTE = 12
56NCtype;
57
58
59/*! Hashmap-related structs.
60  NOTE: 'data' is the dimid or varid which is non-negative.
61  we store the dimid+1 so a valid entry will have
62  data > 0
63*/
64typedef struct {
65  long data;
66  int flags;
67  unsigned long key;
68hEntry;
69
70typedef struct s_hashmap {
71  hEntrytable;
72  unsigned long size;
73  unsigned long count;
74NC_hashmap;
75
76
77/*
78 * NC dimension structure
79 */
80typedef struct {
81 /* all xdr'd */
82 NC_string *name;
83 size_t size;
84NC_dim;
85
86typedef struct NC_dimarray {
87 size_t nalloc; /* number allocated >= nelems */
88 /* below gets xdr'd */
89 /* NCtype type = NC_DIMENSION */
90 size_t nelems; /* length of the array */
91 NC_hashmap *hashmap;
92 NC_dim **value;
93NC_dimarray;
94
95/* Begin defined in dim.c */
96
97extern void
98free_NC_dim(NC_dim *dimp);
99
100extern NC_dim *
101new_x_NC_dim(NC_string *name);
102
103extern int
104find_NC_Udim(const NC_dimarray *ncapNC_dim **dimpp);
105
106/* dimarray */
107
108extern void
109free_NC_dimarrayV0(NC_dimarray *ncap);
110
111extern void
112free_NC_dimarrayV(NC_dimarray *ncap);
113
114extern int
115dup_NC_dimarrayV(NC_dimarray *ncap, const NC_dimarray *ref);
116
117extern NC_dim *
118elem_NC_dimarray(const NC_dimarray *ncap, size_t elem);
119
120/* End defined in dim.c */
121
122/*
123 * NC attribute
124 */
125typedef struct {
126 size_t xsz; /* amount of space at xvalue */
127 /* below gets xdr'd */
128 NC_string *name;
129 nc_type type; /* the discriminant */
130 size_t nelems; /* length of the array */
131 void *xvalue; /* the actual data, in external representation */
132NC_attr;
133
134typedef struct NC_attrarray {
135 size_t nalloc; /* number allocated >= nelems */
136 /* below gets xdr'd */
137 /* NCtype type = NC_ATTRIBUTE */
138 size_t nelems; /* length of the array */
139 NC_attr **value;
140NC_attrarray;
141
142/* Begin defined in attr.c */
143
144extern void
145free_NC_attr(NC_attr *attrp);
146
147extern NC_attr *
148new_x_NC_attr(
149 NC_string *strp,
150 nc_type type,
151 size_t nelems);
152
153extern NC_attr **
154NC_findattr(const NC_attrarray *ncap, const char *name);
155
156/* attrarray */
157
158extern void
159free_NC_attrarrayV0(NC_attrarray *ncap);
160
161extern void
162free_NC_attrarrayV(NC_attrarray *ncap);
163
164extern int
165dup_NC_attrarrayV(NC_attrarray *ncap, const NC_attrarray *ref);
166
167extern NC_attr *
168elem_NC_attrarray(const NC_attrarray *ncap, size_t elem);
169
170/* End defined in attr.c */
171
172
173/*
174 * NC variable: description and data
175 */
176typedef struct NC_var {
177 size_t xsz; /* xszof 1 element */
178 size_t *shape; /* compiled info: dim->size of each dim */
179 off_t *dsizes; /* compiled info: the right to left product of shape */
180 /* below gets xdr'd */
181 NC_string *name;
182 /* next two: formerly NC_iarray *assoc */ /* user definition */
183 size_t ndims; /* assoc->count */
184 int *dimids; /* assoc->value */
185 NC_attrarray attrs;
186 nc_type type; /* the discriminant */
187 size_t len; /* the total length originally allocated */
188 off_t begin;
189NC_var;
190
191typedef struct NC_vararray {
192 size_t nalloc; /* number allocated >= nelems */
193 /* below gets xdr'd */
194 /* NCtype type = NC_VARIABLE */
195 size_t nelems; /* length of the array */
196  NC_hashmap *hashmap;
197  NC_var **value;
198NC_vararray;
199
200/* Begin defined in lookup3.c */
201
202/* End defined in lookup3.c */
203
204/* Begin defined in var.c */
205
206extern void
207free_NC_var(NC_var *varp);
208
209extern NC_var *
210new_x_NC_var(
211 NC_string *strp,
212 size_t ndims);
213
214/* vararray */
215
216extern void
217free_NC_vararrayV0(NC_vararray *ncap);
218
219extern void
220free_NC_vararrayV(NC_vararray *ncap);
221
222extern int
223dup_NC_vararrayV(NC_vararray *ncap, const NC_vararray *ref);
224
225extern int
226NC_var_shape(NC_var *varp, const NC_dimarray *dims);
227
228extern int
229NC_findvar(const NC_vararray *ncap, const char *nameNC_var **varpp);
230
231extern int
232NC_check_vlen(NC_var *varp, size_t vlen_max);
233
234extern int
235NC_lookupvar(NC3_INFOncp, int varidNC_var **varp);
236
237/* End defined in var.c */
238
239/* defined in nc_hashmap.c */
240/** Creates a new hashmap near the given size. */
241extern NC_hashmapNC_hashmapCreate(unsigned long startsize);
242
243/** Inserts a new element into the hashmap. */
244extern void NC_hashmapAddDim(const NC_dimarray*, long data, const char *name);
245
246/** Removes the storage for the element of the key and returns the element. */
247extern long NC_hashmapRemoveDim(const NC_dimarray*, const char *name);
248
249/** Returns the element for the key. */
250extern long NC_hashmapGetDim(const NC_dimarray*, const char *name);
251
252/** Inserts a new element into the hashmap. */
253extern void NC_hashmapAddVar(const NC_vararray*, long data, const char *name);
254
255/** Removes the storage for the element of the key and returns the element. */
256extern long NC_hashmapRemoveVar(const NC_vararray*, const char *name);
257
258/** Returns the element for the key. */
259extern long NC_hashmapGetVar(const NC_vararray*, const char *name);
260
261/** Returns the number of saved elements. */
262extern unsigned long NC_hashmapCount(NC_hashmap*);
263
264/** Removes the hashmap structure. */
265extern void NC_hashmapDelete(NC_hashmap*);
266
267/* end defined in nc_hashmap.c */
268
269
270#define IS_RECVAR(vp) \
271 ((vp)->shape != NULL ? (*(vp)->shape == NC_UNLIMITED) : 0 )
272
273#ifdef LOCKNUMREC
274/*
275 * typedef SHMEM type
276 * for whenever the SHMEM functions can handle other than shorts
277 */
278typedef unsigned short int ushmem_t;
279typedef short int  shmem_t;
280#endif
281
282struct NC3_INFO {
283 /* contains the previous NC during redef. */
284 NC3_INFO *old;
285 /* flags */
286#define NC_CREAT 2 /* in create phase, cleared by ncendef */
287#define NC_INDEF 8 /* in define mode, cleared by ncendef */
288#define NC_NSYNC 0x10 /* synchronise numrecs on change */
289#define NC_HSYNC 0x20 /* synchronise whole header on change */
290#define NC_NDIRTY 0x40 /* numrecs has changed */
291#define NC_HDIRTY 0x80  /* header info has changed */
292/* NC_NOFILL in netcdf.h, historical interface */
293 int flags;
294 struct ncionciop;
295 size_t chunk; /* largest extent this layer will request from ncio->get() */
296 size_t xsz; /* external size of this header, == var[0].begin */
297 off_t begin_var; /* position of the first (non-record) var */
298 off_t begin_rec; /* position of the first 'record' */
299        /* Don't constrain maximum size of record unnecessarily */
300#if SIZEOF_OFF_T > SIZEOF_SIZE_T
301        off_t recsize;   /* length of 'record' */
302#else
303 size_t recsize;  /* length of 'record' */
304#endif
305 /* below gets xdr'd */
306 size_t numrecs; /* number of 'records' allocated */
307 NC_dimarray dims;
308 NC_attrarray attrs;
309 NC_vararray vars;
310#ifdef LOCKNUMREC
311/* size and named indexes for the lock array protecting NC.numrecs */
312#  define LOCKNUMREC_DIM 4
313#  define LOCKNUMREC_VALUE 0
314#  define LOCKNUMREC_LOCK 1
315#  define LOCKNUMREC_SERVING 2
316#  define LOCKNUMREC_BASEPE 3
317 /* Used on Cray T3E MPP to maintain the
318  * integrity of numrecs for an unlimited dimension
319  */
320 ushmem_t lock[LOCKNUMREC_DIM];
321#endif
322};
323
324#define NC_readonly(ncp) \
325 (!fIsSet((ncp)->nciop->ioflagsNC_WRITE))
326
327#define NC_set_readonly(ncp) \
328 fClr((ncp)->flagsNC_WRITE)
329
330#define NC_IsNew(ncp) \
331 fIsSet((ncp)->flagsNC_CREAT)
332
333#define NC_indef(ncp) \
334 (NC_IsNew(ncp) || fIsSet((ncp)->flagsNC_INDEF))
335
336#define set_NC_ndirty(ncp) \
337 fSet((ncp)->flagsNC_NDIRTY)
338
339#define NC_ndirty(ncp) \
340 fIsSet((ncp)->flagsNC_NDIRTY)
341
342#define set_NC_hdirty(ncp) \
343 fSet((ncp)->flagsNC_HDIRTY)
344
345#define NC_hdirty(ncp) \
346 fIsSet((ncp)->flagsNC_HDIRTY)
347
348#define NC_dofill(ncp) \
349 (!fIsSet((ncp)->flagsNC_NOFILL))
350
351#define NC_doHsync(ncp) \
352 fIsSet((ncp)->flagsNC_HSYNC)
353
354#define NC_doNsync(ncp) \
355 fIsSet((ncp)->flagsNC_NSYNC)
356
357#ifndef LOCKNUMREC
358#  define NC_get_numrecs(nc3i) \
359 ((nc3i)->numrecs)
360
361#  define NC_set_numrecs(nc3inrecs) \
362 {(nc3i)->numrecs = (nrecs);}
363
364#  define NC_increase_numrecs(nc3inrecs) \
365 {if((nrecs) > (nc3i)->numrecs) ((nc3i)->numrecs = (nrecs));}
366#else
367 size_t NC_get_numrecs(const NC3_INFO *nc3i);
368 void   NC_set_numrecs(NC3_INFO *nc3i, size_t nrecs);
369 void   NC_increase_numrecs(NC3_INFO *nc3i, size_t nrecs);
370#endif
371
372/* Begin defined in nc.c */
373
374extern int
375nc3_cktype(int modenc_type datatype);
376
377extern size_t
378ncx_howmany(nc_type type, size_t xbufsize);
379
380extern int
381read_numrecs(NC3_INFOncp);
382
383extern int
384write_numrecs(NC3_INFOncp);
385
386extern int
387NC_sync(NC3_INFOncp);
388
389extern int
390NC_calcsize(const NC3_INFOncpoff_t *filesizep);
391
392/* End defined in nc.c */
393/* Begin defined in v1hpg.c */
394
395extern size_t
396ncx_len_NC(const NC3_INFOncp, size_t sizeof_off_t);
397
398extern int
399ncx_put_NC(const NC3_INFOncp, void **xppoff_t offset, size_t extent);
400
401extern int
402nc_get_NC(NC3_INFOncp);
403
404/* End defined in v1hpg.c */
405/* Begin defined in putget.c */
406
407extern int
408fill_NC_var(NC3_INFOncp, const NC_var *varp, size_t varsize, size_t recno);
409
410extern int
411nc_inq_rec(int ncid, size_t *nrecvars, int *recvarids, size_t *recsizes);
412
413extern int
414nc_get_rec(int ncid, size_t recnum, void **datap);
415
416extern int
417nc_put_rec(int ncid, size_t recnum, void *const *datap);
418
419/* End defined in putget.c */
420
421/* Define accessors for the dispatchdata */
422#define NC3_DATA(nc) ((NC3_INFO*)(nc)->dispatchdata)
423#define NC3_DATA_SET(nc,data) ((nc)->dispatchdata = (void*)(data))
424
425#endif /* _NC3INTERNAL_ */


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