Mercurial > repos > ktnyt > gembassy

comparison GEMBASSY-1.0.3/gsoap/wsdl/schema.h @ 2:8947fca5f715 draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author ktnyt
date Fri, 26 Jun 2015 05:21:44 -0400
parents 84a17b3fad1f
children
comparison
equal deleted inserted replaced
1:84a17b3fad1f 2:8947fca5f715
1 /*
2 schema.h
3
4 XSD binding schema interface
5
6 --------------------------------------------------------------------------------
7 gSOAP XML Web services tools
8 Copyright (C) 2000-2013, Robert van Engelen, Genivia Inc. All Rights Reserved.
9 This software is released under one of the following licenses:
10 GPL or Genivia's license for commercial use.
11 --------------------------------------------------------------------------------
12 GPL license.
13
14 This program is free software; you can redistribute it and/or modify it under
15 the terms of the GNU General Public License as published by the Free Software
16 Foundation; either version 2 of the License, or (at your option) any later
17 version.
18
19 This program is distributed in the hope that it will be useful, but WITHOUT ANY
20 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
21 PARTICULAR PURPOSE. See the GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License along with
24 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
25 Place, Suite 330, Boston, MA 02111-1307 USA
26
27 Author contact information:
28 engelen@genivia.com / engelen@acm.org
29 --------------------------------------------------------------------------------
30 A commercial use license is available from Genivia, Inc., contact@genivia.com
31 --------------------------------------------------------------------------------
32
33 */
34
35 //gsoap xs schema documentation: XSD binding schema
36 //gsoap xs schema namespace: http://www.w3.org/2001/XMLSchema
37 //gsoap xs schema elementForm: qualified
38 //gsoap xs schema attributeForm: unqualified
39
40 /* For the wsdl:arrayType attribute to support old style SOAP arrays: */
41 //gsoap wsdl schema namespace: http://schemas.xmlsoap.org/wsdl/
42
43 #import "imports.h"
44
45 class xs__schema; // forward declaration
46 class xs__simpleType; // forward declaration
47 class xs__complexType; // forward declaration
48 class xs__extension; // forward declaration
49 class xs__restriction; // forward declaration
50 class xs__seqchoice; // forward declaration
51 class xs__group; // forward declaration
52 class xs__list; // forward declaration
53 class xs__union; // forward declaration
54
55 class xs__annotation
56 { public:
57 char *documentation;
58 };
59
60 enum xs__formChoice { unqualified, qualified };
61
62 class xs__element
63 { public:
64 // @xsd__ID id;
65 @xsd__NCName name;
66 @xsd__QName ref;
67 @xsd__QName type;
68 @xsd__string default_;
69 @xsd__QName default__; // also get QName value if element type is QName
70 @xsd__string fixed;
71 @xsd__QName fixed_; // also get QName value if element type is QName
72 @enum xs__formChoice *form;
73 @xsd__boolean nillable = false;
74 @xsd__boolean abstract = false;
75 @xsd__QName substitutionGroup;
76 @xsd__string minOccurs; // xsd:nonNegativeInteger
77 @xsd__string maxOccurs; // xsd:nonNegativeInteger|unbounded
78 @xsd__string xmime__expectedContentTypes;
79 xs__annotation *annotation;
80 xs__simpleType *simpleType; // choice
81 xs__complexType *complexType; // choice
82 xsd__string unique; // dummy, not used
83 private:
84 xs__schema *schemaRef; // schema to which this belongs
85 xs__element *elementRef; // traverse() finds ref
86 xs__simpleType *simpleTypeRef; // traverse() finds type or = simpleType above
87 xs__complexType *complexTypeRef; // traverse() finds type or = complexType above
88 std::vector<xs__element*> substitutions; // traverse() finds substitutionGroup elements for this abstract element
89 public:
90 xs__element();
91 int traverse(xs__schema&);
92 void schemaPtr(xs__schema*);
93 void elementPtr(xs__element*);
94 void simpleTypePtr(xs__simpleType*);
95 void complexTypePtr(xs__complexType*);
96 xs__schema *schemaPtr() const;
97 xs__element *elementPtr() const;
98 xs__simpleType *simpleTypePtr() const;
99 xs__complexType *complexTypePtr() const;
100 const std::vector<xs__element*> *substitutionsPtr() const;
101 };
102
103 enum xs__attribute_use { optional, prohibited, required, default_, fixed_ };
104
105 class xs__attribute
106 { public:
107 @xsd__NCName name;
108 @xsd__QName ref;
109 @xsd__QName type;
110 @enum xs__attribute_use use = optional;
111 @xsd__string default_;
112 @xsd__QName default__; // also get QName value if attribute type is QName
113 @xsd__string fixed;
114 @xsd__QName fixed_; // also get QName value if attribute type is QName
115 @enum xs__formChoice *form;
116 @xsd__QName wsdl__arrayType; // extensibility attribute added to simplify WSDL parsing
117 xs__annotation *annotation;
118 xs__simpleType *simpleType;
119 private:
120 xs__schema *schemaRef; // schema to which this belongs
121 xs__attribute *attributeRef; // traverse() finds ref
122 xs__simpleType *simpleTypeRef; // traverse() finds type or = simpleType above
123 public:
124 xs__attribute();
125 int traverse(xs__schema&);
126 void schemaPtr(xs__schema*);
127 void attributePtr(xs__attribute*);
128 void simpleTypePtr(xs__simpleType*);
129 xs__schema *schemaPtr() const;
130 xs__attribute *attributePtr() const;
131 xs__simpleType *simpleTypePtr() const;
132 };
133
134 class xs__all
135 { public:
136 std::vector<xs__element> element;
137 public:
138 int traverse(xs__schema&);
139 };
140
141 enum xs__processContents { strict, skip, lax };
142
143 typedef char *xs__namespaceList; // "##any" or "##other" or list of URI, "##targetNamespace", "##local"
144
145 class xs__any
146 { public:
147 @xs__namespaceList namespace_ = "##any";
148 @enum xs__processContents processContents = strict;
149 @xsd__string minOccurs; // xsd:nonNegativeInteger
150 @xsd__string maxOccurs; // xsd:nonNegativeInteger|unbounded
151 std::vector<xs__element> element;
152 public:
153 int traverse(xs__schema&);
154 };
155
156 class xs__contents
157 { public:
158 $int __union;
159 union xs__union_content
160 { xs__element *element;
161 xs__group *group;
162 xs__seqchoice *choice;
163 xs__seqchoice *sequence;
164 xs__any *any;
165 } __content;
166 public:
167 int traverse(xs__schema&);
168 };
169
170 class xs__seqchoice
171 { public:
172 @xsd__string minOccurs; // xsd:nonNegativeInteger
173 @xsd__string maxOccurs; // xsd:nonNegativeInteger|unbounded
174 xs__annotation *annotation;
175 std::vector<xs__contents> __contents;
176 private:
177 xs__schema *schemaRef; // schema to which this belongs
178 public:
179 xs__seqchoice();
180 int traverse(xs__schema&);
181 void schemaPtr(xs__schema*);
182 xs__schema *schemaPtr() const;
183 };
184
185 class xs__group
186 { public:
187 @xsd__NCName name;
188 @xsd__QName ref;
189 @xsd__string minOccurs; // xsd:nonNegativeInteger
190 @xsd__string maxOccurs; // xsd:nonNegativeInteger|unbounded
191 xs__annotation *annotation;
192 xs__all *all;
193 xs__seqchoice *choice;
194 xs__seqchoice *sequence;
195 private:
196 xs__schema *schemaRef; // schema to which this belongs
197 xs__group *groupRef; // traverse() finds ref
198 public:
199 xs__group();
200 int traverse(xs__schema&);
201 void schemaPtr(xs__schema*);
202 void groupPtr(xs__group*);
203 xs__schema *schemaPtr() const;
204 xs__group *groupPtr() const;
205 };
206
207 class xs__anyAttribute
208 { public:
209 @xs__namespaceList namespace_ = "##any";
210 @enum xs__processContents processContents = strict;
211 };
212
213 class xs__attributeGroup
214 { public:
215 @xsd__NCName name;
216 @xsd__QName ref;
217 xs__annotation *annotation;
218 std::vector<xs__attribute> attribute;
219 std::vector<xs__attributeGroup> attributeGroup;
220 xs__anyAttribute *anyAttribute;
221 private:
222 xs__schema *schemaRef;
223 xs__attributeGroup *attributeGroupRef;
224 public:
225 xs__attributeGroup();
226 int traverse(xs__schema&);
227 void schemaPtr(xs__schema*);
228 void attributeGroupPtr(xs__attributeGroup*);
229 xs__schema *schemaPtr() const;
230 xs__attributeGroup *attributeGroupPtr() const;
231 };
232
233 class xs__enumeration
234 { public:
235 @xsd__string value;
236 @xsd__QName value_; // also get QName value if base type is QName
237 xs__annotation *annotation;
238 public:
239 int traverse(xs__schema&);
240 };
241
242 class xs__pattern
243 { public:
244 @xsd__string value;
245 public:
246 int traverse(xs__schema&);
247 };
248
249 class xs__simpleContent
250 { public:
251 xs__extension *extension; // choice
252 xs__restriction *restriction; // choice
253 public:
254 int traverse(xs__schema&);
255 };
256
257 class xs__simpleType
258 { public:
259 @xsd__NMTOKEN name;
260 xs__annotation *annotation;
261 xs__restriction *restriction; // choice
262 xs__list *list; // choice
263 xs__union *union_; // choice
264 private:
265 xs__schema *schemaRef;
266 int level;
267 public:
268 xs__simpleType();
269 int traverse(xs__schema&);
270 void schemaPtr(xs__schema*);
271 xs__schema *schemaPtr() const;
272 int baseLevel();
273 };
274
275 class xs__extension
276 { public:
277 @xsd__QName base;
278 xs__group *group;
279 xs__all *all;
280 xs__seqchoice *choice;
281 xs__seqchoice *sequence;
282 std::vector<xs__attribute> attribute;
283 std::vector<xs__attributeGroup> attributeGroup;
284 xs__anyAttribute *anyAttribute;
285 private:
286 xs__simpleType *simpleTypeRef; // traverse() finds type
287 xs__complexType *complexTypeRef; // traverse() finds type
288 public:
289 xs__extension();
290 int traverse(xs__schema&);
291 void simpleTypePtr(xs__simpleType*);
292 void complexTypePtr(xs__complexType*);
293 xs__simpleType *simpleTypePtr() const;
294 xs__complexType *complexTypePtr() const;
295 };
296
297 class xs__length
298 { public:
299 @xsd__string value;
300 @xsd__boolean fixed;
301 xs__annotation *annotation;
302 };
303
304 class xs__whiteSpace
305 { public:
306 @xsd__string value;
307 };
308
309 class xs__restriction
310 { public:
311 @xsd__QName base;
312 xs__simpleType *simpleType; // used in <simpleType><restriction>
313 xs__attributeGroup *attributeGroup;// not used in <simpleType><restriction>
314 xs__group *group; // not used in <simpleType><restriction>
315 xs__all *all; // not used in <simpleType><restriction>
316 xs__seqchoice *choice; // not used in <simpleType><restriction>
317 xs__seqchoice *sequence; // not used in <simpleType><restriction>
318 std::vector<xs__attribute> attribute; // not used in <simpleType><restriction>
319 xs__anyAttribute *anyAttribute; // not used in <simpleType><restriction>
320 std::vector<xs__enumeration> enumeration;
321 std::vector<xs__pattern> pattern;
322 xs__whiteSpace *whiteSpace;
323 xs__length *length;
324 xs__length *minLength;
325 xs__length *maxLength;
326 xs__length *precision; // 2000 schema
327 xs__length *scale; // 2000 schema
328 xs__length *totalDigits; // 2001 schema
329 xs__length *fractionDigits; // 2001 schema
330 xs__length *minInclusive;
331 xs__length *maxInclusive;
332 xs__length *minExclusive;
333 xs__length *maxExclusive;
334 xs__annotation *annotation;
335 private:
336 xs__simpleType *simpleTypeRef; // traverse() finds type
337 xs__complexType *complexTypeRef; // traverse() finds type
338 public:
339 xs__restriction();
340 int traverse(xs__schema&);
341 void simpleTypePtr(xs__simpleType*);
342 void complexTypePtr(xs__complexType*);
343 xs__simpleType *simpleTypePtr() const;
344 xs__complexType *complexTypePtr() const;
345 };
346
347 class xs__list
348 { public:
349 @xsd__QName itemType;
350 xs__restriction *restriction; // choice
351 std::vector<xs__simpleType> simpleType; // choice
352 private:
353 xs__simpleType *itemTypeRef;
354 public:
355 xs__list();
356 int traverse(xs__schema&);
357 void itemTypePtr(xs__simpleType*);
358 xs__simpleType *itemTypePtr() const;
359 };
360
361 class xs__union
362 { public:
363 @xsd__NMTOKENS memberTypes; // check if NMTOKENS is ok???
364 std::vector<xs__simpleType> simpleType;
365 public:
366 int traverse(xs__schema&);
367 };
368
369 class xs__complexContent
370 { public:
371 @xsd__boolean mixed = false;
372 xs__extension *extension;
373 xs__restriction *restriction;
374 public:
375 int traverse(xs__schema&);
376 };
377
378 class xs__complexType
379 { public:
380 @xsd__NMTOKEN name;
381 @xsd__boolean abstract = false;
382 @xsd__boolean mixed = false;
383 xs__annotation *annotation;
384 xs__simpleContent *simpleContent;
385 xs__complexContent *complexContent;
386 xs__all *all;
387 xs__seqchoice *choice;
388 xs__seqchoice *sequence;
389 xs__any *any;
390 std::vector<xs__attribute> attribute;
391 std::vector<xs__attributeGroup> attributeGroup;
392 xs__anyAttribute *anyAttribute;
393 private:
394 xs__schema *schemaRef;
395 int level;
396 public:
397 xs__complexType();
398 int traverse(xs__schema&);
399 void schemaPtr(xs__schema*);
400 xs__schema *schemaPtr() const;
401 int baseLevel();
402 };
403
404 class xs__import
405 { public:
406 @xsd__anyURI namespace_;
407 @xsd__anyURI schemaLocation;
408 private:
409 xs__schema *schemaRef; // set by WSDL parser or via schemaLocation
410 public:
411 xs__import();
412 int traverse(xs__schema&);
413 void schemaPtr(xs__schema*);
414 xs__schema *schemaPtr() const;
415 };
416
417 class xs__include
418 { public:
419 @xsd__anyURI schemaLocation;
420 private:
421 xs__schema *schemaRef;
422 public:
423 xs__include();
424 int preprocess(xs__schema&);
425 int traverse(xs__schema&);
426 void schemaPtr(xs__schema*);
427 xs__schema *schemaPtr() const;
428 };
429
430 class xs__redefine
431 { public:
432 @xsd__anyURI schemaLocation;
433 std::vector<xs__group> group;
434 std::vector<xs__attributeGroup> attributeGroup;
435 std::vector<xs__simpleType> simpleType;
436 std::vector<xs__complexType> complexType;
437 private:
438 xs__schema *schemaRef;
439 public:
440 xs__redefine();
441 int preprocess(xs__schema&);
442 int traverse(xs__schema&);
443 void schemaPtr(xs__schema*);
444 xs__schema *schemaPtr() const;
445 };
446
447 class xs__schema
448 { public:
449 @xsd__anyURI targetNamespace = "";
450 @xsd__string version;
451 @enum xs__formChoice attributeFormDefault = unqualified;
452 @enum xs__formChoice elementFormDefault = unqualified;
453 xs__annotation *annotation;
454 std::vector<xs__include> include;
455 std::vector<xs__redefine> redefine;
456 std::vector<xs__import> import;
457 std::vector<xs__attribute> attribute;
458 std::vector<xs__element> element;
459 std::vector<xs__group> group;
460 std::vector<xs__attributeGroup> attributeGroup;
461 std::vector<xs__simpleType> simpleType;
462 std::vector<xs__complexType> complexType;
463 struct soap *soap;
464 private:
465 bool updated;
466 char* location;
467 int redirs;
468 SetOfString builtinTypeSet;
469 SetOfString builtinElementSet;
470 SetOfString builtinAttributeSet;
471 public:
472 xs__schema();
473 xs__schema(struct soap*);
474 xs__schema(struct soap*, const char*, const char*);
475 virtual ~xs__schema();
476 int get(struct soap*); // gSOAP getter is triggered after parsing
477 int preprocess();
478 int insert(xs__schema&);
479 int traverse();
480 int read(const char*, const char*);
481 void sourceLocation(const char*);
482 const char* sourceLocation();
483 int error();
484 void print_fault();
485 void builtinType(const char*);
486 void builtinElement(const char*);
487 void builtinAttribute(const char*);
488 const SetOfString& builtinTypes() const;
489 const SetOfString& builtinElements() const;
490 const SetOfString& builtinAttributes() const;
491 bool empty() const;
492 friend ostream& operator<<(ostream&, const xs__schema&);
493 friend istream& operator>>(istream&, xs__schema&);
494 };
495
496 extern ostream &operator<<(ostream &o, const xs__schema &e);
497 extern istream &operator>>(istream &i, xs__schema &e);
498