source: XIOS/trunk/extern/src_netcdf4/dsubstrate.c @ 409

Last change on this file since 409 was 409, checked in by ymipsl, 11 years ago

Add improved nectdf internal library src

YM

  • Property svn:eol-style set to native
File size: 26.1 KB
Line 
1/** \substrate
2Define the substrate dispatch table and functions
3
4These functions end up calling functions in one of the dispatch layers
5(netCDF-4, dap server, etc) using the substrate field of struct NC.
6
7Copyright 2010 University Corporation for Atmospheric
8Research/Unidata. See COPYRIGHT file for more info. 
9*/
10
11#include "netcdf.h"
12#include "ncdispatch.h"
13
14/* forward */
15static NC_Dispatch NCSUBSTRATE_dispatch_base;
16
17/*
18Note that because many of the signatures differ
19from the netcdf API, we need to break
20the abstraction and invoke the
21substrate dispatch table directly.
22*/
23
24
25int
26NCSUBSTRATE_initialize(void)
27{
28    NCSUBSTRATE_dispatch_table = &NCSUBSTRATE_dispatch_base;
29    return NC_NOERR;
30}
31
32static int
33NCSUB_new_nc(NC** ncp)
34{
35    NC* nc;
36    /* Allocate memory for this info. */
37    if (!(nc = calloc(1, sizeof(struct NC)))) 
38       return NC_ENOMEM;
39    if(ncp) *ncp = nc;
40    return NC_NOERR;
41}
42
43static int
44NCSUB_redef(int ncid)
45{
46    NC *nc, *ncsub;
47    int ncstat = NC_check_id(ncid, &nc);
48    if(ncstat != NC_NOERR) return ncstat;
49    ncstat = NC_check_id(nc->substrate,&ncsub);
50    if(ncstat != NC_NOERR) return ncstat;
51    return ncsub->dispatch->redef(nc->substrate);
52}
53
54static int
55NCSUB__enddef(int ncid, size_t a1, size_t a2, size_t a3, size_t a4)
56{
57    NC *nc, *ncsub;
58    int ncstat = NC_check_id(ncid, &nc);
59    if(ncstat != NC_NOERR) return ncstat;
60    ncstat = NC_check_id(nc->substrate, &ncsub);
61    if(ncstat != NC_NOERR) return ncstat;
62    return ncsub->dispatch->_enddef(nc->substrate,a1,a2,a3,a4);
63}
64
65static int
66NCSUB_sync(int ncid)
67{
68    NC *nc, *ncsub;
69    int ncstat = NC_check_id(ncid, &nc);
70    if(ncstat != NC_NOERR) return ncstat;
71    ncstat = NC_check_id(nc->substrate, &ncsub);
72    if(ncstat != NC_NOERR) return ncstat;
73    return ncsub->dispatch->sync(nc->substrate);
74}
75
76static int
77NCSUB_abort(int ncid)
78{
79    NC *nc, *ncsub;
80    int ncstat = NC_check_id(ncid, &nc);
81    if(ncstat != NC_NOERR) return ncstat;
82    ncstat = NC_check_id(nc->substrate, &ncsub);
83    if(ncstat != NC_NOERR) return ncstat;
84    return ncsub->dispatch->abort(nc->substrate);
85}
86
87static int
88NCSUB_close(int ncid)
89{
90    NC *nc, *ncsub;
91    int ncstat = NC_check_id(ncid, &nc);
92    if(ncstat != NC_NOERR) return ncstat;
93    ncstat = NC_check_id(nc->substrate, &ncsub);
94    if(ncstat != NC_NOERR) return ncstat;
95    return ncsub->dispatch->close(nc->substrate);
96}
97
98static int
99NCSUB_set_fill(int ncid, int a1, int* a2)
100{
101    NC *nc, *ncsub;
102    int ncstat = NC_check_id(ncid, &nc);
103    if(ncstat != NC_NOERR) return ncstat;
104    ncstat = NC_check_id(nc->substrate, &ncsub);
105    if(ncstat != NC_NOERR) return ncstat;
106    return ncsub->dispatch->set_fill(nc->substrate,a1,a2);
107}
108
109static int
110NCSUB_inq_base_pe(int ncid, int* a1)
111{
112    NC *nc, *ncsub;
113    int ncstat = NC_check_id(ncid, &nc);
114    if(ncstat != NC_NOERR) return ncstat;
115    ncstat = NC_check_id(nc->substrate, &ncsub);
116    if(ncstat != NC_NOERR) return ncstat;
117    return ncsub->dispatch->inq_base_pe(nc->substrate,a1);
118}
119
120static int
121NCSUB_set_base_pe(int ncid, int a1)
122{
123    NC *nc, *ncsub;
124    int ncstat = NC_check_id(ncid, &nc);
125    if(ncstat != NC_NOERR) return ncstat;
126    ncstat = NC_check_id(nc->substrate, &ncsub);
127    if(ncstat != NC_NOERR) return ncstat;
128    return ncsub->dispatch->set_base_pe(nc->substrate,a1);
129}
130
131static int
132NCSUB_inq_format(int ncid, int* a1)
133{
134    NC *nc, *ncsub;
135    int ncstat = NC_check_id(ncid, &nc);
136    if(ncstat != NC_NOERR) return ncstat;
137    ncstat = NC_check_id(nc->substrate, &ncsub);
138    if(ncstat != NC_NOERR) return ncstat;
139    return ncsub->dispatch->inq_format(nc->substrate,a1);
140}
141
142static int
143NCSUB_inq(int ncid, int* a1, int* a2, int* a3, int* a4)
144{
145    NC *nc, *ncsub;
146    int ncstat = NC_check_id(ncid, &nc);
147    if(ncstat != NC_NOERR) return ncstat;
148    ncstat = NC_check_id(nc->substrate, &ncsub);
149    if(ncstat != NC_NOERR) return ncstat;
150    return ncsub->dispatch->inq(nc->substrate,a1,a2,a3,a4);
151}
152
153static int
154NCSUB_inq_type(int ncid, nc_type a1, char* a2, size_t* a3)
155{
156    NC *nc, *ncsub;
157    int ncstat = NC_check_id(ncid, &nc);
158    if(ncstat != NC_NOERR) return ncstat;
159    ncstat = NC_check_id(nc->substrate, &ncsub);
160    if(ncstat != NC_NOERR) return ncstat;
161    return ncsub->dispatch->inq_type(nc->substrate,a1,a2,a3);
162}
163
164static int
165NCSUB_def_dim(int ncid, const char* a1, size_t a2, int* a3)
166{
167    NC *nc, *ncsub;
168    int ncstat = NC_check_id(ncid, &nc);
169    if(ncstat != NC_NOERR) return ncstat;
170    ncstat = NC_check_id(nc->substrate, &ncsub);
171    if(ncstat != NC_NOERR) return ncstat;
172    return ncsub->dispatch->def_dim(nc->substrate,a1,a2,a3);
173}
174
175static int
176NCSUB_inq_dimid(int ncid, const char* a1, int* a2)
177{
178    NC *nc, *ncsub;
179    int ncstat = NC_check_id(ncid, &nc);
180    if(ncstat != NC_NOERR) return ncstat;
181    ncstat = NC_check_id(nc->substrate, &ncsub);
182    if(ncstat != NC_NOERR) return ncstat;
183    return ncsub->dispatch->inq_dimid(nc->substrate,a1,a2);
184}
185
186static int
187NCSUB_inq_dim(int ncid, int a1, char* a2, size_t* a3)
188{
189    NC *nc, *ncsub;
190    int ncstat = NC_check_id(ncid, &nc);
191    if(ncstat != NC_NOERR) return ncstat;
192    ncstat = NC_check_id(nc->substrate, &ncsub);
193    if(ncstat != NC_NOERR) return ncstat;
194    return ncsub->dispatch->inq_dim(nc->substrate,a1,a2,a3);
195}
196
197static int
198NCSUB_inq_unlimdim(int ncid,  int* a1)
199{
200    NC *nc, *ncsub;
201    int ncstat = NC_check_id(ncid, &nc);
202    if(ncstat != NC_NOERR) return ncstat;
203    ncstat = NC_check_id(nc->substrate, &ncsub);
204    if(ncstat != NC_NOERR) return ncstat;
205    return ncsub->dispatch->inq_unlimdim(nc->substrate,a1);
206}
207
208static int
209NCSUB_rename_dim(int ncid, int a1, const char* a2)
210{
211    NC *nc, *ncsub;
212    int ncstat = NC_check_id(ncid, &nc);
213    if(ncstat != NC_NOERR) return ncstat;
214    ncstat = NC_check_id(nc->substrate, &ncsub);
215    if(ncstat != NC_NOERR) return ncstat;
216    return ncsub->dispatch->rename_dim(nc->substrate,a1,a2);
217}
218
219static int
220NCSUB_inq_att(int ncid, int a1, const char* a2, nc_type* a3, size_t* a4)
221{
222    NC *nc, *ncsub;
223    int ncstat = NC_check_id(ncid, &nc);
224    if(ncstat != NC_NOERR) return ncstat;
225    ncstat = NC_check_id(nc->substrate, &ncsub);
226    if(ncstat != NC_NOERR) return ncstat;
227    return ncsub->dispatch->inq_att(nc->substrate,a1,a2,a3,a4);
228}
229
230static int
231NCSUB_inq_attid(int ncid, int a1, const char* a2, int* a3)
232{
233    NC *nc, *ncsub;
234    int ncstat = NC_check_id(ncid, &nc);
235    if(ncstat != NC_NOERR) return ncstat;
236    ncstat = NC_check_id(nc->substrate, &ncsub);
237    if(ncstat != NC_NOERR) return ncstat;
238    return ncsub->dispatch->inq_attid(nc->substrate,a1,a2,a3);
239}
240
241static int
242NCSUB_inq_attname(int ncid, int a1, int a2, char* a3)
243{
244    NC *nc, *ncsub;
245    int ncstat = NC_check_id(ncid, &nc);
246    if(ncstat != NC_NOERR) return ncstat;
247    ncstat = NC_check_id(nc->substrate, &ncsub);
248    if(ncstat != NC_NOERR) return ncstat;
249    return ncsub->dispatch->inq_attname(nc->substrate,a1,a2,a3);
250}
251
252static int
253NCSUB_rename_att(int ncid, int a1, const char* a2, const char* a3)
254{
255    NC *nc, *ncsub;
256    int ncstat = NC_check_id(ncid, &nc);
257    if(ncstat != NC_NOERR) return ncstat;
258    ncstat = NC_check_id(nc->substrate, &ncsub);
259    if(ncstat != NC_NOERR) return ncstat;
260    return ncsub->dispatch->rename_att(nc->substrate,a1,a2,a3);
261}
262
263static int
264NCSUB_del_att(int ncid, int a1, const char* a2)
265{
266    NC *nc, *ncsub;
267    int ncstat = NC_check_id(ncid, &nc);
268    if(ncstat != NC_NOERR) return ncstat;
269    ncstat = NC_check_id(nc->substrate, &ncsub);
270    if(ncstat != NC_NOERR) return ncstat;
271    return ncsub->dispatch->del_att(nc->substrate,a1,a2);
272}
273
274static int
275NCSUB_get_att(int ncid, int a1, const char* a2, void* a3, nc_type a4)
276{
277    NC *nc, *ncsub;
278    int ncstat = NC_check_id(ncid, &nc);
279    if(ncstat != NC_NOERR) return ncstat;
280    ncstat = NC_check_id(nc->substrate, &ncsub);
281    if(ncstat != NC_NOERR) return ncstat;
282    return ncsub->dispatch->get_att(nc->substrate,a1,a2,a3,a4);
283}
284
285static int
286NCSUB_put_att(int ncid, int a1, const char* a2, nc_type a3, size_t a4, const void* a5, nc_type a6)
287{
288    NC *nc, *ncsub;
289    int ncstat = NC_check_id(ncid, &nc);
290    if(ncstat != NC_NOERR) return ncstat;
291    ncstat = NC_check_id(nc->substrate, &ncsub);
292    if(ncstat != NC_NOERR) return ncstat;
293    return ncsub->dispatch->put_att(nc->substrate,a1,a2,a3,a4,a5,a6);
294}
295
296static int
297NCSUB_def_var(int ncid, const char* a1, nc_type a2, int a3, const int* a4, int* a5)
298{
299    NC *nc, *ncsub;
300    int ncstat = NC_check_id(ncid, &nc);
301    if(ncstat != NC_NOERR) return ncstat;
302    ncstat = NC_check_id(nc->substrate, &ncsub);
303    if(ncstat != NC_NOERR) return ncstat;
304    return ncsub->dispatch->def_var(nc->substrate,a1,a2,a3,a4,a5);
305}
306
307static int
308NCSUB_inq_varid(int ncid, const char* a1, int* a2)
309{
310    NC *nc, *ncsub;
311    int ncstat = NC_check_id(ncid, &nc);
312    if(ncstat != NC_NOERR) return ncstat;
313    ncstat = NC_check_id(nc->substrate, &ncsub);
314    if(ncstat != NC_NOERR) return ncstat;
315    return ncsub->dispatch->inq_varid(nc->substrate,a1,a2);
316}
317
318static int
319NCSUB_rename_var(int ncid, int a1, const char* a2)
320{
321    NC *nc, *ncsub;
322    int ncstat = NC_check_id(ncid, &nc);
323    if(ncstat != NC_NOERR) return ncstat;
324    ncstat = NC_check_id(nc->substrate, &ncsub);
325    if(ncstat != NC_NOERR) return ncstat;
326    return ncsub->dispatch->rename_var(nc->substrate,a1,a2);
327}
328
329static int
330NCSUB_get_vara(int ncid, int a1, const size_t* a2, const size_t* a3, void* a4, nc_type a5)
331{
332    NC *nc, *ncsub;
333    int ncstat = NC_check_id(ncid, &nc);
334    if(ncstat != NC_NOERR) return ncstat;
335    ncstat = NC_check_id(nc->substrate, &ncsub);
336    if(ncstat != NC_NOERR) return ncstat;
337    return ncsub->dispatch->get_vara(nc->substrate,a1,a2,a3,a4,a5);
338}
339
340static int
341NCSUB_put_vara(int ncid, int a1, const size_t* a2, const size_t* a3, const void* a4, nc_type a5)
342{
343    NC *nc, *ncsub;
344    int ncstat = NC_check_id(ncid, &nc);
345    if(ncstat != NC_NOERR) return ncstat;
346    ncstat = NC_check_id(nc->substrate, &ncsub);
347    if(ncstat != NC_NOERR) return ncstat;
348    return ncsub->dispatch->put_vara(nc->substrate,a1,a2,a3,a4,a5);
349}
350
351/* Added to solve Ferret performance problem with Opendap */
352static int
353NCSUB_get_vars(int ncid, int a1, const size_t* a2, const size_t* a3, const ptrdiff_t* a4, void* a5, nc_type a6)
354{
355    NC *nc, *ncsub;
356    int ncstat = NC_check_id(ncid, &nc);
357    if(ncstat != NC_NOERR) return ncstat;
358    ncstat = NC_check_id(nc->substrate, &ncsub);
359    if(ncstat != NC_NOERR) return ncstat;
360    return ncsub->dispatch->get_vars(nc->substrate,a1,a2,a3,a4,a5,a6);
361}
362
363static int
364NCSUB_put_vars(int ncid, int a1, const size_t* a2, const size_t* a3, const ptrdiff_t* a4, const void* a5, nc_type a6)
365{
366    NC *nc, *ncsub;
367    int ncstat = NC_check_id(ncid, &nc);
368    if(ncstat != NC_NOERR) return ncstat;
369    ncstat = NC_check_id(nc->substrate, &ncsub);
370    if(ncstat != NC_NOERR) return ncstat;
371    return ncsub->dispatch->put_vars(nc->substrate,a1,a2,a3,a4,a5,a6);
372}
373
374static int
375NCSUB_get_varm(int ncid, int a1, const size_t* a2, const size_t* a3, const ptrdiff_t* a4, const ptrdiff_t* a5, void* a6, nc_type a7)
376{
377    NC *nc, *ncsub;
378    int ncstat = NC_check_id(ncid, &nc);
379    if(ncstat != NC_NOERR) return ncstat;
380    ncstat = NC_check_id(nc->substrate, &ncsub);
381    if(ncstat != NC_NOERR) return ncstat;
382    return ncsub->dispatch->get_varm(nc->substrate,a1,a2,a3,a4,a5,a6,a7);
383}
384
385static int
386NCSUB_put_varm(int ncid, int a1, const size_t* a2, const size_t* a3, const ptrdiff_t* a4, const ptrdiff_t* a5, const void* a6, nc_type a7)
387{
388    NC *nc, *ncsub;
389    int ncstat = NC_check_id(ncid, &nc);
390    if(ncstat != NC_NOERR) return ncstat;
391    ncstat = NC_check_id(nc->substrate, &ncsub);
392    if(ncstat != NC_NOERR) return ncstat;
393    return ncsub->dispatch->put_varm(nc->substrate,a1,a2,a3,a4,a5,a6,a7);
394}
395
396
397static int
398NCSUB_inq_var_all(int ncid, int varid, char* name, nc_type* xtypep, 
399               int* ndimsp, int* dimidsp, int* nattsp, 
400               int* shufflep, int* deflatep, int* deflate_levelp, 
401               int* fletcher32p, int* contiguousp, size_t* chunksizesp, 
402               int* no_fill, void* fill_valuep, int* endiannessp, 
403               int* options_maskp, int* pixels_per_blockp)
404{
405   NC *nc, *ncsub;
406   int ncstat = NC_check_id(ncid, &nc);
407   if(ncstat != NC_NOERR) return ncstat;
408    ncstat = NC_check_id(nc->substrate, &ncsub);
409   if(ncstat != NC_NOERR) return ncstat;
410   return ncsub->dispatch->inq_var_all(nc->substrate,varid,name,xtypep,
411                                     ndimsp,dimidsp,nattsp,shufflep,
412                                     deflatep,deflate_levelp,fletcher32p,
413                                     contiguousp,chunksizesp,
414                                     no_fill,fill_valuep,
415                                     endiannessp,
416                                     options_maskp,pixels_per_blockp);
417}
418
419#ifdef USE_NETCDF4
420
421static int
422NCSUB_show_metadata(int ncid)
423{
424    NC *nc, *ncsub;
425    int ncstat = NC_check_id(ncid, &nc);
426    if(ncstat != NC_NOERR) return ncstat;
427    ncstat = NC_check_id(nc->substrate, &ncsub);
428    if(ncstat != NC_NOERR) return ncstat;
429    return ncsub->dispatch->show_metadata(nc->substrate);
430}
431
432static int
433NCSUB_inq_unlimdims(int ncid, int* a1, int* a2)
434{
435    NC *nc, *ncsub;
436    int ncstat = NC_check_id(ncid, &nc);
437    if(ncstat != NC_NOERR) return ncstat;
438    ncstat = NC_check_id(nc->substrate, &ncsub);
439    if(ncstat != NC_NOERR) return ncstat;
440    return ncsub->dispatch->inq_unlimdims(nc->substrate,a1,a2);
441}
442
443static int
444NCSUB_var_par_access(int ncid, int a1, int a2)
445{
446    NC *nc, *ncsub;
447    int ncstat = NC_check_id(ncid, &nc);
448    if(ncstat != NC_NOERR) return ncstat;
449    ncstat = NC_check_id(nc->substrate, &ncsub);
450    if(ncstat != NC_NOERR) return ncstat;
451    return ncsub->dispatch->var_par_access(nc->substrate,a1,a2);
452}
453
454static int
455NCSUB_inq_ncid(int ncid, const char* a1, int* a2)
456{
457    NC *nc, *ncsub;
458    int ncstat = NC_check_id(ncid, &nc);
459    if(ncstat != NC_NOERR) return ncstat;
460    ncstat = NC_check_id(nc->substrate, &ncsub);
461    if(ncstat != NC_NOERR) return ncstat;
462    return ncsub->dispatch->inq_ncid(nc->substrate,a1,a2);
463}
464
465static int
466NCSUB_inq_grps(int ncid, int* a1, int* a2)
467{
468    NC *nc, *ncsub;
469    int ncstat = NC_check_id(ncid, &nc);
470    if(ncstat != NC_NOERR) return ncstat;
471    ncstat = NC_check_id(nc->substrate, &ncsub);
472    if(ncstat != NC_NOERR) return ncstat;
473    return ncsub->dispatch->inq_grps(nc->substrate,a1,a2);
474}
475
476static int
477NCSUB_inq_grpname(int ncid, char* a1)
478{
479    NC *nc, *ncsub;
480    int ncstat = NC_check_id(ncid, &nc);
481    if(ncstat != NC_NOERR) return ncstat;
482    ncstat = NC_check_id(nc->substrate, &ncsub);
483    if(ncstat != NC_NOERR) return ncstat;
484    return ncsub->dispatch->inq_grpname(nc->substrate,a1);
485}
486
487static int
488NCSUB_inq_grpname_full(int ncid, size_t* a1, char* a2)
489{
490    NC *nc, *ncsub;
491    int ncstat = NC_check_id(ncid, &nc);
492    if(ncstat != NC_NOERR) return ncstat;
493    ncstat = NC_check_id(nc->substrate, &ncsub);
494    if(ncstat != NC_NOERR) return ncstat;
495    return ncsub->dispatch->inq_grpname_full(nc->substrate,a1,a2);
496}
497
498static int
499NCSUB_inq_grp_parent(int ncid, int* a1)
500{
501    NC *nc, *ncsub;
502    int ncstat = NC_check_id(ncid, &nc);
503    if(ncstat != NC_NOERR) return ncstat;
504    ncstat = NC_check_id(nc->substrate, &ncsub);
505    if(ncstat != NC_NOERR) return ncstat;
506    return ncsub->dispatch->inq_grp_parent(nc->substrate,a1);
507}
508
509static int
510NCSUB_inq_grp_full_ncid(int ncid, const char* a1, int* a2)
511{
512    NC *nc, *ncsub;
513    int ncstat = NC_check_id(ncid, &nc);
514    if(ncstat != NC_NOERR) return ncstat;
515    ncstat = NC_check_id(nc->substrate, &ncsub);
516    if(ncstat != NC_NOERR) return ncstat;
517    return ncsub->dispatch->inq_grp_full_ncid(nc->substrate,a1,a2);
518}
519
520static int
521NCSUB_inq_varids(int ncid, int* a1, int* a2)
522{
523    NC *nc, *ncsub;
524    int ncstat = NC_check_id(ncid, &nc);
525    if(ncstat != NC_NOERR) return ncstat;
526    ncstat = NC_check_id(nc->substrate, &ncsub);
527    if(ncstat != NC_NOERR) return ncstat;
528    return ncsub->dispatch->inq_varids(nc->substrate,a1,a2);
529}
530
531static int
532NCSUB_inq_dimids(int ncid, int* a1, int* a2, int a3)
533{
534    NC *nc, *ncsub;
535    int ncstat = NC_check_id(ncid, &nc);
536    if(ncstat != NC_NOERR) return ncstat;
537    ncstat = NC_check_id(nc->substrate, &ncsub);
538    if(ncstat != NC_NOERR) return ncstat;
539    return ncsub->dispatch->inq_dimids(nc->substrate,a1,a2,a3);
540}
541
542static int
543NCSUB_inq_typeids(int ncid, int* a1, int* a2)
544{
545    NC *nc, *ncsub;
546    int ncstat = NC_check_id(ncid, &nc);
547    if(ncstat != NC_NOERR) return ncstat;
548    ncstat = NC_check_id(nc->substrate, &ncsub);
549    if(ncstat != NC_NOERR) return ncstat;
550    return ncsub->dispatch->inq_typeids(nc->substrate,a1,a2);
551}
552
553static int
554NCSUB_inq_type_equal(int ncid, nc_type a1, int a2, nc_type a3, int* a4)
555{
556    NC *nc, *ncsub;
557    int ncstat = NC_check_id(ncid, &nc);
558    if(ncstat != NC_NOERR) return ncstat;
559    ncstat = NC_check_id(nc->substrate, &ncsub);
560    if(ncstat != NC_NOERR) return ncstat;
561    return ncsub->dispatch->inq_type_equal(nc->substrate,a1,a2,a3,a4);
562}
563
564static int
565NCSUB_def_grp(int ncid, const char* a1, int* a2)
566{
567    NC *nc, *ncsub;
568    int ncstat = NC_check_id(ncid, &nc);
569    if(ncstat != NC_NOERR) return ncstat;
570    ncstat = NC_check_id(nc->substrate, &ncsub);
571    if(ncstat != NC_NOERR) return ncstat;
572    return ncsub->dispatch->def_grp(nc->substrate,a1,a2);
573}
574
575static int
576NCSUB_inq_user_type(int ncid, nc_type a1, char* a2, size_t* a3, nc_type* a4, size_t* a5, int* a6)
577{
578    NC *nc, *ncsub;
579    int ncstat = NC_check_id(ncid, &nc);
580    if(ncstat != NC_NOERR) return ncstat;
581    ncstat = NC_check_id(nc->substrate, &ncsub);
582    if(ncstat != NC_NOERR) return ncstat;
583    return ncsub->dispatch->inq_user_type(nc->substrate,a1,a2,a3,a4,a5,a6);
584}
585
586static int
587NCSUB_inq_typeid(int ncid, const char* a1, nc_type* a2)
588{
589    NC *nc, *ncsub;
590    int ncstat = NC_check_id(ncid, &nc);
591    if(ncstat != NC_NOERR) return ncstat;
592    ncstat = NC_check_id(nc->substrate, &ncsub);
593    if(ncstat != NC_NOERR) return ncstat;
594    return ncsub->dispatch->inq_typeid(nc->substrate,a1,a2);
595}
596
597static int
598NCSUB_def_compound(int ncid, size_t a1, const char* a2, nc_type* a3)
599{
600    NC *nc, *ncsub;
601    int ncstat = NC_check_id(ncid, &nc);
602    if(ncstat != NC_NOERR) return ncstat;
603    ncstat = NC_check_id(nc->substrate, &ncsub);
604    if(ncstat != NC_NOERR) return ncstat;
605    return ncsub->dispatch->def_compound(nc->substrate,a1,a2,a3);
606}
607
608static int
609NCSUB_insert_compound(int ncid, nc_type a1, const char* a2, size_t a3, nc_type a4)
610{
611    NC *nc, *ncsub;
612    int ncstat = NC_check_id(ncid, &nc);
613    if(ncstat != NC_NOERR) return ncstat;
614    ncstat = NC_check_id(nc->substrate, &ncsub);
615    if(ncstat != NC_NOERR) return ncstat;
616    return ncsub->dispatch->insert_compound(nc->substrate,a1,a2,a3,a4);
617}
618
619static int
620NCSUB_insert_array_compound(int ncid, nc_type a1, const char* a2, size_t a3, nc_type a4, int a5, const int* a6)
621{
622    NC *nc, *ncsub;
623    int ncstat = NC_check_id(ncid, &nc);
624    if(ncstat != NC_NOERR) return ncstat;
625    ncstat = NC_check_id(nc->substrate, &ncsub);
626    if(ncstat != NC_NOERR) return ncstat;
627    return ncsub->dispatch->insert_array_compound(nc->substrate,a1,a2,a3,a4,a5,a6);
628}
629
630static int
631NCSUB_inq_compound_field(int ncid, nc_type a1, int a2, char* a3, size_t* a4, nc_type* a5, int* a6, int* a7)
632{
633    NC *nc, *ncsub;
634    int ncstat = NC_check_id(ncid, &nc);
635    if(ncstat != NC_NOERR) return ncstat;
636    ncstat = NC_check_id(nc->substrate, &ncsub);
637    if(ncstat != NC_NOERR) return ncstat;
638    return ncsub->dispatch->inq_compound_field(nc->substrate,a1,a2,a3,a4,a5,a6,a7);
639}
640
641static int
642NCSUB_inq_compound_fieldindex(int ncid, nc_type a1, const char* a2, int* a3)
643{
644    NC *nc, *ncsub;
645    int ncstat = NC_check_id(ncid, &nc);
646    if(ncstat != NC_NOERR) return ncstat;
647    ncstat = NC_check_id(nc->substrate, &ncsub);
648    if(ncstat != NC_NOERR) return ncstat;
649    return ncsub->dispatch->inq_compound_fieldindex(nc->substrate,a1,a2,a3);
650}
651
652static int
653NCSUB_def_vlen(int ncid, const char* a1, nc_type a2, nc_type* a3)
654{
655    NC *nc, *ncsub;
656    int ncstat = NC_check_id(ncid, &nc);
657    if(ncstat != NC_NOERR) return ncstat;
658    ncstat = NC_check_id(nc->substrate, &ncsub);
659    if(ncstat != NC_NOERR) return ncstat;
660    return ncsub->dispatch->def_vlen(nc->substrate,a1,a2,a3);
661}
662
663static int
664NCSUB_put_vlen_element(int ncid, int a1, void* a2, size_t a3, const void* a4)
665{
666    NC *nc, *ncsub;
667    int ncstat = NC_check_id(ncid, &nc);
668    if(ncstat != NC_NOERR) return ncstat;
669    ncstat = NC_check_id(nc->substrate, &ncsub);
670    if(ncstat != NC_NOERR) return ncstat;
671    return ncsub->dispatch->put_vlen_element(nc->substrate,a1,a2,a3,a4);
672}
673
674static int
675NCSUB_get_vlen_element(int ncid, int a1, const void* a2, size_t* a3, void* a4)
676{
677    NC *nc, *ncsub;
678    int ncstat = NC_check_id(ncid, &nc);
679    if(ncstat != NC_NOERR) return ncstat;
680    ncstat = NC_check_id(nc->substrate, &ncsub);
681    if(ncstat != NC_NOERR) return ncstat;
682    return ncsub->dispatch->get_vlen_element(nc->substrate,a1,a2,a3,a4);
683}
684
685static int
686NCSUB_def_enum(int ncid, nc_type a1, const char* a2, nc_type* a3)
687{
688    NC *nc, *ncsub;
689    int ncstat = NC_check_id(ncid, &nc);
690    if(ncstat != NC_NOERR) return ncstat;
691    ncstat = NC_check_id(nc->substrate, &ncsub);
692    if(ncstat != NC_NOERR) return ncstat;
693    return ncsub->dispatch->def_enum(nc->substrate,a1,a2,a3);
694}
695
696static int
697NCSUB_insert_enum(int ncid, nc_type a1, const char* a2, const void* a3)
698{
699    NC *nc, *ncsub;
700    int ncstat = NC_check_id(ncid, &nc);
701    if(ncstat != NC_NOERR) return ncstat;
702    ncstat = NC_check_id(nc->substrate, &ncsub);
703    if(ncstat != NC_NOERR) return ncstat;
704    return ncsub->dispatch->insert_enum(nc->substrate,a1,a2,a3);
705}
706
707static int
708NCSUB_inq_enum_member(int ncid, nc_type a1, int a2, char* a3, void* a4)
709{
710    NC *nc, *ncsub;
711    int ncstat = NC_check_id(ncid, &nc);
712    if(ncstat != NC_NOERR) return ncstat;
713    ncstat = NC_check_id(nc->substrate, &ncsub);
714    if(ncstat != NC_NOERR) return ncstat;
715    return ncsub->dispatch->inq_enum_member(nc->substrate,a1,a2,a3,a4);
716}
717
718static int
719NCSUB_inq_enum_ident(int ncid, nc_type a1, long long a2, char* a3)
720{
721    NC *nc, *ncsub;
722    int ncstat = NC_check_id(ncid, &nc);
723    if(ncstat != NC_NOERR) return ncstat;
724    ncstat = NC_check_id(nc->substrate, &ncsub);
725    if(ncstat != NC_NOERR) return ncstat;
726    return ncsub->dispatch->inq_enum_ident(nc->substrate,a1,a2,a3);
727}
728
729static int
730NCSUB_def_opaque(int ncid, size_t a1, const char* a2, nc_type* a3)
731{
732    NC *nc, *ncsub;
733    int ncstat = NC_check_id(ncid, &nc);
734    if(ncstat != NC_NOERR) return ncstat;
735    ncstat = NC_check_id(nc->substrate, &ncsub);
736    if(ncstat != NC_NOERR) return ncstat;
737    return ncsub->dispatch->def_opaque(nc->substrate,a1,a2,a3);
738}
739
740static int
741NCSUB_def_var_deflate(int ncid, int a1, int a2, int a3, int a4)
742{
743    NC *nc, *ncsub;
744    int ncstat = NC_check_id(ncid, &nc);
745    if(ncstat != NC_NOERR) return ncstat;
746    ncstat = NC_check_id(nc->substrate, &ncsub);
747    if(ncstat != NC_NOERR) return ncstat;
748    return ncsub->dispatch->def_var_deflate(nc->substrate,a1,a2,a3,a4);
749}
750
751static int
752NCSUB_def_var_fletcher32(int ncid, int a1, int a2)
753{
754    NC *nc, *ncsub;
755    int ncstat = NC_check_id(ncid, &nc);
756    if(ncstat != NC_NOERR) return ncstat;
757    ncstat = NC_check_id(nc->substrate, &ncsub);
758    if(ncstat != NC_NOERR) return ncstat;
759    return ncsub->dispatch->def_var_fletcher32(nc->substrate,a1,a2);
760}
761
762static int
763NCSUB_def_var_chunking(int ncid, int a1, int a2, const size_t* a3)
764{
765    NC *nc, *ncsub;
766    int ncstat = NC_check_id(ncid, &nc);
767    if(ncstat != NC_NOERR) return ncstat;
768    ncstat = NC_check_id(nc->substrate, &ncsub);
769    if(ncstat != NC_NOERR) return ncstat;
770    return ncsub->dispatch->def_var_chunking(nc->substrate,a1,a2,a3);
771}
772
773static int
774NCSUB_def_var_fill(int ncid, int a1, int a2, const void* a3)
775{
776    NC *nc, *ncsub;
777    int ncstat = NC_check_id(ncid, &nc);
778    if(ncstat != NC_NOERR) return ncstat;
779    ncstat = NC_check_id(nc->substrate, &ncsub);
780    if(ncstat != NC_NOERR) return ncstat;
781    return ncsub->dispatch->def_var_fill(nc->substrate,a1,a2,a3);
782}
783
784static int
785NCSUB_def_var_endian(int ncid, int a1, int a2)
786{
787    NC *nc, *ncsub;
788    int ncstat = NC_check_id(ncid, &nc);
789    if(ncstat != NC_NOERR) return ncstat;
790    ncstat = NC_check_id(nc->substrate, &ncsub);
791    if(ncstat != NC_NOERR) return ncstat;
792    return ncsub->dispatch->def_var_endian(nc->substrate,a1,a2);
793}
794
795static int
796NCSUB_set_var_chunk_cache(int ncid, int a1, size_t a2, size_t a3, float a4)
797{
798    NC *nc, *ncsub;
799    int ncstat = NC_check_id(ncid, &nc);
800    if(ncstat != NC_NOERR) return ncstat;
801    ncstat = NC_check_id(nc->substrate, &ncsub);
802    if(ncstat != NC_NOERR) return ncstat;
803    return ncsub->dispatch->set_var_chunk_cache(nc->substrate,a1,a2,a3,a4);
804}
805
806static int
807NCSUB_get_var_chunk_cache(int ncid, int a1, size_t* a2, size_t* a3, float* a4)
808{
809    NC *nc, *ncsub;
810    int ncstat = NC_check_id(ncid, &nc);
811    if(ncstat != NC_NOERR) return ncstat;
812    ncstat = NC_check_id(nc->substrate, &ncsub);
813    if(ncstat != NC_NOERR) return ncstat;
814    return ncsub->dispatch->get_var_chunk_cache(nc->substrate,a1,a2,a3,a4);
815}
816
817#endif /*USE_NETCDF4*/
818
819/* Declare here to avoid having a bunch of static forward declarations */ 
820
821static NC_Dispatch NCSUBSTRATE_dispatch_base =  {
822
8230,
824
825NCSUB_new_nc,
826
827NULL, /*NC_create*/
828NULL, /*NC_open*/
829
830NCSUB_redef,
831NCSUB__enddef,
832NCSUB_sync,
833NCSUB_abort,
834NCSUB_close,
835NCSUB_set_fill,
836NCSUB_inq_base_pe,
837NCSUB_set_base_pe,
838NCSUB_inq_format,
839
840NCSUB_inq,
841NCSUB_inq_type,
842
843NCSUB_def_dim,
844NCSUB_inq_dimid,
845NCSUB_inq_dim,
846NCSUB_inq_unlimdim,
847NCSUB_rename_dim,
848
849NCSUB_inq_att,
850NCSUB_inq_attid,
851NCSUB_inq_attname,
852NCSUB_rename_att,
853NCSUB_del_att,
854NCSUB_get_att,
855NCSUB_put_att,
856
857NCSUB_def_var,
858NCSUB_inq_varid,
859NCSUB_rename_var,
860
861NCSUB_get_vara,
862NCSUB_put_vara,
863NCSUB_get_vars,
864NCSUB_put_vars,
865NCSUB_get_varm,
866NCSUB_put_varm,
867
868NCSUB_inq_var_all,
869
870#ifdef USE_NETCDF4
871NCSUB_show_metadata,
872NCSUB_inq_unlimdims,
873
874NCSUB_var_par_access,
875
876NCSUB_inq_ncid,
877NCSUB_inq_grps,
878NCSUB_inq_grpname,
879NCSUB_inq_grpname_full,
880NCSUB_inq_grp_parent,
881NCSUB_inq_grp_full_ncid,
882NCSUB_inq_varids,
883NCSUB_inq_dimids,
884NCSUB_inq_typeids,
885NCSUB_inq_type_equal,
886NCSUB_def_grp,
887NCSUB_inq_user_type,
888NCSUB_inq_typeid,
889
890NCSUB_def_compound,
891NCSUB_insert_compound,
892NCSUB_insert_array_compound,
893NCSUB_inq_compound_field,
894NCSUB_inq_compound_fieldindex,
895NCSUB_def_vlen,
896NCSUB_put_vlen_element,
897NCSUB_get_vlen_element,
898NCSUB_def_enum,
899NCSUB_insert_enum,
900NCSUB_inq_enum_member,
901NCSUB_inq_enum_ident,
902NCSUB_def_opaque,
903NCSUB_def_var_deflate,
904NCSUB_def_var_fletcher32,
905NCSUB_def_var_chunking,
906NCSUB_def_var_fill,
907NCSUB_def_var_endian,
908NCSUB_set_var_chunk_cache,
909NCSUB_get_var_chunk_cache
910
911#endif /*USE_NETCDF4*/
912
913};
914
915NC_Dispatch* NCSUBSTRATE_dispatch_table = NULL; /*Moved here from ddispatch.c*/
Note: See TracBrowser for help on using the repository browser.