Context Navigation

xml-schema-pskel.hxx @ 120

Revision 111, 14.1 kB (checked in by mido, 18 years ago)
pridana knihovna XSD (a jeji chlebodarkyne XERCES), v ramci Win32 zprovoznen priklad tests/test_xsd_hello.cxx

Line
1	// file : xsd/cxx/parser/validating/xml-schema-pskel.hxx
2	// author : Boris Kolpackov <boris@codesynthesis.com>
3	// copyright : Copyright (c) 2005-2008 Code Synthesis Tools CC
4	// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
5
6	#ifndef XSD_CXX_PARSER_VALIDATING_XML_SCHEMA_PSKEL_HXX
7	#define XSD_CXX_PARSER_VALIDATING_XML_SCHEMA_PSKEL_HXX
8
9	#include <string>
10	#include <memory> // auto_ptr
11
12	#include <xsd/cxx/parser/xml-schema.hxx>
13	#include <xsd/cxx/parser/validating/parser.hxx>
14
15	namespace xsd
16	{
17	namespace cxx
18	{
19	namespace parser
20	{
21	namespace validating
22	{
23	// anyType and anySimpleType. All events are routed to the
24	// _any_* callbacks.
25	//
26	template <typename C>
27	struct any_type_pskel: virtual complex_content<C>
28	{
29	virtual bool
30	_start_element_impl (const ro_string<C>&,
31	const ro_string<C>&,
32	const ro_string<C>*);
33
34	virtual bool
35	_end_element_impl (const ro_string<C>&,
36	const ro_string<C>&);
37
38	virtual bool
39	_attribute_impl_phase_two (const ro_string<C>&,
40	const ro_string<C>&,
41	const ro_string<C>&);
42
43	virtual bool
44	_characters_impl (const ro_string<C>&);
45
46	virtual void
47	post_any_type () = 0;
48
49	static const C*
50	_static_type ();
51
52	virtual const C*
53	_dynamic_type () const;
54	};
55
56	template <typename C>
57	struct any_simple_type_pskel: virtual simple_content<C>
58	{
59	virtual bool
60	_characters_impl (const ro_string<C>&);
61
62	virtual void
63	post_any_simple_type () = 0;
64
65	static const C*
66	_static_type ();
67
68	virtual const C*
69	_dynamic_type () const;
70	};
71
72
73	// Boolean.
74	//
75	template <typename C>
76	struct boolean_pskel: virtual simple_content<C>
77	{
78	virtual bool
79	post_boolean () = 0;
80
81	static const C*
82	_static_type ();
83
84	virtual const C*
85	_dynamic_type () const;
86	};
87
88
89	// 8-bit
90	//
91	template <typename C>
92	struct byte_pskel: virtual simple_content<C>
93	{
94	virtual signed char
95	post_byte () = 0;
96
97	static const C*
98	_static_type ();
99
100	virtual const C*
101	_dynamic_type () const;
102	};
103
104	template <typename C>
105	struct unsigned_byte_pskel: virtual simple_content<C>
106	{
107	virtual unsigned char
108	post_unsigned_byte () = 0;
109
110	static const C*
111	_static_type ();
112
113	virtual const C*
114	_dynamic_type () const;
115	};
116
117
118	// 16-bit
119	//
120	template <typename C>
121	struct short_pskel: virtual simple_content<C>
122	{
123	virtual short
124	post_short () = 0;
125
126	static const C*
127	_static_type ();
128
129	virtual const C*
130	_dynamic_type () const;
131	};
132
133	template <typename C>
134	struct unsigned_short_pskel: virtual simple_content<C>
135	{
136	virtual unsigned short
137	post_unsigned_short () = 0;
138
139	static const C*
140	_static_type ();
141
142	virtual const C*
143	_dynamic_type () const;
144	};
145
146
147	// 32-bit
148	//
149	template <typename C>
150	struct int_pskel: virtual simple_content<C>
151	{
152	virtual int
153	post_int () = 0;
154
155	static const C*
156	_static_type ();
157
158	virtual const C*
159	_dynamic_type () const;
160	};
161
162	template <typename C>
163	struct unsigned_int_pskel: virtual simple_content<C>
164	{
165	virtual unsigned int
166	post_unsigned_int () = 0;
167
168	static const C*
169	_static_type ();
170
171	virtual const C*
172	_dynamic_type () const;
173	};
174
175
176	// 64-bit
177	//
178	template <typename C>
179	struct long_pskel: virtual simple_content<C>
180	{
181	virtual long long
182	post_long () = 0;
183
184	static const C*
185	_static_type ();
186
187	virtual const C*
188	_dynamic_type () const;
189	};
190
191	template <typename C>
192	struct unsigned_long_pskel: virtual simple_content<C>
193	{
194	virtual unsigned long long
195	post_unsigned_long () = 0;
196
197	static const C*
198	_static_type ();
199
200	virtual const C*
201	_dynamic_type () const;
202	};
203
204
205	// Arbitrary-length integers.
206	//
207	template <typename C>
208	struct integer_pskel: virtual simple_content<C>
209	{
210	virtual long long
211	post_integer () = 0;
212
213	static const C*
214	_static_type ();
215
216	virtual const C*
217	_dynamic_type () const;
218	};
219
220	template <typename C>
221	struct negative_integer_pskel: virtual simple_content<C>
222	{
223	virtual long long
224	post_negative_integer () = 0;
225
226	static const C*
227	_static_type ();
228
229	virtual const C*
230	_dynamic_type () const;
231	};
232
233	template <typename C>
234	struct non_positive_integer_pskel: virtual simple_content<C>
235	{
236	virtual long long
237	post_non_positive_integer () = 0;
238
239	static const C*
240	_static_type ();
241
242	virtual const C*
243	_dynamic_type () const;
244	};
245
246	template <typename C>
247	struct positive_integer_pskel: virtual simple_content<C>
248	{
249	virtual unsigned long long
250	post_positive_integer () = 0;
251
252	static const C*
253	_static_type ();
254
255	virtual const C*
256	_dynamic_type () const;
257	};
258
259	template <typename C>
260	struct non_negative_integer_pskel: virtual simple_content<C>
261	{
262	virtual unsigned long long
263	post_non_negative_integer () = 0;
264
265	static const C*
266	_static_type ();
267
268	virtual const C*
269	_dynamic_type () const;
270	};
271
272
273	// Floats.
274	//
275	template <typename C>
276	struct float_pskel: virtual simple_content<C>
277	{
278	virtual float
279	post_float () = 0;
280
281	static const C*
282	_static_type ();
283
284	virtual const C*
285	_dynamic_type () const;
286	};
287
288	template <typename C>
289	struct double_pskel: virtual simple_content<C>
290	{
291	virtual double
292	post_double () = 0;
293
294	static const C*
295	_static_type ();
296
297	virtual const C*
298	_dynamic_type () const;
299	};
300
301	template <typename C>
302	struct decimal_pskel: virtual simple_content<C>
303	{
304	virtual double
305	post_decimal () = 0;
306
307	static const C*
308	_static_type ();
309
310	virtual const C*
311	_dynamic_type () const;
312	};
313
314
315	// Strings.
316	//
317	template <typename C>
318	struct string_pskel: virtual simple_content<C>
319	{
320	virtual std::basic_string<C>
321	post_string () = 0;
322
323	static const C*
324	_static_type ();
325
326	virtual const C*
327	_dynamic_type () const;
328	};
329
330	template <typename C>
331	struct normalized_string_pskel: virtual simple_content<C>
332	{
333	virtual std::basic_string<C>
334	post_normalized_string () = 0;
335
336	static const C*
337	_static_type ();
338
339	virtual const C*
340	_dynamic_type () const;
341	};
342
343	template <typename C>
344	struct token_pskel: virtual simple_content<C>
345	{
346	virtual std::basic_string<C>
347	post_token () = 0;
348
349	static const C*
350	_static_type ();
351
352	virtual const C*
353	_dynamic_type () const;
354	};
355
356	template <typename C>
357	struct name_pskel: virtual simple_content<C>
358	{
359	virtual std::basic_string<C>
360	post_name () = 0;
361
362	static const C*
363	_static_type ();
364
365	virtual const C*
366	_dynamic_type () const;
367	};
368
369	template <typename C>
370	struct nmtoken_pskel: virtual simple_content<C>
371	{
372	virtual std::basic_string<C>
373	post_nmtoken () = 0;
374
375	static const C*
376	_static_type ();
377
378	virtual const C*
379	_dynamic_type () const;
380	};
381
382	template <typename C>
383	struct nmtokens_pskel: list_base<C>
384	{
385	virtual string_sequence<C>
386	post_nmtokens () = 0;
387
388	static const C*
389	_static_type ();
390
391	virtual const C*
392	_dynamic_type () const;
393	};
394
395	template <typename C>
396	struct ncname_pskel: virtual simple_content<C>
397	{
398	virtual std::basic_string<C>
399	post_ncname () = 0;
400
401	static const C*
402	_static_type ();
403
404	virtual const C*
405	_dynamic_type () const;
406	};
407
408	template <typename C>
409	struct id_pskel: virtual ncname_pskel<C>
410	{
411	virtual std::basic_string<C>
412	post_id () = 0;
413
414	static const C*
415	_static_type ();
416
417	virtual const C*
418	_dynamic_type () const;
419	};
420
421	template <typename C>
422	struct idref_pskel: virtual ncname_pskel<C>
423	{
424	virtual std::basic_string<C>
425	post_idref () = 0;
426
427	static const C*
428	_static_type ();
429
430	virtual const C*
431	_dynamic_type () const;
432	};
433
434	template <typename C>
435	struct idrefs_pskel: list_base<C>
436	{
437	virtual string_sequence<C>
438	post_idrefs () = 0;
439
440	static const C*
441	_static_type ();
442
443	virtual const C*
444	_dynamic_type () const;
445	};
446
447	// Language.
448	//
449	template <typename C>
450	struct language_pskel: virtual simple_content<C>
451	{
452	virtual std::basic_string<C>
453	post_language () = 0;
454
455	static const C*
456	_static_type ();
457
458	virtual const C*
459	_dynamic_type () const;
460	};
461
462	// URI.
463	//
464	template <typename C>
465	struct uri_pskel: virtual simple_content<C>
466	{
467	virtual std::basic_string<C>
468	post_uri () = 0;
469
470	static const C*
471	_static_type ();
472
473	virtual const C*
474	_dynamic_type () const;
475	};
476
477	// QName.
478	//
479	template <typename C>
480	struct qname_pskel: virtual simple_content<C>
481	{
482	virtual qname<C>
483	post_qname () = 0;
484
485	static const C*
486	_static_type ();
487
488	virtual const C*
489	_dynamic_type () const;
490	};
491
492	// Base64 and hex binaries.
493	//
494	template <typename C>
495	struct base64_binary_pskel: virtual simple_content<C>
496	{
497	virtual std::auto_ptr<buffer>
498	post_base64_binary () = 0;
499
500	static const C*
501	_static_type ();
502
503	virtual const C*
504	_dynamic_type () const;
505	};
506
507	template <typename C>
508	struct hex_binary_pskel: virtual simple_content<C>
509	{
510	virtual std::auto_ptr<buffer>
511	post_hex_binary () = 0;
512
513	static const C*
514	_static_type ();
515
516	virtual const C*
517	_dynamic_type () const;
518	};
519
520	// Time and date types.
521	//
522	template <typename C>
523	struct gday_pskel: virtual simple_content<C>
524	{
525	virtual gday
526	post_gday () = 0;
527
528	static const C*
529	_static_type ();
530
531	virtual const C*
532	_dynamic_type () const;
533	};
534
535	template <typename C>
536	struct gmonth_pskel: virtual simple_content<C>
537	{
538	virtual gmonth
539	post_gmonth () = 0;
540
541	static const C*
542	_static_type ();
543
544	virtual const C*
545	_dynamic_type () const;
546	};
547
548	template <typename C>
549	struct gyear_pskel: virtual simple_content<C>
550	{
551	virtual gyear
552	post_gyear () = 0;
553
554	static const C*
555	_static_type ();
556
557	virtual const C*
558	_dynamic_type () const;
559	};
560
561	template <typename C>
562	struct gmonth_day_pskel: virtual simple_content<C>
563	{
564	virtual gmonth_day
565	post_gmonth_day () = 0;
566
567	static const C*
568	_static_type ();
569
570	virtual const C*
571	_dynamic_type () const;
572	};
573
574	template <typename C>
575	struct gyear_month_pskel: virtual simple_content<C>
576	{
577	virtual gyear_month
578	post_gyear_month () = 0;
579
580	static const C*
581	_static_type ();
582
583	virtual const C*
584	_dynamic_type () const;
585	};
586
587	template <typename C>
588	struct date_pskel: virtual simple_content<C>
589	{
590	virtual date
591	post_date () = 0;
592
593	static const C*
594	_static_type ();
595
596	virtual const C*
597	_dynamic_type () const;
598	};
599
600	template <typename C>
601	struct time_pskel: virtual simple_content<C>
602	{
603	virtual time
604	post_time () = 0;
605
606	static const C*
607	_static_type ();
608
609	virtual const C*
610	_dynamic_type () const;
611	};
612
613	template <typename C>
614	struct date_time_pskel: virtual simple_content<C>
615	{
616	virtual date_time
617	post_date_time () = 0;
618
619	static const C*
620	_static_type ();
621
622	virtual const C*
623	_dynamic_type () const;
624	};
625
626	template <typename C>
627	struct duration_pskel: virtual simple_content<C>
628	{
629	virtual duration
630	post_duration () = 0;
631
632	static const C*
633	_static_type ();
634
635	virtual const C*
636	_dynamic_type () const;
637	};
638	}
639	}
640	}
641	}
642
643	#include <xsd/cxx/parser/validating/xml-schema-pskel.txx>
644
645	#endif // XSD_CXX_PARSER_VALIDATING_XML_SCHEMA_PSKEL_HXX
646
647	#include <xsd/cxx/parser/validating/xml-schema-pskel.ixx>

Note: See TracBrowser for help on using the browser.

Download in other formats:

Original Format