/src/gdal/netcdf-c-4.7.4/libdispatch/dvarinq.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Copyright 2018 University Corporation for Atmospheric |
2 | | Research/Unidata. See COPYRIGHT file for more info. */ |
3 | | /*! \file |
4 | | Functions for inquiring about variables. |
5 | | |
6 | | */ |
7 | | |
8 | | #include "config.h" |
9 | | #include "netcdf.h" |
10 | | #include "netcdf_filter.h" |
11 | | #include "ncdispatch.h" |
12 | | #include "nc4internal.h" |
13 | | #ifdef USE_HDF5 |
14 | | #include <hdf5.h> |
15 | | #endif /* USE_HDF5 */ |
16 | | |
17 | | /** \name Learning about Variables |
18 | | |
19 | | Functions to learn about the variables in a file. */ |
20 | | /*! \{ */ /* All these functions are part of this named group... */ |
21 | | |
22 | | /** |
23 | | \ingroup variables |
24 | | Find the ID of a variable, from the name. |
25 | | |
26 | | The function nc_inq_varid returns the ID of a netCDF variable, given |
27 | | its name. |
28 | | |
29 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
30 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
31 | | nc_inq_ncid(). |
32 | | |
33 | | \param name Name of the variable. |
34 | | |
35 | | \param varidp Pointer to location for returned variable ID. \ref |
36 | | ignored_if_null. |
37 | | |
38 | | \returns ::NC_NOERR No error. |
39 | | \returns ::NC_EBADID Bad ncid. |
40 | | \returns ::NC_ENOTVAR Invalid variable ID. |
41 | | |
42 | | \section nc_inq_varid_example4 Example |
43 | | |
44 | | Here is an example using nc_inq_varid to find out the ID of a variable |
45 | | named rh in an existing netCDF dataset named foo.nc: |
46 | | |
47 | | \code |
48 | | #include <netcdf.h> |
49 | | ... |
50 | | int status, ncid, rh_id; |
51 | | ... |
52 | | status = nc_open("foo.nc", NC_NOWRITE, &ncid); |
53 | | if (status != NC_NOERR) handle_error(status); |
54 | | ... |
55 | | status = nc_inq_varid (ncid, "rh", &rh_id); |
56 | | if (status != NC_NOERR) handle_error(status); |
57 | | \endcode |
58 | | */ |
59 | | int |
60 | | nc_inq_varid(int ncid, const char *name, int *varidp) |
61 | 33.2k | { |
62 | 33.2k | NC* ncp; |
63 | 33.2k | int stat = NC_check_id(ncid, &ncp); |
64 | 33.2k | if(stat != NC_NOERR) return stat; |
65 | 33.2k | return ncp->dispatch->inq_varid(ncid, name, varidp); |
66 | 33.2k | } |
67 | | |
68 | | /** |
69 | | \ingroup variables |
70 | | Learn about a variable. |
71 | | |
72 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
73 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
74 | | nc_inq_ncid(). |
75 | | |
76 | | \param varid Variable ID |
77 | | |
78 | | \param name Returned \ref object_name of variable. \ref |
79 | | ignored_if_null. |
80 | | |
81 | | \param xtypep Pointer where typeid will be stored. \ref ignored_if_null. |
82 | | |
83 | | \param ndimsp Pointer where number of dimensions will be |
84 | | stored. \ref ignored_if_null. |
85 | | |
86 | | \param dimidsp Pointer where array of dimension IDs will be |
87 | | stored. \ref ignored_if_null. |
88 | | |
89 | | \param nattsp Pointer where number of attributes will be |
90 | | stored. \ref ignored_if_null. |
91 | | |
92 | | \returns ::NC_NOERR No error. |
93 | | \returns ::NC_EBADID Bad ncid. |
94 | | \returns ::NC_ENOTVAR Invalid variable ID. |
95 | | |
96 | | \section nc_inq_var_example5 Example |
97 | | |
98 | | Here is an example using nc_inq_var() to find out about a variable named |
99 | | rh in an existing netCDF dataset named foo.nc: |
100 | | |
101 | | \code |
102 | | #include <netcdf.h> |
103 | | ... |
104 | | int status |
105 | | int ncid; |
106 | | int rh_id; |
107 | | nc_type rh_type; |
108 | | int rh_ndims; |
109 | | int rh_dimids[NC_MAX_VAR_DIMS]; |
110 | | int rh_natts |
111 | | ... |
112 | | status = nc_open ("foo.nc", NC_NOWRITE, &ncid); |
113 | | if (status != NC_NOERR) handle_error(status); |
114 | | ... |
115 | | status = nc_inq_varid (ncid, "rh", &rh_id); |
116 | | if (status != NC_NOERR) handle_error(status); |
117 | | status = nc_inq_var (ncid, rh_id, 0, &rh_type, &rh_ndims, rh_dimids, |
118 | | &rh_natts); |
119 | | if (status != NC_NOERR) handle_error(status); |
120 | | \endcode |
121 | | |
122 | | */ |
123 | | int |
124 | | nc_inq_var(int ncid, int varid, char *name, nc_type *xtypep, |
125 | | int *ndimsp, int *dimidsp, int *nattsp) |
126 | 73.0k | { |
127 | 73.0k | NC* ncp; |
128 | 73.0k | int stat = NC_check_id(ncid, &ncp); |
129 | 73.0k | if(stat != NC_NOERR) return stat; |
130 | 73.0k | TRACE(nc_inq_var); |
131 | 73.0k | return ncp->dispatch->inq_var_all(ncid, varid, name, xtypep, ndimsp, |
132 | 73.0k | dimidsp, nattsp, NULL, NULL, NULL, |
133 | 73.0k | NULL, NULL, NULL, NULL, NULL, NULL, |
134 | 73.0k | NULL,NULL,NULL); |
135 | 73.0k | } |
136 | | |
137 | | /** |
138 | | \ingroup variables |
139 | | Learn the name of a variable. |
140 | | |
141 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
142 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
143 | | nc_inq_ncid(). |
144 | | |
145 | | \param varid Variable ID |
146 | | |
147 | | \param name Returned variable name. The caller must allocate space for |
148 | | the returned name. The maximum length is ::NC_MAX_NAME. Ignored if |
149 | | NULL. |
150 | | |
151 | | \returns ::NC_NOERR No error. |
152 | | \returns ::NC_EBADID Bad ncid. |
153 | | \returns ::NC_ENOTVAR Invalid variable ID. |
154 | | */ |
155 | | int |
156 | | nc_inq_varname(int ncid, int varid, char *name) |
157 | 32.4k | { |
158 | 32.4k | return nc_inq_var(ncid, varid, name, NULL, NULL, |
159 | 32.4k | NULL, NULL); |
160 | 32.4k | } |
161 | | |
162 | | /** Learn the type of a variable. |
163 | | \ingroup variables |
164 | | |
165 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
166 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
167 | | nc_inq_ncid(). |
168 | | |
169 | | \param varid Variable ID |
170 | | |
171 | | \param typep Pointer where typeid will be stored. \ref ignored_if_null. |
172 | | |
173 | | \returns ::NC_NOERR No error. |
174 | | \returns ::NC_EBADID Bad ncid. |
175 | | \returns ::NC_ENOTVAR Invalid variable ID. |
176 | | */ |
177 | | int |
178 | | nc_inq_vartype(int ncid, int varid, nc_type *typep) |
179 | 1.42k | { |
180 | 1.42k | return nc_inq_var(ncid, varid, NULL, typep, NULL, |
181 | 1.42k | NULL, NULL); |
182 | 1.42k | } |
183 | | |
184 | | /** |
185 | | Learn how many dimensions are associated with a variable. |
186 | | \ingroup variables |
187 | | |
188 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
189 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
190 | | nc_inq_ncid(). |
191 | | |
192 | | \param varid Variable ID |
193 | | |
194 | | \param ndimsp Pointer where number of dimensions will be |
195 | | stored. \ref ignored_if_null. |
196 | | |
197 | | \returns ::NC_NOERR No error. |
198 | | \returns ::NC_EBADID Bad ncid. |
199 | | \returns ::NC_ENOTVAR Invalid variable ID. |
200 | | */ |
201 | | int |
202 | | nc_inq_varndims(int ncid, int varid, int *ndimsp) |
203 | 31.7k | { |
204 | 31.7k | return nc_inq_var(ncid, varid, NULL, NULL, ndimsp, NULL, NULL); |
205 | 31.7k | } |
206 | | |
207 | | /** |
208 | | Learn the dimension IDs associated with a variable. |
209 | | \ingroup variables |
210 | | |
211 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
212 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
213 | | nc_inq_ncid(). |
214 | | |
215 | | \param varid Variable ID |
216 | | |
217 | | \param dimidsp Pointer where array of dimension IDs will be |
218 | | stored. \ref ignored_if_null. |
219 | | |
220 | | \returns ::NC_NOERR No error. |
221 | | \returns ::NC_EBADID Bad ncid. |
222 | | \returns ::NC_ENOTVAR Invalid variable ID. |
223 | | */ |
224 | | int |
225 | | nc_inq_vardimid(int ncid, int varid, int *dimidsp) |
226 | 6.40k | { |
227 | 6.40k | return nc_inq_var(ncid, varid, NULL, NULL, NULL, |
228 | 6.40k | dimidsp, NULL); |
229 | 6.40k | } |
230 | | |
231 | | /** |
232 | | Learn how many attributes are associated with a variable. |
233 | | \ingroup variables |
234 | | |
235 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
236 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
237 | | nc_inq_ncid(). |
238 | | |
239 | | \param varid Variable ID |
240 | | |
241 | | \param nattsp Pointer where number of attributes will be |
242 | | stored. \ref ignored_if_null. |
243 | | |
244 | | \returns ::NC_NOERR No error. |
245 | | \returns ::NC_EBADID Bad ncid. |
246 | | \returns ::NC_ENOTVAR Invalid variable ID. |
247 | | */ |
248 | | int |
249 | | nc_inq_varnatts(int ncid, int varid, int *nattsp) |
250 | 2.46k | { |
251 | 2.46k | if (varid == NC_GLOBAL) |
252 | 1.70k | return nc_inq_natts(ncid,nattsp); |
253 | | /*else*/ |
254 | 758 | return nc_inq_var(ncid, varid, NULL, NULL, NULL, NULL, |
255 | 758 | nattsp); |
256 | 2.46k | } |
257 | | |
258 | | /** \ingroup variables |
259 | | Learn the storage and deflate settings for a variable. |
260 | | |
261 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
262 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
263 | | nc_inq_ncid(). |
264 | | |
265 | | \param varid Variable ID |
266 | | |
267 | | \param shufflep A 1 will be written here if the shuffle filter is |
268 | | turned on for this variable, and a 0 otherwise. \ref ignored_if_null. |
269 | | |
270 | | \param deflatep If this pointer is non-NULL, the nc_inq_var_deflate |
271 | | function will write a 1 if the deflate filter is turned on for this |
272 | | variable, and a 0 otherwise. \ref ignored_if_null. |
273 | | |
274 | | \param deflate_levelp If the deflate filter is in use for this |
275 | | variable, the deflate_level will be written here. If deflate is not in |
276 | | use, and deflate_levelp is provided, it will get a zero. (This |
277 | | behavior is expected by the Fortran APIs). \ref ignored_if_null. |
278 | | |
279 | | \returns ::NC_NOERR No error. |
280 | | \returns ::NC_ENOTNC4 Not a netCDF-4 file. |
281 | | \returns ::NC_EBADID Bad ncid. |
282 | | \returns ::NC_ENOTVAR Invalid variable ID. |
283 | | \author Ed Hartnett, Dennis Heimbigner |
284 | | */ |
285 | | int |
286 | | nc_inq_var_deflate(int ncid, int varid, int *shufflep, int *deflatep, int *deflate_levelp) |
287 | 0 | { |
288 | 0 | NC* ncp; |
289 | 0 | size_t nparams; |
290 | 0 | unsigned int params[4]; |
291 | 0 | int deflating = 0; |
292 | |
|
293 | 0 | int stat = NC_check_id(ncid,&ncp); |
294 | 0 | if(stat != NC_NOERR) return stat; |
295 | 0 | TRACE(nc_inq_var_deflate); |
296 | | |
297 | | /* Verify id and nparams */ |
298 | 0 | stat = nc_inq_var_filter_info(ncid,varid,H5Z_FILTER_DEFLATE,&nparams,params); |
299 | 0 | switch (stat) { |
300 | 0 | case NC_ENOFILTER: deflating = 0; stat = NC_NOERR; break; |
301 | 0 | case NC_NOERR: deflating = 1; break; |
302 | 0 | default: return stat; |
303 | 0 | } |
304 | 0 | if(deflatep) *deflatep = deflating; |
305 | 0 | if(deflating) { |
306 | 0 | if(nparams != 1) |
307 | 0 | return NC_EFILTER; /* bad # params */ |
308 | | /* Param[0] should be level */ |
309 | 0 | if(deflate_levelp) *deflate_levelp = (int)params[0]; |
310 | 0 | } else if (deflate_levelp) |
311 | 0 | *deflate_levelp = 0; |
312 | | /* also get the shuffle state */ |
313 | 0 | if(!shufflep) |
314 | 0 | return NC_NOERR; |
315 | 0 | return ncp->dispatch->inq_var_all( |
316 | 0 | ncid, varid, |
317 | 0 | NULL, /*name*/ |
318 | 0 | NULL, /*xtypep*/ |
319 | 0 | NULL, /*ndimsp*/ |
320 | 0 | NULL, /*dimidsp*/ |
321 | 0 | NULL, /*nattsp*/ |
322 | 0 | shufflep, /*shufflep*/ |
323 | 0 | NULL, /*deflatep*/ |
324 | 0 | NULL, /*deflatelevelp*/ |
325 | 0 | NULL, /*fletcher32p*/ |
326 | 0 | NULL, /*contiguousp*/ |
327 | 0 | NULL, /*chunksizep*/ |
328 | 0 | NULL, /*nofillp*/ |
329 | 0 | NULL, /*fillvaluep*/ |
330 | 0 | NULL, /*endianp*/ |
331 | 0 | NULL, NULL, NULL |
332 | 0 | ); |
333 | 0 | } |
334 | | |
335 | | /** \ingroup variables |
336 | | Learn the checksum settings for a variable. |
337 | | |
338 | | This is a wrapper for nc_inq_var_all(). |
339 | | |
340 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
341 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
342 | | nc_inq_ncid(). |
343 | | |
344 | | \param varid Variable ID |
345 | | |
346 | | \param fletcher32p Will be set to ::NC_FLETCHER32 if the fletcher32 |
347 | | checksum filter is turned on for this variable, and ::NC_NOCHECKSUM if |
348 | | it is not. \ref ignored_if_null. |
349 | | |
350 | | \returns ::NC_NOERR No error. |
351 | | \returns ::NC_EBADID Bad ncid. |
352 | | \returns ::NC_ENOTNC4 Not a netCDF-4 file. |
353 | | \returns ::NC_ENOTVAR Invalid variable ID. |
354 | | */ |
355 | | int |
356 | | nc_inq_var_fletcher32(int ncid, int varid, int *fletcher32p) |
357 | 0 | { |
358 | 0 | NC* ncp; |
359 | 0 | int stat = NC_check_id(ncid,&ncp); |
360 | 0 | if(stat != NC_NOERR) return stat; |
361 | 0 | TRACE(nc_inq_var_fletcher32); |
362 | 0 | return ncp->dispatch->inq_var_all( |
363 | 0 | ncid, varid, |
364 | 0 | NULL, /*name*/ |
365 | 0 | NULL, /*xtypep*/ |
366 | 0 | NULL, /*ndimsp*/ |
367 | 0 | NULL, /*dimidsp*/ |
368 | 0 | NULL, /*nattsp*/ |
369 | 0 | NULL, /*shufflep*/ |
370 | 0 | NULL, /*deflatep*/ |
371 | 0 | NULL, /*deflatelevelp*/ |
372 | 0 | fletcher32p, /*fletcher32p*/ |
373 | 0 | NULL, /*contiguousp*/ |
374 | 0 | NULL, /*chunksizep*/ |
375 | 0 | NULL, /*nofillp*/ |
376 | 0 | NULL, /*fillvaluep*/ |
377 | 0 | NULL, /*endianp*/ |
378 | 0 | NULL, NULL, NULL |
379 | 0 | ); |
380 | 0 | } |
381 | | |
382 | | /** |
383 | | * @ingroup variables |
384 | | * |
385 | | * Get the storage and (for chunked variables) the chunksizes of a |
386 | | * variable. See nc_def_var_chunking() for explanation of storage. |
387 | | * |
388 | | * @param ncid NetCDF or group ID, from a previous call to nc_open(), |
389 | | * nc_create(), nc_def_grp(), or associated inquiry functions such as |
390 | | * nc_inq_ncid(). |
391 | | * @param varid Variable ID |
392 | | * @param storagep Address of returned storage property, returned as |
393 | | * ::NC_CONTIGUOUS if this variable uses contiguous storage, |
394 | | * ::NC_CHUNKED if it uses chunked storage, or ::NC_COMPACT for |
395 | | * compact storage. \ref ignored_if_null. |
396 | | * @param chunksizesp The chunksizes will be copied here. \ref |
397 | | * ignored_if_null. |
398 | | * |
399 | | * @return ::NC_NOERR No error. |
400 | | * @return ::NC_EBADID Bad ncid. |
401 | | * @return ::NC_ENOTNC4 Not a netCDF-4 file. |
402 | | * @return ::NC_ENOTVAR Invalid variable ID. |
403 | | * |
404 | | * @author Ed Hartnett |
405 | | * |
406 | | * @section nc_inq_var_chunking_example Example |
407 | | * |
408 | | * @code |
409 | | printf("**** testing contiguous storage..."); |
410 | | { |
411 | | #define NDIMS6 1 |
412 | | #define DIM6_NAME "D5" |
413 | | #define VAR_NAME6 "V5" |
414 | | #define DIM6_LEN 100 |
415 | | |
416 | | int dimids[NDIMS6], dimids_in[NDIMS6]; |
417 | | int varid; |
418 | | int ndims, nvars, natts, unlimdimid; |
419 | | nc_type xtype_in; |
420 | | char name_in[NC_MAX_NAME + 1]; |
421 | | int data[DIM6_LEN], data_in[DIM6_LEN]; |
422 | | size_t chunksize_in[NDIMS6]; |
423 | | int storage_in; |
424 | | int i, d; |
425 | | |
426 | | for (i = 0; i < DIM6_LEN; i++) |
427 | | data[i] = i; |
428 | | |
429 | | |
430 | | if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; |
431 | | if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR; |
432 | | if (dimids[0] != 0) ERR; |
433 | | if (nc_def_var(ncid, VAR_NAME6, NC_INT, NDIMS6, dimids, &varid)) ERR; |
434 | | if (nc_def_var_chunking(ncid, varid, NC_CONTIGUOUS, NULL)) ERR; |
435 | | if (nc_put_var_int(ncid, varid, data)) ERR; |
436 | | |
437 | | |
438 | | if (nc_inq_var_chunking(ncid, 0, &storage_in, chunksize_in)) ERR; |
439 | | if (storage_in != NC_CONTIGUOUS) ERR; |
440 | | @endcode |
441 | | * |
442 | | */ |
443 | | int |
444 | | nc_inq_var_chunking(int ncid, int varid, int *storagep, size_t *chunksizesp) |
445 | 171 | { |
446 | 171 | NC *ncp; |
447 | 171 | int stat = NC_check_id(ncid, &ncp); |
448 | 171 | if(stat != NC_NOERR) return stat; |
449 | 171 | TRACE(nc_inq_var_chunking); |
450 | 171 | return ncp->dispatch->inq_var_all(ncid, varid, NULL, NULL, NULL, NULL, |
451 | 171 | NULL, NULL, NULL, NULL, NULL, storagep, |
452 | 171 | chunksizesp, NULL, NULL, NULL, |
453 | 171 | NULL, NULL, NULL); |
454 | 171 | } |
455 | | |
456 | | /** \ingroup variables |
457 | | Learn the fill mode of a variable. |
458 | | |
459 | | The fill mode of a variable is set by nc_def_var_fill(). |
460 | | |
461 | | This is a wrapper for nc_inq_var_all(). |
462 | | |
463 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
464 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
465 | | nc_inq_ncid(). |
466 | | |
467 | | \param varid Variable ID |
468 | | |
469 | | \param no_fill Pointer to an integer which will get a 1 if no_fill |
470 | | mode is set for this variable. \ref ignored_if_null. |
471 | | |
472 | | \param fill_valuep A pointer which will get the fill value for this |
473 | | variable. \ref ignored_if_null. |
474 | | |
475 | | \returns ::NC_NOERR No error. |
476 | | \returns ::NC_EBADID Bad ncid. |
477 | | \returns ::NC_ENOTVAR Invalid variable ID. |
478 | | */ |
479 | | int |
480 | | nc_inq_var_fill(int ncid, int varid, int *no_fill, void *fill_valuep) |
481 | 0 | { |
482 | 0 | NC* ncp; |
483 | 0 | int stat = NC_check_id(ncid,&ncp); |
484 | |
|
485 | 0 | if(stat != NC_NOERR) return stat; |
486 | 0 | TRACE(nc_inq_var_fill); |
487 | |
|
488 | 0 | return ncp->dispatch->inq_var_all( |
489 | 0 | ncid,varid, |
490 | 0 | NULL, /*name*/ |
491 | 0 | NULL, /*xtypep*/ |
492 | 0 | NULL, /*ndimsp*/ |
493 | 0 | NULL, /*dimidsp*/ |
494 | 0 | NULL, /*nattsp*/ |
495 | 0 | NULL, /*shufflep*/ |
496 | 0 | NULL, /*deflatep*/ |
497 | 0 | NULL, /*deflatelevelp*/ |
498 | 0 | NULL, /*fletcher32p*/ |
499 | 0 | NULL, /*contiguousp*/ |
500 | 0 | NULL, /*chunksizep*/ |
501 | 0 | no_fill, /*nofillp*/ |
502 | 0 | fill_valuep, /*fillvaluep*/ |
503 | 0 | NULL, /*endianp*/ |
504 | 0 | NULL, NULL, NULL |
505 | 0 | ); |
506 | 0 | } |
507 | | |
508 | | /** \ingroup variables |
509 | | Find the endianness of a variable. |
510 | | |
511 | | This is a wrapper for nc_inq_var_all(). |
512 | | |
513 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
514 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
515 | | nc_inq_ncid(). |
516 | | |
517 | | \param varid Variable ID |
518 | | |
519 | | \param endianp Storage which will get ::NC_ENDIAN_LITTLE if this |
520 | | variable is stored in little-endian format, ::NC_ENDIAN_BIG if it is |
521 | | stored in big-endian format, and ::NC_ENDIAN_NATIVE if the endianness |
522 | | is not set, and the variable is not created yet. |
523 | | |
524 | | \returns ::NC_NOERR No error. |
525 | | \returns ::NC_ENOTNC4 Not a netCDF-4 file. |
526 | | \returns ::NC_EBADID Bad ncid. |
527 | | \returns ::NC_ENOTVAR Invalid variable ID. |
528 | | */ |
529 | | int |
530 | | nc_inq_var_endian(int ncid, int varid, int *endianp) |
531 | 0 | { |
532 | 0 | NC* ncp; |
533 | 0 | int stat = NC_check_id(ncid,&ncp); |
534 | 0 | if(stat != NC_NOERR) return stat; |
535 | 0 | TRACE(nc_inq_var_endian); |
536 | 0 | return ncp->dispatch->inq_var_all( |
537 | 0 | ncid, varid, |
538 | 0 | NULL, /*name*/ |
539 | 0 | NULL, /*xtypep*/ |
540 | 0 | NULL, /*ndimsp*/ |
541 | 0 | NULL, /*dimidsp*/ |
542 | 0 | NULL, /*nattsp*/ |
543 | 0 | NULL, /*shufflep*/ |
544 | 0 | NULL, /*deflatep*/ |
545 | 0 | NULL, /*deflatelevelp*/ |
546 | 0 | NULL, /*fletcher32p*/ |
547 | 0 | NULL, /*contiguousp*/ |
548 | 0 | NULL, /*chunksizep*/ |
549 | 0 | NULL, /*nofillp*/ |
550 | 0 | NULL, /*fillvaluep*/ |
551 | 0 | endianp, /*endianp*/ |
552 | 0 | NULL, NULL, NULL); |
553 | 0 | } |
554 | | |
555 | | /** |
556 | | Return number and list of unlimited dimensions. |
557 | | |
558 | | In netCDF-4 files, it's possible to have multiple unlimited |
559 | | dimensions. This function returns a list of the unlimited dimension |
560 | | ids visible in a group. |
561 | | |
562 | | Dimensions are visible in a group if they have been defined in that |
563 | | group, or any ancestor group. |
564 | | |
565 | | \param ncid NetCDF file and group ID, from a previous call to nc_open(), |
566 | | nc_create(), nc_def_grp(), etc. |
567 | | |
568 | | \param nunlimdimsp A pointer to an int which will get the number of |
569 | | visible unlimited dimensions. Ignored if NULL. |
570 | | |
571 | | \param unlimdimidsp A pointer to an already allocated array of int |
572 | | which will get the ids of all visible unlimited dimensions. Ignored if |
573 | | NULL. To allocate the correct length for this array, call |
574 | | nc_inq_unlimdims with a NULL for this parameter and use the |
575 | | nunlimdimsp parameter to get the number of visible unlimited |
576 | | dimensions. |
577 | | |
578 | | \section nc_inq_unlimdims_example Example |
579 | | |
580 | | Here is an example from nc_test4/tst_dims.c. In this example we create |
581 | | a file with two unlimited dimensions, and then call nc_inq_unlimdims() |
582 | | to check that there are 2 unlimited dimensions, and that they have |
583 | | dimids 0 and 1. |
584 | | |
585 | | \code |
586 | | #include <netcdf.h> |
587 | | ... |
588 | | #define ROMULUS "Romulus" |
589 | | #define REMUS "Remus" |
590 | | #define DIMS2 2 |
591 | | printf("*** Testing file with two unlimited dimensions..."); |
592 | | { |
593 | | int ncid, dimid[DIMS2]; |
594 | | int unlimdimid_in[DIMS2]; |
595 | | int nunlimdims_in; |
596 | | |
597 | | if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; |
598 | | if (nc_def_dim(ncid, REMUS, NC_UNLIMITED, &dimid[0])) ERR; |
599 | | if (nc_def_dim(ncid, ROMULUS, NC_UNLIMITED, &dimid[1])) ERR; |
600 | | |
601 | | ... |
602 | | if (nc_inq_unlimdims(ncid, &nunlimdims_in, unlimdimid_in)) ERR; |
603 | | if (nunlimdims_in != 2 || unlimdimid_in[0] != 0 || unlimdimid_in[1] != 1) ERR; |
604 | | \endcode |
605 | | |
606 | | This function will return one of the following values. |
607 | | |
608 | | \returns ::NC_NOERR No error. |
609 | | \returns ::NC_EBADID Bad group id. |
610 | | \returns ::NC_ENOTNC4 Attempting a netCDF-4 operation on a netCDF-3 |
611 | | file. NetCDF-4 operations can only be performed on files defined with |
612 | | a create mode which includes flag HDF5. (see nc_open). |
613 | | \returns ::NC_ESTRICTNC3 This file was created with the strict |
614 | | netcdf-3 flag, therefore netcdf-4 operations are not allowed. (see |
615 | | nc_open). |
616 | | \returns ::NC_EHDFERR An error was reported by the HDF5 layer. |
617 | | \author Ed Hartnett, Dennis Heimbigner |
618 | | */ |
619 | | int |
620 | | nc_inq_unlimdims(int ncid, int *nunlimdimsp, int *unlimdimidsp) |
621 | 0 | { |
622 | | #ifndef USE_NETCDF4 |
623 | | return NC_ENOTNC4; |
624 | | #else |
625 | 0 | NC* ncp; |
626 | 0 | int stat = NC_check_id(ncid,&ncp); |
627 | 0 | if(stat != NC_NOERR) return stat; |
628 | 0 | TRACE(nc_inq_unlimdims); |
629 | 0 | return ncp->dispatch->inq_unlimdims(ncid, nunlimdimsp, |
630 | 0 | unlimdimidsp); |
631 | 0 | #endif |
632 | 0 | } |
633 | | |
634 | | /** |
635 | | \ingroup variables |
636 | | Learn the szip settings of a variable. |
637 | | |
638 | | This function returns the szip settings for a variable. To turn on |
639 | | szip compression, use nc_def_var_szip(). Szip compression is only |
640 | | available if HDF5 was built with szip support. The nc_def_var_filter |
641 | | function may also be used to set szip compression. |
642 | | |
643 | | If a variable is not using szip, then a zero will be passed back |
644 | | for both options_maskp and pixels_per_blockp. |
645 | | |
646 | | For more information on HDF5 and szip see |
647 | | https://support.hdfgroup.org/HDF5/doc/RM/RM_H5P.html#Property-SetSzip |
648 | | and https://support.hdfgroup.org/doc_resource/SZIP/index.html. |
649 | | |
650 | | \param ncid NetCDF or group ID, from a previous call to nc_open(), |
651 | | nc_create(), nc_def_grp(), or associated inquiry functions such as |
652 | | nc_inq_ncid(). |
653 | | |
654 | | \param varid Variable ID |
655 | | |
656 | | \param options_maskp The szip options mask will be copied to this |
657 | | pointer. Note that the HDF5 layer adds to the options_mask, so this |
658 | | value may be different from the value used when setting szip |
659 | | compression, however the bit set when setting szip compression will |
660 | | still be set in the options_maskp and can be checked for. If zero is |
661 | | returned, szip is not in use for this variable.\ref ignored_if_null. |
662 | | |
663 | | \param pixels_per_blockp The szip pixels per block will be copied |
664 | | here. The HDF5 layer may change this value, so this may not match the |
665 | | value passed in when setting szip compression. If zero is returned, |
666 | | szip is not in use for this variable. \ref ignored_if_null. |
667 | | |
668 | | \returns ::NC_NOERR No error. |
669 | | \returns ::NC_EBADID Bad ncid. |
670 | | \returns ::NC_ENOTNC4 Not a netCDF-4 file. |
671 | | \returns ::NC_ENOTVAR Invalid variable ID. |
672 | | \returns ::NC_EFILTER Filter error. |
673 | | |
674 | | \author Ed Hartnett, Dennis Heimbigner |
675 | | |
676 | | */ |
677 | | int |
678 | | nc_inq_var_szip(int ncid, int varid, int *options_maskp, int *pixels_per_blockp) |
679 | 0 | { |
680 | 0 | NC* ncp; |
681 | 0 | size_t nparams; |
682 | 0 | unsigned int params[4]; |
683 | |
|
684 | 0 | int stat = NC_check_id(ncid,&ncp); |
685 | 0 | if(stat != NC_NOERR) return stat; |
686 | 0 | TRACE(nc_inq_var_szip); |
687 | | |
688 | | /* Verify id and nparams */ |
689 | 0 | stat = nc_inq_var_filter_info(ncid,varid,H5Z_FILTER_SZIP,&nparams,params); |
690 | 0 | switch (stat) { |
691 | 0 | case NC_NOERR: |
692 | 0 | if(nparams != 2) |
693 | 0 | return NC_EFILTER; /* bad # params */ |
694 | 0 | break; |
695 | 0 | case NC_ENOFILTER: |
696 | | /* If the szip filter is not in use, return 0 for both parameters. */ |
697 | 0 | params[0] = 0; |
698 | 0 | params[1] = 0; |
699 | 0 | stat = NC_NOERR; |
700 | 0 | break; |
701 | 0 | default: |
702 | 0 | return stat; |
703 | 0 | } |
704 | | |
705 | | /* Param[0] should be options_mask |
706 | | Param[1] should be pixels_per_block */ |
707 | 0 | if(options_maskp) *options_maskp = (int)params[0]; |
708 | 0 | if(pixels_per_blockp) *pixels_per_blockp = (int)params[1]; |
709 | 0 | return stat; |
710 | 0 | } |
711 | | |
712 | | /*! |
713 | | Learn all about a variable. |
714 | | |
715 | | @param[in] ncid ncid for file. |
716 | | @param[in] varid varid for variable in question. |
717 | | @param[out] name Pointer to memory to contain the name of the |
718 | | variable. |
719 | | @param[out] xtypep Pointer to memory to contain the type of the |
720 | | variable. |
721 | | @param[out] ndimsp Pointer to memory to store the number of associated |
722 | | dimensions for the variable. |
723 | | @param[out] dimidsp Pointer to memory to store the dimids associated |
724 | | with the variable. |
725 | | @param[out] nattsp Pointer to memory to store the number of attributes |
726 | | associated with the variable. |
727 | | @param[out] shufflep Pointer to memory to store shuffle information |
728 | | associated with the variable. |
729 | | @param[out] deflatep Pointer to memory to store compression type |
730 | | associated with the variable. |
731 | | @param[out] deflate_levelp Pointer to memory to store compression |
732 | | level associated with the variable. |
733 | | @param[out] fletcher32p Pointer to memory to store compression |
734 | | information associated with the variable. |
735 | | @param[out] contiguousp Pointer to memory to store contiguous-data |
736 | | information associated with the variable. |
737 | | @param[out] chunksizesp Pointer to memory to store chunksize |
738 | | information associated with the variable. |
739 | | @param[out] no_fill Pointer to memory to store whether or not there is |
740 | | a fill value associated with the variable. |
741 | | @param[out] fill_valuep Pointer to memory to store the fill value (if |
742 | | one exists) for the variable. |
743 | | @param[out] endiannessp Pointer to memory to store endianness |
744 | | value. One of ::NC_ENDIAN_BIG ::NC_ENDIAN_LITTLE ::NC_ENDIAN_NATIVE |
745 | | @param[out] idp Pointer to memory to store filter id. |
746 | | @param[out] nparamsp Pointer to memory to store filter parameter count. |
747 | | @param[out] params Pointer to vector of unsigned integers into which |
748 | | to store filter parameters. |
749 | | \note Expose access to nc_inq_var_all(). |
750 | | |
751 | | \returns ::NC_NOERR No error. |
752 | | \returns ::NC_EBADID Bad ncid. |
753 | | \returns ::NC_ENOTVAR Bad varid. |
754 | | \returns ::NC_ENOMEM Out of memory. |
755 | | \returns ::NC_EINVAL Invalid input. |
756 | | \author Ed Hartnett, Dennis Heimbigner |
757 | | \internal |
758 | | \ingroup variables |
759 | | */ |
760 | | #if 0 |
761 | | int |
762 | | NC_inq_var_all(int ncid, int varid, char *name, nc_type *xtypep, |
763 | | int *ndimsp, int *dimidsp, int *nattsp, |
764 | | int *shufflep, int *deflatep, int *deflate_levelp, |
765 | | int *fletcher32p, int *contiguousp, size_t *chunksizesp, |
766 | | int *no_fill, void *fill_valuep, int *endiannessp, |
767 | | unsigned int* unused1, size_t* unused2, unsigned int* unused3 |
768 | | ) |
769 | | { |
770 | | NC* ncp; |
771 | | int stat = NC_check_id(ncid,&ncp); |
772 | | if(stat != NC_NOERR) return stat; |
773 | | return ncp->dispatch->inq_var_all( |
774 | | ncid, varid, name, xtypep, |
775 | | ndimsp, dimidsp, nattsp, |
776 | | shufflep, deflatep, deflate_levelp, fletcher32p, |
777 | | contiguousp, chunksizesp, |
778 | | no_fill, fill_valuep, |
779 | | endiannessp, |
780 | | NULL, NULL, NULL); |
781 | | } |
782 | | #endif |
783 | | |
784 | | /*! \} */ /* End of named group ...*/ |