Coverage Report

Created: 2025-06-09 07:02

/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 ...*/