1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
/*********************************************************************
* Copyright 2018, UCAR/Unidata
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
*********************************************************************/
#ifndef DCECONSTRAINTS_H
#define DCECONSTRAINTS_H 1
#include "ceconstraints.h"
/* Provide a universal cast type containing common fields */
/* Define the common "supertype */
typedef struct DCEnode {
CEsort sort;
} DCEnode;
/* The slice structure is assumed common to all uses.
It is initially established from [first:stride:last]
*/
typedef struct DCEslice {
DCEnode node;
size_t first;
size_t stride;
size_t length;
size_t last; /* first + length - 1*/
size_t count; /* (length + (stride-1))/ stride == actual # of elements returned to client*/
size_t declsize; /* from defining dimension, if any.*/
} DCEslice;
typedef struct DCEsegment {
DCEnode node;
char* name;
int slicesdefined; /*1=>slice counts defined, except declsize*/
int slicesdeclized; /*1=>slice declsize defined */
size_t rank;
DCEslice slices[NC_MAX_VAR_DIMS];
void* annotation;
} DCEsegment;
typedef struct DCEfcn {
DCEnode node;
char* name;
NClist* args;
} DCEfcn;
typedef struct DCEvar {
DCEnode node;
NClist* segments;
void* annotation;
} DCEvar;
typedef struct DCEconstant {
DCEnode node;
CEsort discrim;
char* text;
long long intvalue;
double floatvalue;
} DCEconstant;
typedef struct DCEvalue {
DCEnode node;
CEsort discrim;
/* Do not bother with a union */
DCEconstant* constant;
DCEvar* var;
DCEfcn* fcn;
} DCEvalue;
typedef struct DCEselection {
DCEnode node;
CEsort operator;
DCEvalue* lhs;
NClist* rhs;
} DCEselection;
typedef struct DCEprojection {
DCEnode node;
CEsort discrim;
/* Do not bother with a union */
DCEvar* var;
DCEfcn* fcn;
} DCEprojection;
typedef struct DCEconstraint {
DCEnode node;
NClist* projections;
NClist* selections;
} DCEconstraint;
extern int dceparseconstraints(char* constraints, DCEconstraint* DCEonstraint);
extern int dceslicecompose(DCEslice* s1, DCEslice* s2, DCEslice* sr);
extern int dcemergeprojectionlists(NClist* dst, NClist* src);
extern DCEnode* dceclone(DCEnode* node);
extern NClist* dceclonelist(NClist* list);
extern void dcefree(DCEnode* node);
extern void dcefreelist(NClist* list);
extern char* dcetostring(DCEnode* node);
extern char* dcelisttostring(NClist* list,char*);
extern void dcetobuffer(DCEnode* node, NCbytes* buf);
extern void dcelisttobuffer(NClist* list, NCbytes* buf,char*);
extern char* dcerawtostring(void*);
extern char* dcerawlisttostring(NClist*);
extern NClist* dceallnodes(DCEnode* node, CEsort which);
extern DCEnode* dcecreate(CEsort sort);
extern void dcemakewholeslice(DCEslice* slice, size_t declsize);
extern void dcemakewholeprojection(DCEprojection*);
extern int dceiswholesegment(DCEsegment*);
extern int dceiswholeslice(DCEslice*);
extern int dceiswholeseglist(NClist*);
extern int dceiswholeprojection(DCEprojection*);
extern int dcesamepath(NClist* list1, NClist* list2);
extern int dcemergeprojections(DCEprojection* dst, DCEprojection* src);
extern void dcesegment_transpose(DCEsegment* seg,
size_t* start,
size_t* count,
size_t* stride,
size_t* sizes
);
/* Find leftmost index of segment slices
s.t. that index and all up to last
satisfy dceiswholeslice
*/
extern size_t dcesafeindex(DCEsegment* seg, size_t start, size_t stop);
/* Compute segment size for start up to stop */
extern size_t dcesegmentsize(DCEsegment*, size_t start, size_t stop);
/* Convert a DCE projection/selection/constraint instance into a string
that can be used with a url. Caller must free returned string.
*/
extern char* dcebuildprojectionstring(NClist* projections);
extern char* dcebuildselectionstring(NClist* selections);
extern char* dcebuildconstraintstring(DCEconstraint* constraints);
extern int dceverbose;
#endif /*DCECONSTRAINTS_H*/
|
