BT-MatML-Editor 0.1.4
Editor for the MatML 3.1 XML Schema
matml31.hxx
1// Copyright (c) 2005-2014 Code Synthesis Tools CC
2//
3// This program was generated by CodeSynthesis XSD, an XML Schema to
4// C++ data binding compiler.
5//
6// This program is free software; you can redistribute it and/or modify
7// it under the terms of the GNU General Public License version 2 as
8// published by the Free Software Foundation.
9//
10// This program is distributed in the hope that it will be useful,
11// but WITHOUT ANY WARRANTY; without even the implied warranty of
12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13// GNU General Public License for more details.
14//
15// You should have received a copy of the GNU General Public License
16// along with this program; if not, write to the Free Software
17// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18//
19// In addition, as a special exception, Code Synthesis Tools CC gives
20// permission to link this program with the Xerces-C++ library (or with
21// modified versions of Xerces-C++ that use the same license as Xerces-C++),
22// and distribute linked combinations including the two. You must obey
23// the GNU General Public License version 2 in all respects for all of
24// the code used other than Xerces-C++. If you modify this copy of the
25// program, you may extend this exception to your version of the program,
26// but you are not obligated to do so. If you do not wish to do so, delete
27// this exception statement from your version.
28//
29// Furthermore, Code Synthesis Tools CC makes a special exception for
30// the Free/Libre and Open Source Software (FLOSS) which is described
31// in the accompanying FLOSSE file.
32//
33
34#ifndef MATML31_HXX
35#define MATML31_HXX
36
37#ifndef XSD_USE_CHAR
38#define XSD_USE_CHAR
39#endif
40
41#ifndef XSD_CXX_TREE_USE_CHAR
42#define XSD_CXX_TREE_USE_CHAR
43#endif
44
45// Begin prologue.
46//
47//
48// End prologue.
49
50#include <xsd/cxx/config.hxx>
51
52#if (XSD_INT_VERSION != 4000000L)
53#error XSD runtime version mismatch
54#endif
55
56#include <xsd/cxx/pre.hxx>
57
58#include <xsd/cxx/xml/char-utf8.hxx>
59
60#include <xsd/cxx/tree/exceptions.hxx>
61#include <xsd/cxx/tree/elements.hxx>
62#include <xsd/cxx/tree/types.hxx>
63
64#include <xsd/cxx/xml/error-handler.hxx>
65
66#include <xsd/cxx/xml/dom/auto-ptr.hxx>
67
68#include <xsd/cxx/tree/parsing.hxx>
69#include <xsd/cxx/tree/parsing/byte.hxx>
70#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
71#include <xsd/cxx/tree/parsing/short.hxx>
72#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
73#include <xsd/cxx/tree/parsing/int.hxx>
74#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
75#include <xsd/cxx/tree/parsing/long.hxx>
76#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
77#include <xsd/cxx/tree/parsing/boolean.hxx>
78#include <xsd/cxx/tree/parsing/float.hxx>
79#include <xsd/cxx/tree/parsing/double.hxx>
80#include <xsd/cxx/tree/parsing/decimal.hxx>
81
82#include <xsd/cxx/xml/dom/serialization-header.hxx>
83#include <xsd/cxx/tree/serialization.hxx>
84#include <xsd/cxx/tree/serialization/byte.hxx>
85#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
86#include <xsd/cxx/tree/serialization/short.hxx>
87#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
88#include <xsd/cxx/tree/serialization/int.hxx>
89#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
90#include <xsd/cxx/tree/serialization/long.hxx>
91#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
92#include <xsd/cxx/tree/serialization/boolean.hxx>
93#include <xsd/cxx/tree/serialization/float.hxx>
94#include <xsd/cxx/tree/serialization/double.hxx>
95#include <xsd/cxx/tree/serialization/decimal.hxx>
96
97#include <xsd/cxx/tree/std-ostream-operators.hxx>
98
99namespace xml_schema
100{
101 // anyType and anySimpleType.
102 //
103 typedef ::xsd::cxx::tree::type type;
104 typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;
105 typedef ::xsd::cxx::tree::type container;
106
107 // 8-bit
108 //
109 typedef signed char byte;
110 typedef unsigned char unsigned_byte;
111
112 // 16-bit
113 //
114 typedef short short_;
115 typedef unsigned short unsigned_short;
116
117 // 32-bit
118 //
119 typedef int int_;
120 typedef unsigned int unsigned_int;
121
122 // 64-bit
123 //
124 typedef long long long_;
125 typedef unsigned long long unsigned_long;
126
127 // Supposed to be arbitrary-length integral types.
128 //
129 typedef long long integer;
130 typedef long long non_positive_integer;
131 typedef unsigned long long non_negative_integer;
132 typedef unsigned long long positive_integer;
133 typedef long long negative_integer;
134
135 // Boolean.
136 //
137 typedef bool boolean;
138
139 // Floating-point types.
140 //
141 typedef float float_;
142 typedef double double_;
143 typedef double decimal;
144
145 // String types.
146 //
147 typedef ::xsd::cxx::tree::string< char, simple_type > string;
148 typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;
149 typedef ::xsd::cxx::tree::token< char, normalized_string > token;
150 typedef ::xsd::cxx::tree::name< char, token > name;
151 typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;
152 typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;
153 typedef ::xsd::cxx::tree::ncname< char, name > ncname;
154 typedef ::xsd::cxx::tree::language< char, token > language;
155
156 // ID/IDREF.
157 //
158 typedef ::xsd::cxx::tree::id< char, ncname > id;
159 typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;
160 typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;
161
162 // URI.
163 //
164 typedef ::xsd::cxx::tree::uri< char, simple_type > uri;
165
166 // Qualified name.
167 //
168 typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;
169
170 // Binary.
171 //
172 typedef ::xsd::cxx::tree::buffer< char > buffer;
173 typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;
174 typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;
175
176 // Date/time.
177 //
178 typedef ::xsd::cxx::tree::time_zone time_zone;
179 typedef ::xsd::cxx::tree::date< char, simple_type > date;
180 typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;
181 typedef ::xsd::cxx::tree::duration< char, simple_type > duration;
182 typedef ::xsd::cxx::tree::gday< char, simple_type > gday;
183 typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;
184 typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;
185 typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;
186 typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;
187 typedef ::xsd::cxx::tree::time< char, simple_type > time;
188
189 // Entity.
190 //
191 typedef ::xsd::cxx::tree::entity< char, ncname > entity;
192 typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;
193
194 typedef ::xsd::cxx::tree::content_order content_order;
195 // Namespace information and list stream. Used in
196 // serialization functions.
197 //
198 typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;
199 typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;
200 typedef ::xsd::cxx::tree::list_stream< char > list_stream;
201 typedef ::xsd::cxx::tree::as_double< double_ > as_double;
202 typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;
203 typedef ::xsd::cxx::tree::facet facet;
204
205 // Flags and properties.
206 //
207 typedef ::xsd::cxx::tree::flags flags;
208 typedef ::xsd::cxx::tree::properties< char > properties;
209
210 // Parsing/serialization diagnostics.
211 //
212 typedef ::xsd::cxx::tree::severity severity;
213 typedef ::xsd::cxx::tree::error< char > error;
214 typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;
215
216 // Exceptions.
217 //
218 typedef ::xsd::cxx::tree::exception< char > exception;
219 typedef ::xsd::cxx::tree::bounds< char > bounds;
220 typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;
221 typedef ::xsd::cxx::tree::parsing< char > parsing;
222 typedef ::xsd::cxx::tree::expected_element< char > expected_element;
223 typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;
224 typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;
225 typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;
226 typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;
227 typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;
228 typedef ::xsd::cxx::tree::serialization< char > serialization;
229
230 // Error handler callback interface.
231 //
232 typedef ::xsd::cxx::xml::error_handler< char > error_handler;
233
234 // DOM interaction.
235 //
236 namespace dom
237 {
238 // Automatic pointer for DOMDocument.
239 //
240 using ::xsd::cxx::xml::dom::auto_ptr;
241
242#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
243#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
244 // DOM user data key for back pointers to tree nodes.
245 //
246 const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
247#endif
248 }
249}
250
251// Forward declarations.
252//
253class Associate;
254class AssociationDetails;
255class BulkDetails;
256class Characterization;
257class ChemicalComposition;
258class Class;
259class ComponentDetails;
260class Compound;
261class Concentration;
262class DataFormat;
263class DimensionalDetails;
264class Element;
265class Form;
266class Formula;
267class Geometry;
268class Glossary;
269class GlossaryTerm;
270class Graphs;
271class Material;
272class Metadata;
273class Name;
274class Notes;
275class ParameterValue;
276class PhaseComposition;
277class ProcessingDetails;
278class PropertyData;
279class Qualifier;
280class Relationship;
281class Source;
282class Specification;
283class Uncertainty;
284class Unit;
285class Unitless;
286class Units;
287class Value;
288class AuthorityDetails;
289class DataSourceDetails;
290class MeasurementTechniqueDetails;
291class ParameterDetails;
292class PropertyDetails;
293class SourceDetails;
294class SpecimenDetails;
295class TestConditionDetails;
296class ChemicalElementSymbol;
297class CurrencyCode;
298class MatML_Doc;
299class ParentMaterial;
300class Symbol;
301class Graph;
302class Data;
303class Data1;
304class delimiter;
305class Scale;
306
307#include <memory> // ::std::auto_ptr
308#include <limits> // std::numeric_limits
309#include <algorithm> // std::binary_search
310
311#include <xsd/cxx/xml/char-utf8.hxx>
312
313#include <xsd/cxx/tree/exceptions.hxx>
314#include <xsd/cxx/tree/elements.hxx>
315#include <xsd/cxx/tree/containers.hxx>
316#include <xsd/cxx/tree/list.hxx>
317
318#include <xsd/cxx/xml/dom/parsing-header.hxx>
319
320class Associate: public ::xml_schema::string
321{
322 public:
323 // Constructors.
324 //
325 Associate ();
326
327 Associate (const char*);
328
329 Associate (const ::std::string&);
330
331 Associate (const ::xml_schema::string&);
332
333 Associate (const ::xercesc::DOMElement& e,
334 ::xml_schema::flags f = 0,
335 ::xml_schema::container* c = 0);
336
337 Associate (const ::xercesc::DOMAttr& a,
338 ::xml_schema::flags f = 0,
339 ::xml_schema::container* c = 0);
340
341 Associate (const ::std::string& s,
342 const ::xercesc::DOMElement* e,
343 ::xml_schema::flags f = 0,
344 ::xml_schema::container* c = 0);
345
346 Associate (const Associate& x,
347 ::xml_schema::flags f = 0,
348 ::xml_schema::container* c = 0);
349
350 virtual Associate*
351 _clone (::xml_schema::flags f = 0,
352 ::xml_schema::container* c = 0) const;
353
354 virtual
355 ~Associate ();
356};
357
358class AssociationDetails: public ::xml_schema::type
359{
360 public:
361 // Associate
362 //
363 typedef ::Associate Associate_type;
364 typedef ::xsd::cxx::tree::optional< Associate_type > Associate_optional;
365 typedef ::xsd::cxx::tree::traits< Associate_type, char > Associate_traits;
366
367 const Associate_optional&
368 Associate () const;
369
370 Associate_optional&
371 Associate ();
372
373 void
374 Associate (const Associate_type& x);
375
376 void
377 Associate (const Associate_optional& x);
378
379 void
380 Associate (::std::auto_ptr< Associate_type > p);
381
382 // Relationship
383 //
384 typedef ::Relationship Relationship_type;
385 typedef ::xsd::cxx::tree::optional< Relationship_type > Relationship_optional;
386 typedef ::xsd::cxx::tree::traits< Relationship_type, char > Relationship_traits;
387
388 const Relationship_optional&
389 Relationship () const;
390
391 Relationship_optional&
392 Relationship ();
393
394 void
395 Relationship (const Relationship_type& x);
396
397 void
398 Relationship (const Relationship_optional& x);
399
400 void
401 Relationship (::std::auto_ptr< Relationship_type > p);
402
403 // Notes
404 //
405 typedef ::Notes Notes_type;
406 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
407 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
408
409 const Notes_optional&
410 Notes () const;
411
412 Notes_optional&
413 Notes ();
414
415 void
416 Notes (const Notes_type& x);
417
418 void
419 Notes (const Notes_optional& x);
420
421 void
422 Notes (::std::auto_ptr< Notes_type > p);
423
424 // Constructors.
425 //
426 AssociationDetails ();
427
428 AssociationDetails (const ::xercesc::DOMElement& e,
429 ::xml_schema::flags f = 0,
430 ::xml_schema::container* c = 0);
431
432 AssociationDetails (const AssociationDetails& x,
433 ::xml_schema::flags f = 0,
434 ::xml_schema::container* c = 0);
435
436 virtual AssociationDetails*
437 _clone (::xml_schema::flags f = 0,
438 ::xml_schema::container* c = 0) const;
439
440 AssociationDetails&
441 operator= (const AssociationDetails& x);
442
443 virtual
444 ~AssociationDetails ();
445
446 // Implementation.
447 //
448 protected:
449 void
450 parse (::xsd::cxx::xml::dom::parser< char >&,
451 ::xml_schema::flags);
452
453 protected:
454 Associate_optional Associate_;
455 Relationship_optional Relationship_;
456 Notes_optional Notes_;
457};
458
459class BulkDetails: public ::xml_schema::type
460{
461 public:
462 // Name
463 //
464 typedef ::Name Name_type;
465 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
466
467 const Name_type&
468 Name () const;
469
470 Name_type&
471 Name ();
472
473 void
474 Name (const Name_type& x);
475
476 void
477 Name (::std::auto_ptr< Name_type > p);
478
479 // Class
480 //
481 typedef ::Class Class_type;
482 typedef ::xsd::cxx::tree::sequence< Class_type > Class_sequence;
483 typedef Class_sequence::iterator Class_iterator;
484 typedef Class_sequence::const_iterator Class_const_iterator;
485 typedef ::xsd::cxx::tree::traits< Class_type, char > Class_traits;
486
487 const Class_sequence&
488 Class () const;
489
490 Class_sequence&
491 Class ();
492
493 void
494 Class (const Class_sequence& s);
495
496 // Subclass
497 //
498 typedef ::Class Subclass_type;
499 typedef ::xsd::cxx::tree::sequence< Subclass_type > Subclass_sequence;
500 typedef Subclass_sequence::iterator Subclass_iterator;
501 typedef Subclass_sequence::const_iterator Subclass_const_iterator;
502 typedef ::xsd::cxx::tree::traits< Subclass_type, char > Subclass_traits;
503
504 const Subclass_sequence&
505 Subclass () const;
506
507 Subclass_sequence&
508 Subclass ();
509
510 void
511 Subclass (const Subclass_sequence& s);
512
513 // Specification
514 //
515 typedef ::Specification Specification_type;
516 typedef ::xsd::cxx::tree::sequence< Specification_type > Specification_sequence;
517 typedef Specification_sequence::iterator Specification_iterator;
518 typedef Specification_sequence::const_iterator Specification_const_iterator;
519 typedef ::xsd::cxx::tree::traits< Specification_type, char > Specification_traits;
520
521 const Specification_sequence&
522 Specification () const;
523
524 Specification_sequence&
525 Specification ();
526
527 void
528 Specification (const Specification_sequence& s);
529
530 // Source
531 //
532 typedef ::Source Source_type;
533 typedef ::xsd::cxx::tree::optional< Source_type > Source_optional;
534 typedef ::xsd::cxx::tree::traits< Source_type, char > Source_traits;
535
536 const Source_optional&
537 Source () const;
538
539 Source_optional&
540 Source ();
541
542 void
543 Source (const Source_type& x);
544
545 void
546 Source (const Source_optional& x);
547
548 void
549 Source (::std::auto_ptr< Source_type > p);
550
551 // Form
552 //
553 typedef ::Form Form_type;
554 typedef ::xsd::cxx::tree::optional< Form_type > Form_optional;
555 typedef ::xsd::cxx::tree::traits< Form_type, char > Form_traits;
556
557 const Form_optional&
558 Form () const;
559
560 Form_optional&
561 Form ();
562
563 void
564 Form (const Form_type& x);
565
566 void
567 Form (const Form_optional& x);
568
569 void
570 Form (::std::auto_ptr< Form_type > p);
571
572 // ProcessingDetails
573 //
574 typedef ::ProcessingDetails ProcessingDetails_type;
575 typedef ::xsd::cxx::tree::sequence< ProcessingDetails_type > ProcessingDetails_sequence;
576 typedef ProcessingDetails_sequence::iterator ProcessingDetails_iterator;
577 typedef ProcessingDetails_sequence::const_iterator ProcessingDetails_const_iterator;
578 typedef ::xsd::cxx::tree::traits< ProcessingDetails_type, char > ProcessingDetails_traits;
579
580 const ProcessingDetails_sequence&
581 ProcessingDetails () const;
582
583 ProcessingDetails_sequence&
584 ProcessingDetails ();
585
586 void
587 ProcessingDetails (const ProcessingDetails_sequence& s);
588
589 // Characterization
590 //
591 typedef ::Characterization Characterization_type;
592 typedef ::xsd::cxx::tree::optional< Characterization_type > Characterization_optional;
593 typedef ::xsd::cxx::tree::traits< Characterization_type, char > Characterization_traits;
594
595 const Characterization_optional&
596 Characterization () const;
597
598 Characterization_optional&
599 Characterization ();
600
601 void
602 Characterization (const Characterization_type& x);
603
604 void
605 Characterization (const Characterization_optional& x);
606
607 void
608 Characterization (::std::auto_ptr< Characterization_type > p);
609
610 // PropertyData
611 //
612 typedef ::PropertyData PropertyData_type;
613 typedef ::xsd::cxx::tree::sequence< PropertyData_type > PropertyData_sequence;
614 typedef PropertyData_sequence::iterator PropertyData_iterator;
615 typedef PropertyData_sequence::const_iterator PropertyData_const_iterator;
616 typedef ::xsd::cxx::tree::traits< PropertyData_type, char > PropertyData_traits;
617
618 const PropertyData_sequence&
619 PropertyData () const;
620
621 PropertyData_sequence&
622 PropertyData ();
623
624 void
625 PropertyData (const PropertyData_sequence& s);
626
627 // Notes
628 //
629 typedef ::Notes Notes_type;
630 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
631 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
632
633 const Notes_optional&
634 Notes () const;
635
636 Notes_optional&
637 Notes ();
638
639 void
640 Notes (const Notes_type& x);
641
642 void
643 Notes (const Notes_optional& x);
644
645 void
646 Notes (::std::auto_ptr< Notes_type > p);
647
648 // Constructors.
649 //
650 BulkDetails (const Name_type&);
651
652 BulkDetails (::std::auto_ptr< Name_type >);
653
654 BulkDetails (const ::xercesc::DOMElement& e,
655 ::xml_schema::flags f = 0,
656 ::xml_schema::container* c = 0);
657
658 BulkDetails (const BulkDetails& x,
659 ::xml_schema::flags f = 0,
660 ::xml_schema::container* c = 0);
661
662 virtual BulkDetails*
663 _clone (::xml_schema::flags f = 0,
664 ::xml_schema::container* c = 0) const;
665
666 BulkDetails&
667 operator= (const BulkDetails& x);
668
669 virtual
670 ~BulkDetails ();
671
672 // Implementation.
673 //
674 protected:
675 void
676 parse (::xsd::cxx::xml::dom::parser< char >&,
677 ::xml_schema::flags);
678
679 protected:
680 ::xsd::cxx::tree::one< Name_type > Name_;
681 Class_sequence Class_;
682 Subclass_sequence Subclass_;
683 Specification_sequence Specification_;
684 Source_optional Source_;
685 Form_optional Form_;
686 ProcessingDetails_sequence ProcessingDetails_;
687 Characterization_optional Characterization_;
688 PropertyData_sequence PropertyData_;
689 Notes_optional Notes_;
690};
691
692class Characterization: public ::xml_schema::type
693{
694 public:
695 // Formula
696 //
697 typedef ::Formula Formula_type;
698 typedef ::xsd::cxx::tree::traits< Formula_type, char > Formula_traits;
699
700 const Formula_type&
701 Formula () const;
702
703 Formula_type&
704 Formula ();
705
706 void
707 Formula (const Formula_type& x);
708
709 void
710 Formula (::std::auto_ptr< Formula_type > p);
711
712 // ChemicalComposition
713 //
714 typedef ::ChemicalComposition ChemicalComposition_type;
715 typedef ::xsd::cxx::tree::optional< ChemicalComposition_type > ChemicalComposition_optional;
716 typedef ::xsd::cxx::tree::traits< ChemicalComposition_type, char > ChemicalComposition_traits;
717
718 const ChemicalComposition_optional&
719 ChemicalComposition () const;
720
721 ChemicalComposition_optional&
722 ChemicalComposition ();
723
724 void
725 ChemicalComposition (const ChemicalComposition_type& x);
726
727 void
728 ChemicalComposition (const ChemicalComposition_optional& x);
729
730 void
731 ChemicalComposition (::std::auto_ptr< ChemicalComposition_type > p);
732
733 // PhaseComposition
734 //
735 typedef ::PhaseComposition PhaseComposition_type;
736 typedef ::xsd::cxx::tree::sequence< PhaseComposition_type > PhaseComposition_sequence;
737 typedef PhaseComposition_sequence::iterator PhaseComposition_iterator;
738 typedef PhaseComposition_sequence::const_iterator PhaseComposition_const_iterator;
739 typedef ::xsd::cxx::tree::traits< PhaseComposition_type, char > PhaseComposition_traits;
740
741 const PhaseComposition_sequence&
742 PhaseComposition () const;
743
744 PhaseComposition_sequence&
745 PhaseComposition ();
746
747 void
748 PhaseComposition (const PhaseComposition_sequence& s);
749
750 // DimensionalDetails
751 //
752 typedef ::DimensionalDetails DimensionalDetails_type;
753 typedef ::xsd::cxx::tree::sequence< DimensionalDetails_type > DimensionalDetails_sequence;
754 typedef DimensionalDetails_sequence::iterator DimensionalDetails_iterator;
755 typedef DimensionalDetails_sequence::const_iterator DimensionalDetails_const_iterator;
756 typedef ::xsd::cxx::tree::traits< DimensionalDetails_type, char > DimensionalDetails_traits;
757
758 const DimensionalDetails_sequence&
759 DimensionalDetails () const;
760
761 DimensionalDetails_sequence&
762 DimensionalDetails ();
763
764 void
765 DimensionalDetails (const DimensionalDetails_sequence& s);
766
767 // Notes
768 //
769 typedef ::Notes Notes_type;
770 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
771 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
772
773 const Notes_optional&
774 Notes () const;
775
776 Notes_optional&
777 Notes ();
778
779 void
780 Notes (const Notes_type& x);
781
782 void
783 Notes (const Notes_optional& x);
784
785 void
786 Notes (::std::auto_ptr< Notes_type > p);
787
788 // Constructors.
789 //
790 Characterization (const Formula_type&);
791
792 Characterization (const ::xercesc::DOMElement& e,
793 ::xml_schema::flags f = 0,
794 ::xml_schema::container* c = 0);
795
796 Characterization (const Characterization& x,
797 ::xml_schema::flags f = 0,
798 ::xml_schema::container* c = 0);
799
800 virtual Characterization*
801 _clone (::xml_schema::flags f = 0,
802 ::xml_schema::container* c = 0) const;
803
804 Characterization&
805 operator= (const Characterization& x);
806
807 virtual
808 ~Characterization ();
809
810 // Implementation.
811 //
812 protected:
813 void
814 parse (::xsd::cxx::xml::dom::parser< char >&,
815 ::xml_schema::flags);
816
817 protected:
818 ::xsd::cxx::tree::one< Formula_type > Formula_;
819 ChemicalComposition_optional ChemicalComposition_;
820 PhaseComposition_sequence PhaseComposition_;
821 DimensionalDetails_sequence DimensionalDetails_;
822 Notes_optional Notes_;
823};
824
825class ChemicalComposition: public ::xml_schema::type
826{
827 public:
828 // Compound
829 //
830 typedef ::Compound Compound_type;
831 typedef ::xsd::cxx::tree::sequence< Compound_type > Compound_sequence;
832 typedef Compound_sequence::iterator Compound_iterator;
833 typedef Compound_sequence::const_iterator Compound_const_iterator;
834 typedef ::xsd::cxx::tree::traits< Compound_type, char > Compound_traits;
835
836 const Compound_sequence&
837 Compound () const;
838
839 Compound_sequence&
840 Compound ();
841
842 void
843 Compound (const Compound_sequence& s);
844
845 // Element
846 //
847 typedef ::Element Element_type;
848 typedef ::xsd::cxx::tree::sequence< Element_type > Element_sequence;
849 typedef Element_sequence::iterator Element_iterator;
850 typedef Element_sequence::const_iterator Element_const_iterator;
851 typedef ::xsd::cxx::tree::traits< Element_type, char > Element_traits;
852
853 const Element_sequence&
854 Element () const;
855
856 Element_sequence&
857 Element ();
858
859 void
860 Element (const Element_sequence& s);
861
862 // Constructors.
863 //
864 ChemicalComposition ();
865
866 ChemicalComposition (const ::xercesc::DOMElement& e,
867 ::xml_schema::flags f = 0,
868 ::xml_schema::container* c = 0);
869
870 ChemicalComposition (const ChemicalComposition& x,
871 ::xml_schema::flags f = 0,
872 ::xml_schema::container* c = 0);
873
874 virtual ChemicalComposition*
875 _clone (::xml_schema::flags f = 0,
876 ::xml_schema::container* c = 0) const;
877
878 ChemicalComposition&
879 operator= (const ChemicalComposition& x);
880
881 virtual
882 ~ChemicalComposition ();
883
884 // Implementation.
885 //
886 protected:
887 void
888 parse (::xsd::cxx::xml::dom::parser< char >&,
889 ::xml_schema::flags);
890
891 protected:
892 Compound_sequence Compound_;
893 Element_sequence Element_;
894};
895
896class Class: public ::xml_schema::type
897{
898 public:
899 // Name
900 //
901 typedef ::Name Name_type;
902 typedef ::xsd::cxx::tree::optional< Name_type > Name_optional;
903 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
904
905 const Name_optional&
906 Name () const;
907
908 Name_optional&
909 Name ();
910
911 void
912 Name (const Name_type& x);
913
914 void
915 Name (const Name_optional& x);
916
917 void
918 Name (::std::auto_ptr< Name_type > p);
919
920 // ParentMaterial
921 //
922 typedef ::ParentMaterial ParentMaterial_type;
923 typedef ::xsd::cxx::tree::sequence< ParentMaterial_type > ParentMaterial_sequence;
924 typedef ParentMaterial_sequence::iterator ParentMaterial_iterator;
925 typedef ParentMaterial_sequence::const_iterator ParentMaterial_const_iterator;
926 typedef ::xsd::cxx::tree::traits< ParentMaterial_type, char > ParentMaterial_traits;
927
928 const ParentMaterial_sequence&
929 ParentMaterial () const;
930
931 ParentMaterial_sequence&
932 ParentMaterial ();
933
934 void
935 ParentMaterial (const ParentMaterial_sequence& s);
936
937 // ParentSubClass
938 //
939 typedef ::Class ParentSubClass_type;
940 typedef ::xsd::cxx::tree::sequence< ParentSubClass_type > ParentSubClass_sequence;
941 typedef ParentSubClass_sequence::iterator ParentSubClass_iterator;
942 typedef ParentSubClass_sequence::const_iterator ParentSubClass_const_iterator;
943 typedef ::xsd::cxx::tree::traits< ParentSubClass_type, char > ParentSubClass_traits;
944
945 const ParentSubClass_sequence&
946 ParentSubClass () const;
947
948 ParentSubClass_sequence&
949 ParentSubClass ();
950
951 void
952 ParentSubClass (const ParentSubClass_sequence& s);
953
954 // Constructors.
955 //
956 Class ();
957
958 Class (const ::xercesc::DOMElement& e,
959 ::xml_schema::flags f = 0,
960 ::xml_schema::container* c = 0);
961
962 Class (const Class& x,
963 ::xml_schema::flags f = 0,
964 ::xml_schema::container* c = 0);
965
966 virtual Class*
967 _clone (::xml_schema::flags f = 0,
968 ::xml_schema::container* c = 0) const;
969
970 Class&
971 operator= (const Class& x);
972
973 virtual
974 ~Class ();
975
976 // Implementation.
977 //
978 protected:
979 void
980 parse (::xsd::cxx::xml::dom::parser< char >&,
981 ::xml_schema::flags);
982
983 protected:
984 Name_optional Name_;
985 ParentMaterial_sequence ParentMaterial_;
986 ParentSubClass_sequence ParentSubClass_;
987};
988
989class ComponentDetails: public ::xml_schema::type
990{
991 public:
992 // Name
993 //
994 typedef ::Name Name_type;
995 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
996
997 const Name_type&
998 Name () const;
999
1000 Name_type&
1001 Name ();
1002
1003 void
1004 Name (const Name_type& x);
1005
1006 void
1007 Name (::std::auto_ptr< Name_type > p);
1008
1009 // Class
1010 //
1011 typedef ::Class Class_type;
1012 typedef ::xsd::cxx::tree::sequence< Class_type > Class_sequence;
1013 typedef Class_sequence::iterator Class_iterator;
1014 typedef Class_sequence::const_iterator Class_const_iterator;
1015 typedef ::xsd::cxx::tree::traits< Class_type, char > Class_traits;
1016
1017 const Class_sequence&
1018 Class () const;
1019
1020 Class_sequence&
1021 Class ();
1022
1023 void
1024 Class (const Class_sequence& s);
1025
1026 // Subclass
1027 //
1028 typedef ::Class Subclass_type;
1029 typedef ::xsd::cxx::tree::sequence< Subclass_type > Subclass_sequence;
1030 typedef Subclass_sequence::iterator Subclass_iterator;
1031 typedef Subclass_sequence::const_iterator Subclass_const_iterator;
1032 typedef ::xsd::cxx::tree::traits< Subclass_type, char > Subclass_traits;
1033
1034 const Subclass_sequence&
1035 Subclass () const;
1036
1037 Subclass_sequence&
1038 Subclass ();
1039
1040 void
1041 Subclass (const Subclass_sequence& s);
1042
1043 // Specification
1044 //
1045 typedef ::Specification Specification_type;
1046 typedef ::xsd::cxx::tree::sequence< Specification_type > Specification_sequence;
1047 typedef Specification_sequence::iterator Specification_iterator;
1048 typedef Specification_sequence::const_iterator Specification_const_iterator;
1049 typedef ::xsd::cxx::tree::traits< Specification_type, char > Specification_traits;
1050
1051 const Specification_sequence&
1052 Specification () const;
1053
1054 Specification_sequence&
1055 Specification ();
1056
1057 void
1058 Specification (const Specification_sequence& s);
1059
1060 // Source
1061 //
1062 typedef ::Source Source_type;
1063 typedef ::xsd::cxx::tree::optional< Source_type > Source_optional;
1064 typedef ::xsd::cxx::tree::traits< Source_type, char > Source_traits;
1065
1066 const Source_optional&
1067 Source () const;
1068
1069 Source_optional&
1070 Source ();
1071
1072 void
1073 Source (const Source_type& x);
1074
1075 void
1076 Source (const Source_optional& x);
1077
1078 void
1079 Source (::std::auto_ptr< Source_type > p);
1080
1081 // Form
1082 //
1083 typedef ::Form Form_type;
1084 typedef ::xsd::cxx::tree::optional< Form_type > Form_optional;
1085 typedef ::xsd::cxx::tree::traits< Form_type, char > Form_traits;
1086
1087 const Form_optional&
1088 Form () const;
1089
1090 Form_optional&
1091 Form ();
1092
1093 void
1094 Form (const Form_type& x);
1095
1096 void
1097 Form (const Form_optional& x);
1098
1099 void
1100 Form (::std::auto_ptr< Form_type > p);
1101
1102 // ProcessingDetails
1103 //
1104 typedef ::ProcessingDetails ProcessingDetails_type;
1105 typedef ::xsd::cxx::tree::sequence< ProcessingDetails_type > ProcessingDetails_sequence;
1106 typedef ProcessingDetails_sequence::iterator ProcessingDetails_iterator;
1107 typedef ProcessingDetails_sequence::const_iterator ProcessingDetails_const_iterator;
1108 typedef ::xsd::cxx::tree::traits< ProcessingDetails_type, char > ProcessingDetails_traits;
1109
1110 const ProcessingDetails_sequence&
1111 ProcessingDetails () const;
1112
1113 ProcessingDetails_sequence&
1114 ProcessingDetails ();
1115
1116 void
1117 ProcessingDetails (const ProcessingDetails_sequence& s);
1118
1119 // Characterization
1120 //
1121 typedef ::Characterization Characterization_type;
1122 typedef ::xsd::cxx::tree::optional< Characterization_type > Characterization_optional;
1123 typedef ::xsd::cxx::tree::traits< Characterization_type, char > Characterization_traits;
1124
1125 const Characterization_optional&
1126 Characterization () const;
1127
1128 Characterization_optional&
1129 Characterization ();
1130
1131 void
1132 Characterization (const Characterization_type& x);
1133
1134 void
1135 Characterization (const Characterization_optional& x);
1136
1137 void
1138 Characterization (::std::auto_ptr< Characterization_type > p);
1139
1140 // PropertyData
1141 //
1142 typedef ::PropertyData PropertyData_type;
1143 typedef ::xsd::cxx::tree::sequence< PropertyData_type > PropertyData_sequence;
1144 typedef PropertyData_sequence::iterator PropertyData_iterator;
1145 typedef PropertyData_sequence::const_iterator PropertyData_const_iterator;
1146 typedef ::xsd::cxx::tree::traits< PropertyData_type, char > PropertyData_traits;
1147
1148 const PropertyData_sequence&
1149 PropertyData () const;
1150
1151 PropertyData_sequence&
1152 PropertyData ();
1153
1154 void
1155 PropertyData (const PropertyData_sequence& s);
1156
1157 // AssociationDetails
1158 //
1159 typedef ::AssociationDetails AssociationDetails_type;
1160 typedef ::xsd::cxx::tree::sequence< AssociationDetails_type > AssociationDetails_sequence;
1161 typedef AssociationDetails_sequence::iterator AssociationDetails_iterator;
1162 typedef AssociationDetails_sequence::const_iterator AssociationDetails_const_iterator;
1163 typedef ::xsd::cxx::tree::traits< AssociationDetails_type, char > AssociationDetails_traits;
1164
1165 const AssociationDetails_sequence&
1166 AssociationDetails () const;
1167
1168 AssociationDetails_sequence&
1169 AssociationDetails ();
1170
1171 void
1172 AssociationDetails (const AssociationDetails_sequence& s);
1173
1174 // ComponentDetails
1175 //
1176 typedef ::ComponentDetails ComponentDetails1_type;
1177 typedef ::xsd::cxx::tree::sequence< ComponentDetails1_type > ComponentDetails1_sequence;
1178 typedef ComponentDetails1_sequence::iterator ComponentDetails1_iterator;
1179 typedef ComponentDetails1_sequence::const_iterator ComponentDetails1_const_iterator;
1180 typedef ::xsd::cxx::tree::traits< ComponentDetails1_type, char > ComponentDetails1_traits;
1181
1182 const ComponentDetails1_sequence&
1183 ComponentDetails1 () const;
1184
1185 ComponentDetails1_sequence&
1186 ComponentDetails1 ();
1187
1188 void
1189 ComponentDetails1 (const ComponentDetails1_sequence& s);
1190
1191 // id
1192 //
1193 typedef ::xml_schema::id id_type;
1194 typedef ::xsd::cxx::tree::optional< id_type > id_optional;
1195 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
1196
1197 const id_optional&
1198 id () const;
1199
1200 id_optional&
1201 id ();
1202
1203 void
1204 id (const id_type& x);
1205
1206 void
1207 id (const id_optional& x);
1208
1209 void
1210 id (::std::auto_ptr< id_type > p);
1211
1212 // Constructors.
1213 //
1214 ComponentDetails (const Name_type&);
1215
1216 ComponentDetails (::std::auto_ptr< Name_type >);
1217
1218 ComponentDetails (const ::xercesc::DOMElement& e,
1219 ::xml_schema::flags f = 0,
1220 ::xml_schema::container* c = 0);
1221
1222 ComponentDetails (const ComponentDetails& x,
1223 ::xml_schema::flags f = 0,
1224 ::xml_schema::container* c = 0);
1225
1226 virtual ComponentDetails*
1227 _clone (::xml_schema::flags f = 0,
1228 ::xml_schema::container* c = 0) const;
1229
1230 ComponentDetails&
1231 operator= (const ComponentDetails& x);
1232
1233 virtual
1234 ~ComponentDetails ();
1235
1236 // Implementation.
1237 //
1238 protected:
1239 void
1240 parse (::xsd::cxx::xml::dom::parser< char >&,
1241 ::xml_schema::flags);
1242
1243 protected:
1244 ::xsd::cxx::tree::one< Name_type > Name_;
1245 Class_sequence Class_;
1246 Subclass_sequence Subclass_;
1247 Specification_sequence Specification_;
1248 Source_optional Source_;
1249 Form_optional Form_;
1250 ProcessingDetails_sequence ProcessingDetails_;
1251 Characterization_optional Characterization_;
1252 PropertyData_sequence PropertyData_;
1253 AssociationDetails_sequence AssociationDetails_;
1254 ComponentDetails1_sequence ComponentDetails1_;
1255 id_optional id_;
1256};
1257
1258class Compound: public ::xml_schema::type
1259{
1260 public:
1261 // Element
1262 //
1263 typedef ::Element Element_type;
1264 typedef ::xsd::cxx::tree::sequence< Element_type > Element_sequence;
1265 typedef Element_sequence::iterator Element_iterator;
1266 typedef Element_sequence::const_iterator Element_const_iterator;
1267 typedef ::xsd::cxx::tree::traits< Element_type, char > Element_traits;
1268
1269 const Element_sequence&
1270 Element () const;
1271
1272 Element_sequence&
1273 Element ();
1274
1275 void
1276 Element (const Element_sequence& s);
1277
1278 // Concentration
1279 //
1280 typedef ::Concentration Concentration_type;
1281 typedef ::xsd::cxx::tree::optional< Concentration_type > Concentration_optional;
1282 typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;
1283
1284 const Concentration_optional&
1285 Concentration () const;
1286
1287 Concentration_optional&
1288 Concentration ();
1289
1290 void
1291 Concentration (const Concentration_type& x);
1292
1293 void
1294 Concentration (const Concentration_optional& x);
1295
1296 void
1297 Concentration (::std::auto_ptr< Concentration_type > p);
1298
1299 // Notes
1300 //
1301 typedef ::Notes Notes_type;
1302 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
1303 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
1304
1305 const Notes_optional&
1306 Notes () const;
1307
1308 Notes_optional&
1309 Notes ();
1310
1311 void
1312 Notes (const Notes_type& x);
1313
1314 void
1315 Notes (const Notes_optional& x);
1316
1317 void
1318 Notes (::std::auto_ptr< Notes_type > p);
1319
1320 // Constructors.
1321 //
1322 Compound ();
1323
1324 Compound (const ::xercesc::DOMElement& e,
1325 ::xml_schema::flags f = 0,
1326 ::xml_schema::container* c = 0);
1327
1328 Compound (const Compound& x,
1329 ::xml_schema::flags f = 0,
1330 ::xml_schema::container* c = 0);
1331
1332 virtual Compound*
1333 _clone (::xml_schema::flags f = 0,
1334 ::xml_schema::container* c = 0) const;
1335
1336 Compound&
1337 operator= (const Compound& x);
1338
1339 virtual
1340 ~Compound ();
1341
1342 // Implementation.
1343 //
1344 protected:
1345 void
1346 parse (::xsd::cxx::xml::dom::parser< char >&,
1347 ::xml_schema::flags);
1348
1349 protected:
1350 Element_sequence Element_;
1351 Concentration_optional Concentration_;
1352 Notes_optional Notes_;
1353};
1354
1355class Concentration: public ::xml_schema::type
1356{
1357 public:
1358 // Value
1359 //
1360 typedef ::Value Value_type;
1361 typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;
1362
1363 const Value_type&
1364 Value () const;
1365
1366 Value_type&
1367 Value ();
1368
1369 void
1370 Value (const Value_type& x);
1371
1372 void
1373 Value (::std::auto_ptr< Value_type > p);
1374
1375 // Units
1376 //
1377 typedef ::Units Units_type;
1378 typedef ::xsd::cxx::tree::traits< Units_type, char > Units_traits;
1379
1380 const Units_type&
1381 Units () const;
1382
1383 Units_type&
1384 Units ();
1385
1386 void
1387 Units (const Units_type& x);
1388
1389 void
1390 Units (::std::auto_ptr< Units_type > p);
1391
1392 // Qualifier
1393 //
1394 typedef ::Qualifier Qualifier_type;
1395 typedef ::xsd::cxx::tree::sequence< Qualifier_type > Qualifier_sequence;
1396 typedef Qualifier_sequence::iterator Qualifier_iterator;
1397 typedef Qualifier_sequence::const_iterator Qualifier_const_iterator;
1398 typedef ::xsd::cxx::tree::traits< Qualifier_type, char > Qualifier_traits;
1399
1400 const Qualifier_sequence&
1401 Qualifier () const;
1402
1403 Qualifier_sequence&
1404 Qualifier ();
1405
1406 void
1407 Qualifier (const Qualifier_sequence& s);
1408
1409 // Uncertainty
1410 //
1411 typedef ::Uncertainty Uncertainty_type;
1412 typedef ::xsd::cxx::tree::sequence< Uncertainty_type > Uncertainty_sequence;
1413 typedef Uncertainty_sequence::iterator Uncertainty_iterator;
1414 typedef Uncertainty_sequence::const_iterator Uncertainty_const_iterator;
1415 typedef ::xsd::cxx::tree::traits< Uncertainty_type, char > Uncertainty_traits;
1416
1417 const Uncertainty_sequence&
1418 Uncertainty () const;
1419
1420 Uncertainty_sequence&
1421 Uncertainty ();
1422
1423 void
1424 Uncertainty (const Uncertainty_sequence& s);
1425
1426 // Notes
1427 //
1428 typedef ::Notes Notes_type;
1429 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
1430 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
1431
1432 const Notes_optional&
1433 Notes () const;
1434
1435 Notes_optional&
1436 Notes ();
1437
1438 void
1439 Notes (const Notes_type& x);
1440
1441 void
1442 Notes (const Notes_optional& x);
1443
1444 void
1445 Notes (::std::auto_ptr< Notes_type > p);
1446
1447 // Constructors.
1448 //
1449 Concentration (const Value_type&,
1450 const Units_type&);
1451
1452 Concentration (::std::auto_ptr< Value_type >,
1453 ::std::auto_ptr< Units_type >);
1454
1455 Concentration (const ::xercesc::DOMElement& e,
1456 ::xml_schema::flags f = 0,
1457 ::xml_schema::container* c = 0);
1458
1459 Concentration (const Concentration& x,
1460 ::xml_schema::flags f = 0,
1461 ::xml_schema::container* c = 0);
1462
1463 virtual Concentration*
1464 _clone (::xml_schema::flags f = 0,
1465 ::xml_schema::container* c = 0) const;
1466
1467 Concentration&
1468 operator= (const Concentration& x);
1469
1470 virtual
1471 ~Concentration ();
1472
1473 // Implementation.
1474 //
1475 protected:
1476 void
1477 parse (::xsd::cxx::xml::dom::parser< char >&,
1478 ::xml_schema::flags);
1479
1480 protected:
1481 ::xsd::cxx::tree::one< Value_type > Value_;
1482 ::xsd::cxx::tree::one< Units_type > Units_;
1483 Qualifier_sequence Qualifier_;
1484 Uncertainty_sequence Uncertainty_;
1485 Notes_optional Notes_;
1486};
1487
1488class DataFormat: public ::xml_schema::string
1489{
1490 public:
1491 enum value
1492 {
1493 float_,
1494 integer,
1495 string,
1496 exponential,
1497 mixed
1498 };
1499
1500 DataFormat (value v);
1501
1502 DataFormat (const char* v);
1503
1504 DataFormat (const ::std::string& v);
1505
1506 DataFormat (const ::xml_schema::string& v);
1507
1508 DataFormat (const ::xercesc::DOMElement& e,
1509 ::xml_schema::flags f = 0,
1510 ::xml_schema::container* c = 0);
1511
1512 DataFormat (const ::xercesc::DOMAttr& a,
1513 ::xml_schema::flags f = 0,
1514 ::xml_schema::container* c = 0);
1515
1516 DataFormat (const ::std::string& s,
1517 const ::xercesc::DOMElement* e,
1518 ::xml_schema::flags f = 0,
1519 ::xml_schema::container* c = 0);
1520
1521 DataFormat (const DataFormat& x,
1522 ::xml_schema::flags f = 0,
1523 ::xml_schema::container* c = 0);
1524
1525 virtual DataFormat*
1526 _clone (::xml_schema::flags f = 0,
1527 ::xml_schema::container* c = 0) const;
1528
1529 DataFormat&
1530 operator= (value v);
1531
1532 virtual
1533 operator value () const
1534 {
1535 return _xsd_DataFormat_convert ();
1536 }
1537
1538 protected:
1539 value
1540 _xsd_DataFormat_convert () const;
1541
1542 public:
1543 static const char* const _xsd_DataFormat_literals_[5];
1544 static const value _xsd_DataFormat_indexes_[5];
1545};
1546
1547class DimensionalDetails: public ::xml_schema::type
1548{
1549 public:
1550 // Name
1551 //
1552 typedef ::Name Name_type;
1553 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
1554
1555 const Name_type&
1556 Name () const;
1557
1558 Name_type&
1559 Name ();
1560
1561 void
1562 Name (const Name_type& x);
1563
1564 void
1565 Name (::std::auto_ptr< Name_type > p);
1566
1567 // Value
1568 //
1569 typedef ::Value Value_type;
1570 typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;
1571
1572 const Value_type&
1573 Value () const;
1574
1575 Value_type&
1576 Value ();
1577
1578 void
1579 Value (const Value_type& x);
1580
1581 void
1582 Value (::std::auto_ptr< Value_type > p);
1583
1584 // Units
1585 //
1586 typedef ::Units Units_type;
1587 typedef ::xsd::cxx::tree::traits< Units_type, char > Units_traits;
1588
1589 const Units_type&
1590 Units () const;
1591
1592 Units_type&
1593 Units ();
1594
1595 void
1596 Units (const Units_type& x);
1597
1598 void
1599 Units (::std::auto_ptr< Units_type > p);
1600
1601 // Qualifier
1602 //
1603 typedef ::Qualifier Qualifier_type;
1604 typedef ::xsd::cxx::tree::optional< Qualifier_type > Qualifier_optional;
1605 typedef ::xsd::cxx::tree::traits< Qualifier_type, char > Qualifier_traits;
1606
1607 const Qualifier_optional&
1608 Qualifier () const;
1609
1610 Qualifier_optional&
1611 Qualifier ();
1612
1613 void
1614 Qualifier (const Qualifier_type& x);
1615
1616 void
1617 Qualifier (const Qualifier_optional& x);
1618
1619 void
1620 Qualifier (::std::auto_ptr< Qualifier_type > p);
1621
1622 // Uncertainty
1623 //
1624 typedef ::Uncertainty Uncertainty_type;
1625 typedef ::xsd::cxx::tree::sequence< Uncertainty_type > Uncertainty_sequence;
1626 typedef Uncertainty_sequence::iterator Uncertainty_iterator;
1627 typedef Uncertainty_sequence::const_iterator Uncertainty_const_iterator;
1628 typedef ::xsd::cxx::tree::traits< Uncertainty_type, char > Uncertainty_traits;
1629
1630 const Uncertainty_sequence&
1631 Uncertainty () const;
1632
1633 Uncertainty_sequence&
1634 Uncertainty ();
1635
1636 void
1637 Uncertainty (const Uncertainty_sequence& s);
1638
1639 // Notes
1640 //
1641 typedef ::Notes Notes_type;
1642 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
1643 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
1644
1645 const Notes_optional&
1646 Notes () const;
1647
1648 Notes_optional&
1649 Notes ();
1650
1651 void
1652 Notes (const Notes_type& x);
1653
1654 void
1655 Notes (const Notes_optional& x);
1656
1657 void
1658 Notes (::std::auto_ptr< Notes_type > p);
1659
1660 // Constructors.
1661 //
1662 DimensionalDetails (const Name_type&,
1663 const Value_type&,
1664 const Units_type&);
1665
1666 DimensionalDetails (::std::auto_ptr< Name_type >,
1667 ::std::auto_ptr< Value_type >,
1668 ::std::auto_ptr< Units_type >);
1669
1670 DimensionalDetails (const ::xercesc::DOMElement& e,
1671 ::xml_schema::flags f = 0,
1672 ::xml_schema::container* c = 0);
1673
1674 DimensionalDetails (const DimensionalDetails& x,
1675 ::xml_schema::flags f = 0,
1676 ::xml_schema::container* c = 0);
1677
1678 virtual DimensionalDetails*
1679 _clone (::xml_schema::flags f = 0,
1680 ::xml_schema::container* c = 0) const;
1681
1682 DimensionalDetails&
1683 operator= (const DimensionalDetails& x);
1684
1685 virtual
1686 ~DimensionalDetails ();
1687
1688 // Implementation.
1689 //
1690 protected:
1691 void
1692 parse (::xsd::cxx::xml::dom::parser< char >&,
1693 ::xml_schema::flags);
1694
1695 protected:
1696 ::xsd::cxx::tree::one< Name_type > Name_;
1697 ::xsd::cxx::tree::one< Value_type > Value_;
1698 ::xsd::cxx::tree::one< Units_type > Units_;
1699 Qualifier_optional Qualifier_;
1700 Uncertainty_sequence Uncertainty_;
1701 Notes_optional Notes_;
1702};
1703
1704class Element: public ::xml_schema::type
1705{
1706 public:
1707 // Symbol
1708 //
1709 typedef ::Symbol Symbol_type;
1710 typedef ::xsd::cxx::tree::traits< Symbol_type, char > Symbol_traits;
1711
1712 const Symbol_type&
1713 Symbol () const;
1714
1715 Symbol_type&
1716 Symbol ();
1717
1718 void
1719 Symbol (const Symbol_type& x);
1720
1721 void
1722 Symbol (::std::auto_ptr< Symbol_type > p);
1723
1724 // Concentration
1725 //
1726 typedef ::Concentration Concentration_type;
1727 typedef ::xsd::cxx::tree::optional< Concentration_type > Concentration_optional;
1728 typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;
1729
1730 const Concentration_optional&
1731 Concentration () const;
1732
1733 Concentration_optional&
1734 Concentration ();
1735
1736 void
1737 Concentration (const Concentration_type& x);
1738
1739 void
1740 Concentration (const Concentration_optional& x);
1741
1742 void
1743 Concentration (::std::auto_ptr< Concentration_type > p);
1744
1745 // Notes
1746 //
1747 typedef ::Notes Notes_type;
1748 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
1749 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
1750
1751 const Notes_optional&
1752 Notes () const;
1753
1754 Notes_optional&
1755 Notes ();
1756
1757 void
1758 Notes (const Notes_type& x);
1759
1760 void
1761 Notes (const Notes_optional& x);
1762
1763 void
1764 Notes (::std::auto_ptr< Notes_type > p);
1765
1766 // Constructors.
1767 //
1768 Element (const Symbol_type&);
1769
1770 Element (::std::auto_ptr< Symbol_type >);
1771
1772 Element (const ::xercesc::DOMElement& e,
1773 ::xml_schema::flags f = 0,
1774 ::xml_schema::container* c = 0);
1775
1776 Element (const Element& x,
1777 ::xml_schema::flags f = 0,
1778 ::xml_schema::container* c = 0);
1779
1780 virtual Element*
1781 _clone (::xml_schema::flags f = 0,
1782 ::xml_schema::container* c = 0) const;
1783
1784 Element&
1785 operator= (const Element& x);
1786
1787 virtual
1788 ~Element ();
1789
1790 // Implementation.
1791 //
1792 protected:
1793 void
1794 parse (::xsd::cxx::xml::dom::parser< char >&,
1795 ::xml_schema::flags);
1796
1797 protected:
1798 ::xsd::cxx::tree::one< Symbol_type > Symbol_;
1799 Concentration_optional Concentration_;
1800 Notes_optional Notes_;
1801};
1802
1803class Form: public ::xml_schema::type
1804{
1805 public:
1806 // Description
1807 //
1808 typedef ::Name Description_type;
1809 typedef ::xsd::cxx::tree::traits< Description_type, char > Description_traits;
1810
1811 const Description_type&
1812 Description () const;
1813
1814 Description_type&
1815 Description ();
1816
1817 void
1818 Description (const Description_type& x);
1819
1820 void
1821 Description (::std::auto_ptr< Description_type > p);
1822
1823 // Geometry
1824 //
1825 typedef ::Geometry Geometry_type;
1826 typedef ::xsd::cxx::tree::optional< Geometry_type > Geometry_optional;
1827 typedef ::xsd::cxx::tree::traits< Geometry_type, char > Geometry_traits;
1828
1829 const Geometry_optional&
1830 Geometry () const;
1831
1832 Geometry_optional&
1833 Geometry ();
1834
1835 void
1836 Geometry (const Geometry_type& x);
1837
1838 void
1839 Geometry (const Geometry_optional& x);
1840
1841 void
1842 Geometry (::std::auto_ptr< Geometry_type > p);
1843
1844 // Notes
1845 //
1846 typedef ::Notes Notes_type;
1847 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
1848 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
1849
1850 const Notes_optional&
1851 Notes () const;
1852
1853 Notes_optional&
1854 Notes ();
1855
1856 void
1857 Notes (const Notes_type& x);
1858
1859 void
1860 Notes (const Notes_optional& x);
1861
1862 void
1863 Notes (::std::auto_ptr< Notes_type > p);
1864
1865 // Constructors.
1866 //
1867 Form (const Description_type&);
1868
1869 Form (::std::auto_ptr< Description_type >);
1870
1871 Form (const ::xercesc::DOMElement& e,
1872 ::xml_schema::flags f = 0,
1873 ::xml_schema::container* c = 0);
1874
1875 Form (const Form& x,
1876 ::xml_schema::flags f = 0,
1877 ::xml_schema::container* c = 0);
1878
1879 virtual Form*
1880 _clone (::xml_schema::flags f = 0,
1881 ::xml_schema::container* c = 0) const;
1882
1883 Form&
1884 operator= (const Form& x);
1885
1886 virtual
1887 ~Form ();
1888
1889 // Implementation.
1890 //
1891 protected:
1892 void
1893 parse (::xsd::cxx::xml::dom::parser< char >&,
1894 ::xml_schema::flags);
1895
1896 protected:
1897 ::xsd::cxx::tree::one< Description_type > Description_;
1898 Geometry_optional Geometry_;
1899 Notes_optional Notes_;
1900};
1901
1902class Formula: public ::xml_schema::string
1903{
1904 public:
1905 // Constructors.
1906 //
1907 Formula ();
1908
1909 Formula (const char*);
1910
1911 Formula (const ::std::string&);
1912
1913 Formula (const ::xml_schema::string&);
1914
1915 Formula (const ::xercesc::DOMElement& e,
1916 ::xml_schema::flags f = 0,
1917 ::xml_schema::container* c = 0);
1918
1919 Formula (const ::xercesc::DOMAttr& a,
1920 ::xml_schema::flags f = 0,
1921 ::xml_schema::container* c = 0);
1922
1923 Formula (const ::std::string& s,
1924 const ::xercesc::DOMElement* e,
1925 ::xml_schema::flags f = 0,
1926 ::xml_schema::container* c = 0);
1927
1928 Formula (const Formula& x,
1929 ::xml_schema::flags f = 0,
1930 ::xml_schema::container* c = 0);
1931
1932 virtual Formula*
1933 _clone (::xml_schema::flags f = 0,
1934 ::xml_schema::container* c = 0) const;
1935
1936 virtual
1937 ~Formula ();
1938};
1939
1940class Geometry: public ::xml_schema::type
1941{
1942 public:
1943 // Shape
1944 //
1945 typedef ::xml_schema::string Shape_type;
1946 typedef ::xsd::cxx::tree::traits< Shape_type, char > Shape_traits;
1947
1948 const Shape_type&
1949 Shape () const;
1950
1951 Shape_type&
1952 Shape ();
1953
1954 void
1955 Shape (const Shape_type& x);
1956
1957 void
1958 Shape (::std::auto_ptr< Shape_type > p);
1959
1960 // Dimensions
1961 //
1962 typedef ::xml_schema::string Dimensions_type;
1963 typedef ::xsd::cxx::tree::optional< Dimensions_type > Dimensions_optional;
1964 typedef ::xsd::cxx::tree::traits< Dimensions_type, char > Dimensions_traits;
1965
1966 const Dimensions_optional&
1967 Dimensions () const;
1968
1969 Dimensions_optional&
1970 Dimensions ();
1971
1972 void
1973 Dimensions (const Dimensions_type& x);
1974
1975 void
1976 Dimensions (const Dimensions_optional& x);
1977
1978 void
1979 Dimensions (::std::auto_ptr< Dimensions_type > p);
1980
1981 // Orientation
1982 //
1983 typedef ::xml_schema::string Orientation_type;
1984 typedef ::xsd::cxx::tree::optional< Orientation_type > Orientation_optional;
1985 typedef ::xsd::cxx::tree::traits< Orientation_type, char > Orientation_traits;
1986
1987 const Orientation_optional&
1988 Orientation () const;
1989
1990 Orientation_optional&
1991 Orientation ();
1992
1993 void
1994 Orientation (const Orientation_type& x);
1995
1996 void
1997 Orientation (const Orientation_optional& x);
1998
1999 void
2000 Orientation (::std::auto_ptr< Orientation_type > p);
2001
2002 // Notes
2003 //
2004 typedef ::Notes Notes_type;
2005 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
2006 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
2007
2008 const Notes_optional&
2009 Notes () const;
2010
2011 Notes_optional&
2012 Notes ();
2013
2014 void
2015 Notes (const Notes_type& x);
2016
2017 void
2018 Notes (const Notes_optional& x);
2019
2020 void
2021 Notes (::std::auto_ptr< Notes_type > p);
2022
2023 // Constructors.
2024 //
2025 Geometry (const Shape_type&);
2026
2027 Geometry (const ::xercesc::DOMElement& e,
2028 ::xml_schema::flags f = 0,
2029 ::xml_schema::container* c = 0);
2030
2031 Geometry (const Geometry& x,
2032 ::xml_schema::flags f = 0,
2033 ::xml_schema::container* c = 0);
2034
2035 virtual Geometry*
2036 _clone (::xml_schema::flags f = 0,
2037 ::xml_schema::container* c = 0) const;
2038
2039 Geometry&
2040 operator= (const Geometry& x);
2041
2042 virtual
2043 ~Geometry ();
2044
2045 // Implementation.
2046 //
2047 protected:
2048 void
2049 parse (::xsd::cxx::xml::dom::parser< char >&,
2050 ::xml_schema::flags);
2051
2052 protected:
2053 ::xsd::cxx::tree::one< Shape_type > Shape_;
2054 Dimensions_optional Dimensions_;
2055 Orientation_optional Orientation_;
2056 Notes_optional Notes_;
2057};
2058
2059class Glossary: public ::xml_schema::type
2060{
2061 public:
2062 // Term
2063 //
2064 typedef ::GlossaryTerm Term_type;
2065 typedef ::xsd::cxx::tree::sequence< Term_type > Term_sequence;
2066 typedef Term_sequence::iterator Term_iterator;
2067 typedef Term_sequence::const_iterator Term_const_iterator;
2068 typedef ::xsd::cxx::tree::traits< Term_type, char > Term_traits;
2069
2070 const Term_sequence&
2071 Term () const;
2072
2073 Term_sequence&
2074 Term ();
2075
2076 void
2077 Term (const Term_sequence& s);
2078
2079 // Constructors.
2080 //
2081 Glossary ();
2082
2083 Glossary (const ::xercesc::DOMElement& e,
2084 ::xml_schema::flags f = 0,
2085 ::xml_schema::container* c = 0);
2086
2087 Glossary (const Glossary& x,
2088 ::xml_schema::flags f = 0,
2089 ::xml_schema::container* c = 0);
2090
2091 virtual Glossary*
2092 _clone (::xml_schema::flags f = 0,
2093 ::xml_schema::container* c = 0) const;
2094
2095 Glossary&
2096 operator= (const Glossary& x);
2097
2098 virtual
2099 ~Glossary ();
2100
2101 // Implementation.
2102 //
2103 protected:
2104 void
2105 parse (::xsd::cxx::xml::dom::parser< char >&,
2106 ::xml_schema::flags);
2107
2108 protected:
2109 Term_sequence Term_;
2110};
2111
2112class GlossaryTerm: public ::xml_schema::type
2113{
2114 public:
2115 // Name
2116 //
2117 typedef ::Name Name_type;
2118 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
2119
2120 const Name_type&
2121 Name () const;
2122
2123 Name_type&
2124 Name ();
2125
2126 void
2127 Name (const Name_type& x);
2128
2129 void
2130 Name (::std::auto_ptr< Name_type > p);
2131
2132 // Definition
2133 //
2134 typedef ::xml_schema::string Definition_type;
2135 typedef ::xsd::cxx::tree::traits< Definition_type, char > Definition_traits;
2136
2137 const Definition_type&
2138 Definition () const;
2139
2140 Definition_type&
2141 Definition ();
2142
2143 void
2144 Definition (const Definition_type& x);
2145
2146 void
2147 Definition (::std::auto_ptr< Definition_type > p);
2148
2149 // Abbreviation
2150 //
2151 typedef ::xml_schema::string Abbreviation_type;
2152 typedef ::xsd::cxx::tree::sequence< Abbreviation_type > Abbreviation_sequence;
2153 typedef Abbreviation_sequence::iterator Abbreviation_iterator;
2154 typedef Abbreviation_sequence::const_iterator Abbreviation_const_iterator;
2155 typedef ::xsd::cxx::tree::traits< Abbreviation_type, char > Abbreviation_traits;
2156
2157 const Abbreviation_sequence&
2158 Abbreviation () const;
2159
2160 Abbreviation_sequence&
2161 Abbreviation ();
2162
2163 void
2164 Abbreviation (const Abbreviation_sequence& s);
2165
2166 // Synonym
2167 //
2168 typedef ::xml_schema::string Synonym_type;
2169 typedef ::xsd::cxx::tree::sequence< Synonym_type > Synonym_sequence;
2170 typedef Synonym_sequence::iterator Synonym_iterator;
2171 typedef Synonym_sequence::const_iterator Synonym_const_iterator;
2172 typedef ::xsd::cxx::tree::traits< Synonym_type, char > Synonym_traits;
2173
2174 const Synonym_sequence&
2175 Synonym () const;
2176
2177 Synonym_sequence&
2178 Synonym ();
2179
2180 void
2181 Synonym (const Synonym_sequence& s);
2182
2183 // Notes
2184 //
2185 typedef ::Notes Notes_type;
2186 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
2187 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
2188
2189 const Notes_optional&
2190 Notes () const;
2191
2192 Notes_optional&
2193 Notes ();
2194
2195 void
2196 Notes (const Notes_type& x);
2197
2198 void
2199 Notes (const Notes_optional& x);
2200
2201 void
2202 Notes (::std::auto_ptr< Notes_type > p);
2203
2204 // Constructors.
2205 //
2206 GlossaryTerm (const Name_type&,
2207 const Definition_type&);
2208
2209 GlossaryTerm (::std::auto_ptr< Name_type >,
2210 const Definition_type&);
2211
2212 GlossaryTerm (const ::xercesc::DOMElement& e,
2213 ::xml_schema::flags f = 0,
2214 ::xml_schema::container* c = 0);
2215
2216 GlossaryTerm (const GlossaryTerm& x,
2217 ::xml_schema::flags f = 0,
2218 ::xml_schema::container* c = 0);
2219
2220 virtual GlossaryTerm*
2221 _clone (::xml_schema::flags f = 0,
2222 ::xml_schema::container* c = 0) const;
2223
2224 GlossaryTerm&
2225 operator= (const GlossaryTerm& x);
2226
2227 virtual
2228 ~GlossaryTerm ();
2229
2230 // Implementation.
2231 //
2232 protected:
2233 void
2234 parse (::xsd::cxx::xml::dom::parser< char >&,
2235 ::xml_schema::flags);
2236
2237 protected:
2238 ::xsd::cxx::tree::one< Name_type > Name_;
2239 ::xsd::cxx::tree::one< Definition_type > Definition_;
2240 Abbreviation_sequence Abbreviation_;
2241 Synonym_sequence Synonym_;
2242 Notes_optional Notes_;
2243};
2244
2245class Graphs: public ::xml_schema::type
2246{
2247 public:
2248 // Graph
2249 //
2250 typedef ::Graph Graph_type;
2251 typedef ::xsd::cxx::tree::sequence< Graph_type > Graph_sequence;
2252 typedef Graph_sequence::iterator Graph_iterator;
2253 typedef Graph_sequence::const_iterator Graph_const_iterator;
2254 typedef ::xsd::cxx::tree::traits< Graph_type, char > Graph_traits;
2255
2256 const Graph_sequence&
2257 Graph () const;
2258
2259 Graph_sequence&
2260 Graph ();
2261
2262 void
2263 Graph (const Graph_sequence& s);
2264
2265 // Constructors.
2266 //
2267 Graphs ();
2268
2269 Graphs (const ::xercesc::DOMElement& e,
2270 ::xml_schema::flags f = 0,
2271 ::xml_schema::container* c = 0);
2272
2273 Graphs (const Graphs& x,
2274 ::xml_schema::flags f = 0,
2275 ::xml_schema::container* c = 0);
2276
2277 virtual Graphs*
2278 _clone (::xml_schema::flags f = 0,
2279 ::xml_schema::container* c = 0) const;
2280
2281 Graphs&
2282 operator= (const Graphs& x);
2283
2284 virtual
2285 ~Graphs ();
2286
2287 // Implementation.
2288 //
2289 protected:
2290 void
2291 parse (::xsd::cxx::xml::dom::parser< char >&,
2292 ::xml_schema::flags);
2293
2294 protected:
2295 Graph_sequence Graph_;
2296};
2297
2298class Material: public ::xml_schema::type
2299{
2300 public:
2301 // BulkDetails
2302 //
2303 typedef ::BulkDetails BulkDetails_type;
2304 typedef ::xsd::cxx::tree::traits< BulkDetails_type, char > BulkDetails_traits;
2305
2306 const BulkDetails_type&
2307 BulkDetails () const;
2308
2309 BulkDetails_type&
2310 BulkDetails ();
2311
2312 void
2313 BulkDetails (const BulkDetails_type& x);
2314
2315 void
2316 BulkDetails (::std::auto_ptr< BulkDetails_type > p);
2317
2318 // ComponentDetails
2319 //
2320 typedef ::ComponentDetails ComponentDetails_type;
2321 typedef ::xsd::cxx::tree::sequence< ComponentDetails_type > ComponentDetails_sequence;
2322 typedef ComponentDetails_sequence::iterator ComponentDetails_iterator;
2323 typedef ComponentDetails_sequence::const_iterator ComponentDetails_const_iterator;
2324 typedef ::xsd::cxx::tree::traits< ComponentDetails_type, char > ComponentDetails_traits;
2325
2326 const ComponentDetails_sequence&
2327 ComponentDetails () const;
2328
2329 ComponentDetails_sequence&
2330 ComponentDetails ();
2331
2332 void
2333 ComponentDetails (const ComponentDetails_sequence& s);
2334
2335 // Graphs
2336 //
2337 typedef ::Graphs Graphs_type;
2338 typedef ::xsd::cxx::tree::optional< Graphs_type > Graphs_optional;
2339 typedef ::xsd::cxx::tree::traits< Graphs_type, char > Graphs_traits;
2340
2341 const Graphs_optional&
2342 Graphs () const;
2343
2344 Graphs_optional&
2345 Graphs ();
2346
2347 void
2348 Graphs (const Graphs_type& x);
2349
2350 void
2351 Graphs (const Graphs_optional& x);
2352
2353 void
2354 Graphs (::std::auto_ptr< Graphs_type > p);
2355
2356 // Glossary
2357 //
2358 typedef ::Glossary Glossary_type;
2359 typedef ::xsd::cxx::tree::optional< Glossary_type > Glossary_optional;
2360 typedef ::xsd::cxx::tree::traits< Glossary_type, char > Glossary_traits;
2361
2362 const Glossary_optional&
2363 Glossary () const;
2364
2365 Glossary_optional&
2366 Glossary ();
2367
2368 void
2369 Glossary (const Glossary_type& x);
2370
2371 void
2372 Glossary (const Glossary_optional& x);
2373
2374 void
2375 Glossary (::std::auto_ptr< Glossary_type > p);
2376
2377 // id
2378 //
2379 typedef ::xml_schema::id id_type;
2380 typedef ::xsd::cxx::tree::optional< id_type > id_optional;
2381 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
2382
2383 const id_optional&
2384 id () const;
2385
2386 id_optional&
2387 id ();
2388
2389 void
2390 id (const id_type& x);
2391
2392 void
2393 id (const id_optional& x);
2394
2395 void
2396 id (::std::auto_ptr< id_type > p);
2397
2398 // layers
2399 //
2400 typedef ::xml_schema::integer layers_type;
2401 typedef ::xsd::cxx::tree::optional< layers_type > layers_optional;
2402 typedef ::xsd::cxx::tree::traits< layers_type, char > layers_traits;
2403
2404 const layers_optional&
2405 layers () const;
2406
2407 layers_optional&
2408 layers ();
2409
2410 void
2411 layers (const layers_type& x);
2412
2413 void
2414 layers (const layers_optional& x);
2415
2416 // local_frame_of_reference
2417 //
2418 typedef ::xml_schema::string local_frame_of_reference_type;
2419 typedef ::xsd::cxx::tree::optional< local_frame_of_reference_type > local_frame_of_reference_optional;
2420 typedef ::xsd::cxx::tree::traits< local_frame_of_reference_type, char > local_frame_of_reference_traits;
2421
2422 const local_frame_of_reference_optional&
2423 local_frame_of_reference () const;
2424
2425 local_frame_of_reference_optional&
2426 local_frame_of_reference ();
2427
2428 void
2429 local_frame_of_reference (const local_frame_of_reference_type& x);
2430
2431 void
2432 local_frame_of_reference (const local_frame_of_reference_optional& x);
2433
2434 void
2435 local_frame_of_reference (::std::auto_ptr< local_frame_of_reference_type > p);
2436
2437 // Constructors.
2438 //
2439 Material (const BulkDetails_type&);
2440
2441 Material (::std::auto_ptr< BulkDetails_type >);
2442
2443 Material (const ::xercesc::DOMElement& e,
2444 ::xml_schema::flags f = 0,
2445 ::xml_schema::container* c = 0);
2446
2447 Material (const Material& x,
2448 ::xml_schema::flags f = 0,
2449 ::xml_schema::container* c = 0);
2450
2451 virtual Material*
2452 _clone (::xml_schema::flags f = 0,
2453 ::xml_schema::container* c = 0) const;
2454
2455 Material&
2456 operator= (const Material& x);
2457
2458 virtual
2459 ~Material ();
2460
2461 // Implementation.
2462 //
2463 protected:
2464 void
2465 parse (::xsd::cxx::xml::dom::parser< char >&,
2466 ::xml_schema::flags);
2467
2468 protected:
2469 ::xsd::cxx::tree::one< BulkDetails_type > BulkDetails_;
2470 ComponentDetails_sequence ComponentDetails_;
2471 Graphs_optional Graphs_;
2472 Glossary_optional Glossary_;
2473 id_optional id_;
2474 layers_optional layers_;
2475 local_frame_of_reference_optional local_frame_of_reference_;
2476};
2477
2478class Metadata: public ::xml_schema::type
2479{
2480 public:
2481 // AuthorityDetails
2482 //
2483 typedef ::AuthorityDetails AuthorityDetails_type;
2484 typedef ::xsd::cxx::tree::sequence< AuthorityDetails_type > AuthorityDetails_sequence;
2485 typedef AuthorityDetails_sequence::iterator AuthorityDetails_iterator;
2486 typedef AuthorityDetails_sequence::const_iterator AuthorityDetails_const_iterator;
2487 typedef ::xsd::cxx::tree::traits< AuthorityDetails_type, char > AuthorityDetails_traits;
2488
2489 const AuthorityDetails_sequence&
2490 AuthorityDetails () const;
2491
2492 AuthorityDetails_sequence&
2493 AuthorityDetails ();
2494
2495 void
2496 AuthorityDetails (const AuthorityDetails_sequence& s);
2497
2498 // DataSourceDetails
2499 //
2500 typedef ::DataSourceDetails DataSourceDetails_type;
2501 typedef ::xsd::cxx::tree::sequence< DataSourceDetails_type > DataSourceDetails_sequence;
2502 typedef DataSourceDetails_sequence::iterator DataSourceDetails_iterator;
2503 typedef DataSourceDetails_sequence::const_iterator DataSourceDetails_const_iterator;
2504 typedef ::xsd::cxx::tree::traits< DataSourceDetails_type, char > DataSourceDetails_traits;
2505
2506 const DataSourceDetails_sequence&
2507 DataSourceDetails () const;
2508
2509 DataSourceDetails_sequence&
2510 DataSourceDetails ();
2511
2512 void
2513 DataSourceDetails (const DataSourceDetails_sequence& s);
2514
2515 // MeasurementTechniqueDetails
2516 //
2517 typedef ::MeasurementTechniqueDetails MeasurementTechniqueDetails_type;
2518 typedef ::xsd::cxx::tree::sequence< MeasurementTechniqueDetails_type > MeasurementTechniqueDetails_sequence;
2519 typedef MeasurementTechniqueDetails_sequence::iterator MeasurementTechniqueDetails_iterator;
2520 typedef MeasurementTechniqueDetails_sequence::const_iterator MeasurementTechniqueDetails_const_iterator;
2521 typedef ::xsd::cxx::tree::traits< MeasurementTechniqueDetails_type, char > MeasurementTechniqueDetails_traits;
2522
2523 const MeasurementTechniqueDetails_sequence&
2524 MeasurementTechniqueDetails () const;
2525
2526 MeasurementTechniqueDetails_sequence&
2527 MeasurementTechniqueDetails ();
2528
2529 void
2530 MeasurementTechniqueDetails (const MeasurementTechniqueDetails_sequence& s);
2531
2532 // ParameterDetails
2533 //
2534 typedef ::ParameterDetails ParameterDetails_type;
2535 typedef ::xsd::cxx::tree::sequence< ParameterDetails_type > ParameterDetails_sequence;
2536 typedef ParameterDetails_sequence::iterator ParameterDetails_iterator;
2537 typedef ParameterDetails_sequence::const_iterator ParameterDetails_const_iterator;
2538 typedef ::xsd::cxx::tree::traits< ParameterDetails_type, char > ParameterDetails_traits;
2539
2540 const ParameterDetails_sequence&
2541 ParameterDetails () const;
2542
2543 ParameterDetails_sequence&
2544 ParameterDetails ();
2545
2546 void
2547 ParameterDetails (const ParameterDetails_sequence& s);
2548
2549 // PropertyDetails
2550 //
2551 typedef ::PropertyDetails PropertyDetails_type;
2552 typedef ::xsd::cxx::tree::sequence< PropertyDetails_type > PropertyDetails_sequence;
2553 typedef PropertyDetails_sequence::iterator PropertyDetails_iterator;
2554 typedef PropertyDetails_sequence::const_iterator PropertyDetails_const_iterator;
2555 typedef ::xsd::cxx::tree::traits< PropertyDetails_type, char > PropertyDetails_traits;
2556
2557 const PropertyDetails_sequence&
2558 PropertyDetails () const;
2559
2560 PropertyDetails_sequence&
2561 PropertyDetails ();
2562
2563 void
2564 PropertyDetails (const PropertyDetails_sequence& s);
2565
2566 // SourceDetails
2567 //
2568 typedef ::SourceDetails SourceDetails_type;
2569 typedef ::xsd::cxx::tree::sequence< SourceDetails_type > SourceDetails_sequence;
2570 typedef SourceDetails_sequence::iterator SourceDetails_iterator;
2571 typedef SourceDetails_sequence::const_iterator SourceDetails_const_iterator;
2572 typedef ::xsd::cxx::tree::traits< SourceDetails_type, char > SourceDetails_traits;
2573
2574 const SourceDetails_sequence&
2575 SourceDetails () const;
2576
2577 SourceDetails_sequence&
2578 SourceDetails ();
2579
2580 void
2581 SourceDetails (const SourceDetails_sequence& s);
2582
2583 // SpecimenDetails
2584 //
2585 typedef ::SpecimenDetails SpecimenDetails_type;
2586 typedef ::xsd::cxx::tree::sequence< SpecimenDetails_type > SpecimenDetails_sequence;
2587 typedef SpecimenDetails_sequence::iterator SpecimenDetails_iterator;
2588 typedef SpecimenDetails_sequence::const_iterator SpecimenDetails_const_iterator;
2589 typedef ::xsd::cxx::tree::traits< SpecimenDetails_type, char > SpecimenDetails_traits;
2590
2591 const SpecimenDetails_sequence&
2592 SpecimenDetails () const;
2593
2594 SpecimenDetails_sequence&
2595 SpecimenDetails ();
2596
2597 void
2598 SpecimenDetails (const SpecimenDetails_sequence& s);
2599
2600 // TestConditionDetails
2601 //
2602 typedef ::TestConditionDetails TestConditionDetails_type;
2603 typedef ::xsd::cxx::tree::sequence< TestConditionDetails_type > TestConditionDetails_sequence;
2604 typedef TestConditionDetails_sequence::iterator TestConditionDetails_iterator;
2605 typedef TestConditionDetails_sequence::const_iterator TestConditionDetails_const_iterator;
2606 typedef ::xsd::cxx::tree::traits< TestConditionDetails_type, char > TestConditionDetails_traits;
2607
2608 const TestConditionDetails_sequence&
2609 TestConditionDetails () const;
2610
2611 TestConditionDetails_sequence&
2612 TestConditionDetails ();
2613
2614 void
2615 TestConditionDetails (const TestConditionDetails_sequence& s);
2616
2617 // Constructors.
2618 //
2619 Metadata ();
2620
2621 Metadata (const ::xercesc::DOMElement& e,
2622 ::xml_schema::flags f = 0,
2623 ::xml_schema::container* c = 0);
2624
2625 Metadata (const Metadata& x,
2626 ::xml_schema::flags f = 0,
2627 ::xml_schema::container* c = 0);
2628
2629 virtual Metadata*
2630 _clone (::xml_schema::flags f = 0,
2631 ::xml_schema::container* c = 0) const;
2632
2633 Metadata&
2634 operator= (const Metadata& x);
2635
2636 virtual
2637 ~Metadata ();
2638
2639 // Implementation.
2640 //
2641 protected:
2642 void
2643 parse (::xsd::cxx::xml::dom::parser< char >&,
2644 ::xml_schema::flags);
2645
2646 protected:
2647 AuthorityDetails_sequence AuthorityDetails_;
2648 DataSourceDetails_sequence DataSourceDetails_;
2649 MeasurementTechniqueDetails_sequence MeasurementTechniqueDetails_;
2650 ParameterDetails_sequence ParameterDetails_;
2651 PropertyDetails_sequence PropertyDetails_;
2652 SourceDetails_sequence SourceDetails_;
2653 SpecimenDetails_sequence SpecimenDetails_;
2654 TestConditionDetails_sequence TestConditionDetails_;
2655};
2656
2657class Name: public ::xml_schema::string
2658{
2659 public:
2660 // authority
2661 //
2662 typedef ::xml_schema::idref authority_type;
2663 typedef ::xsd::cxx::tree::optional< authority_type > authority_optional;
2664 typedef ::xsd::cxx::tree::traits< authority_type, char > authority_traits;
2665
2666 const authority_optional&
2667 authority () const;
2668
2669 authority_optional&
2670 authority ();
2671
2672 void
2673 authority (const authority_type& x);
2674
2675 void
2676 authority (const authority_optional& x);
2677
2678 void
2679 authority (::std::auto_ptr< authority_type > p);
2680
2681 // Constructors.
2682 //
2683 Name ();
2684
2685 Name (const char*);
2686
2687 Name (const ::std::string&);
2688
2689 Name (const ::xml_schema::string&);
2690
2691 Name (const ::xercesc::DOMElement& e,
2692 ::xml_schema::flags f = 0,
2693 ::xml_schema::container* c = 0);
2694
2695 Name (const Name& x,
2696 ::xml_schema::flags f = 0,
2697 ::xml_schema::container* c = 0);
2698
2699 virtual Name*
2700 _clone (::xml_schema::flags f = 0,
2701 ::xml_schema::container* c = 0) const;
2702
2703 Name&
2704 operator= (const Name& x);
2705
2706 virtual
2707 ~Name ();
2708
2709 // Implementation.
2710 //
2711 protected:
2712 void
2713 parse (::xsd::cxx::xml::dom::parser< char >&,
2714 ::xml_schema::flags);
2715
2716 protected:
2717 authority_optional authority_;
2718};
2719
2720class Notes: public ::xml_schema::string
2721{
2722 public:
2723 // Constructors.
2724 //
2725 Notes ();
2726
2727 Notes (const char*);
2728
2729 Notes (const ::std::string&);
2730
2731 Notes (const ::xml_schema::string&);
2732
2733 Notes (const ::xercesc::DOMElement& e,
2734 ::xml_schema::flags f = 0,
2735 ::xml_schema::container* c = 0);
2736
2737 Notes (const ::xercesc::DOMAttr& a,
2738 ::xml_schema::flags f = 0,
2739 ::xml_schema::container* c = 0);
2740
2741 Notes (const ::std::string& s,
2742 const ::xercesc::DOMElement* e,
2743 ::xml_schema::flags f = 0,
2744 ::xml_schema::container* c = 0);
2745
2746 Notes (const Notes& x,
2747 ::xml_schema::flags f = 0,
2748 ::xml_schema::container* c = 0);
2749
2750 virtual Notes*
2751 _clone (::xml_schema::flags f = 0,
2752 ::xml_schema::container* c = 0) const;
2753
2754 virtual
2755 ~Notes ();
2756};
2757
2758class ParameterValue: public ::xml_schema::type
2759{
2760 public:
2761 // Data
2762 //
2763 typedef ::Data Data_type;
2764 typedef ::xsd::cxx::tree::traits< Data_type, char > Data_traits;
2765
2766 const Data_type&
2767 Data () const;
2768
2769 Data_type&
2770 Data ();
2771
2772 void
2773 Data (const Data_type& x);
2774
2775 void
2776 Data (::std::auto_ptr< Data_type > p);
2777
2778 // Uncertainty
2779 //
2780 typedef ::Uncertainty Uncertainty_type;
2781 typedef ::xsd::cxx::tree::sequence< Uncertainty_type > Uncertainty_sequence;
2782 typedef Uncertainty_sequence::iterator Uncertainty_iterator;
2783 typedef Uncertainty_sequence::const_iterator Uncertainty_const_iterator;
2784 typedef ::xsd::cxx::tree::traits< Uncertainty_type, char > Uncertainty_traits;
2785
2786 const Uncertainty_sequence&
2787 Uncertainty () const;
2788
2789 Uncertainty_sequence&
2790 Uncertainty ();
2791
2792 void
2793 Uncertainty (const Uncertainty_sequence& s);
2794
2795 // Qualifier
2796 //
2797 typedef ::Qualifier Qualifier_type;
2798 typedef ::xsd::cxx::tree::sequence< Qualifier_type > Qualifier_sequence;
2799 typedef Qualifier_sequence::iterator Qualifier_iterator;
2800 typedef Qualifier_sequence::const_iterator Qualifier_const_iterator;
2801 typedef ::xsd::cxx::tree::traits< Qualifier_type, char > Qualifier_traits;
2802
2803 const Qualifier_sequence&
2804 Qualifier () const;
2805
2806 Qualifier_sequence&
2807 Qualifier ();
2808
2809 void
2810 Qualifier (const Qualifier_sequence& s);
2811
2812 // Notes
2813 //
2814 typedef ::Notes Notes_type;
2815 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
2816 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
2817
2818 const Notes_optional&
2819 Notes () const;
2820
2821 Notes_optional&
2822 Notes ();
2823
2824 void
2825 Notes (const Notes_type& x);
2826
2827 void
2828 Notes (const Notes_optional& x);
2829
2830 void
2831 Notes (::std::auto_ptr< Notes_type > p);
2832
2833 // parameter
2834 //
2835 typedef ::xml_schema::idref parameter_type;
2836 typedef ::xsd::cxx::tree::traits< parameter_type, char > parameter_traits;
2837
2838 const parameter_type&
2839 parameter () const;
2840
2841 parameter_type&
2842 parameter ();
2843
2844 void
2845 parameter (const parameter_type& x);
2846
2847 void
2848 parameter (::std::auto_ptr< parameter_type > p);
2849
2850 // format
2851 //
2852 typedef ::DataFormat format_type;
2853 typedef ::xsd::cxx::tree::traits< format_type, char > format_traits;
2854
2855 const format_type&
2856 format () const;
2857
2858 format_type&
2859 format ();
2860
2861 void
2862 format (const format_type& x);
2863
2864 void
2865 format (::std::auto_ptr< format_type > p);
2866
2867 // Constructors.
2868 //
2869 ParameterValue (const Data_type&,
2870 const parameter_type&,
2871 const format_type&);
2872
2873 ParameterValue (::std::auto_ptr< Data_type >,
2874 const parameter_type&,
2875 const format_type&);
2876
2877 ParameterValue (const ::xercesc::DOMElement& e,
2878 ::xml_schema::flags f = 0,
2879 ::xml_schema::container* c = 0);
2880
2881 ParameterValue (const ParameterValue& x,
2882 ::xml_schema::flags f = 0,
2883 ::xml_schema::container* c = 0);
2884
2885 virtual ParameterValue*
2886 _clone (::xml_schema::flags f = 0,
2887 ::xml_schema::container* c = 0) const;
2888
2889 ParameterValue&
2890 operator= (const ParameterValue& x);
2891
2892 virtual
2893 ~ParameterValue ();
2894
2895 // Implementation.
2896 //
2897 protected:
2898 void
2899 parse (::xsd::cxx::xml::dom::parser< char >&,
2900 ::xml_schema::flags);
2901
2902 protected:
2903 ::xsd::cxx::tree::one< Data_type > Data_;
2904 Uncertainty_sequence Uncertainty_;
2905 Qualifier_sequence Qualifier_;
2906 Notes_optional Notes_;
2907 ::xsd::cxx::tree::one< parameter_type > parameter_;
2908 ::xsd::cxx::tree::one< format_type > format_;
2909};
2910
2911class PhaseComposition: public ::xml_schema::type
2912{
2913 public:
2914 // Name
2915 //
2916 typedef ::Name Name_type;
2917 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
2918
2919 const Name_type&
2920 Name () const;
2921
2922 Name_type&
2923 Name ();
2924
2925 void
2926 Name (const Name_type& x);
2927
2928 void
2929 Name (::std::auto_ptr< Name_type > p);
2930
2931 // Concentration
2932 //
2933 typedef ::Concentration Concentration_type;
2934 typedef ::xsd::cxx::tree::optional< Concentration_type > Concentration_optional;
2935 typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;
2936
2937 const Concentration_optional&
2938 Concentration () const;
2939
2940 Concentration_optional&
2941 Concentration ();
2942
2943 void
2944 Concentration (const Concentration_type& x);
2945
2946 void
2947 Concentration (const Concentration_optional& x);
2948
2949 void
2950 Concentration (::std::auto_ptr< Concentration_type > p);
2951
2952 // PropertyData
2953 //
2954 typedef ::PropertyData PropertyData_type;
2955 typedef ::xsd::cxx::tree::sequence< PropertyData_type > PropertyData_sequence;
2956 typedef PropertyData_sequence::iterator PropertyData_iterator;
2957 typedef PropertyData_sequence::const_iterator PropertyData_const_iterator;
2958 typedef ::xsd::cxx::tree::traits< PropertyData_type, char > PropertyData_traits;
2959
2960 const PropertyData_sequence&
2961 PropertyData () const;
2962
2963 PropertyData_sequence&
2964 PropertyData ();
2965
2966 void
2967 PropertyData (const PropertyData_sequence& s);
2968
2969 // Notes
2970 //
2971 typedef ::Notes Notes_type;
2972 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
2973 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
2974
2975 const Notes_optional&
2976 Notes () const;
2977
2978 Notes_optional&
2979 Notes ();
2980
2981 void
2982 Notes (const Notes_type& x);
2983
2984 void
2985 Notes (const Notes_optional& x);
2986
2987 void
2988 Notes (::std::auto_ptr< Notes_type > p);
2989
2990 // Constructors.
2991 //
2992 PhaseComposition (const Name_type&);
2993
2994 PhaseComposition (::std::auto_ptr< Name_type >);
2995
2996 PhaseComposition (const ::xercesc::DOMElement& e,
2997 ::xml_schema::flags f = 0,
2998 ::xml_schema::container* c = 0);
2999
3000 PhaseComposition (const PhaseComposition& x,
3001 ::xml_schema::flags f = 0,
3002 ::xml_schema::container* c = 0);
3003
3004 virtual PhaseComposition*
3005 _clone (::xml_schema::flags f = 0,
3006 ::xml_schema::container* c = 0) const;
3007
3008 PhaseComposition&
3009 operator= (const PhaseComposition& x);
3010
3011 virtual
3012 ~PhaseComposition ();
3013
3014 // Implementation.
3015 //
3016 protected:
3017 void
3018 parse (::xsd::cxx::xml::dom::parser< char >&,
3019 ::xml_schema::flags);
3020
3021 protected:
3022 ::xsd::cxx::tree::one< Name_type > Name_;
3023 Concentration_optional Concentration_;
3024 PropertyData_sequence PropertyData_;
3025 Notes_optional Notes_;
3026};
3027
3028class ProcessingDetails: public ::xml_schema::type
3029{
3030 public:
3031 // Name
3032 //
3033 typedef ::Name Name_type;
3034 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
3035
3036 const Name_type&
3037 Name () const;
3038
3039 Name_type&
3040 Name ();
3041
3042 void
3043 Name (const Name_type& x);
3044
3045 void
3046 Name (::std::auto_ptr< Name_type > p);
3047
3048 // ParameterValue
3049 //
3050 typedef ::ParameterValue ParameterValue_type;
3051 typedef ::xsd::cxx::tree::sequence< ParameterValue_type > ParameterValue_sequence;
3052 typedef ParameterValue_sequence::iterator ParameterValue_iterator;
3053 typedef ParameterValue_sequence::const_iterator ParameterValue_const_iterator;
3054 typedef ::xsd::cxx::tree::traits< ParameterValue_type, char > ParameterValue_traits;
3055
3056 const ParameterValue_sequence&
3057 ParameterValue () const;
3058
3059 ParameterValue_sequence&
3060 ParameterValue ();
3061
3062 void
3063 ParameterValue (const ParameterValue_sequence& s);
3064
3065 // Result
3066 //
3067 typedef ::xml_schema::string Result_type;
3068 typedef ::xsd::cxx::tree::optional< Result_type > Result_optional;
3069 typedef ::xsd::cxx::tree::traits< Result_type, char > Result_traits;
3070
3071 const Result_optional&
3072 Result () const;
3073
3074 Result_optional&
3075 Result ();
3076
3077 void
3078 Result (const Result_type& x);
3079
3080 void
3081 Result (const Result_optional& x);
3082
3083 void
3084 Result (::std::auto_ptr< Result_type > p);
3085
3086 // Notes
3087 //
3088 typedef ::Notes Notes_type;
3089 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
3090 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
3091
3092 const Notes_optional&
3093 Notes () const;
3094
3095 Notes_optional&
3096 Notes ();
3097
3098 void
3099 Notes (const Notes_type& x);
3100
3101 void
3102 Notes (const Notes_optional& x);
3103
3104 void
3105 Notes (::std::auto_ptr< Notes_type > p);
3106
3107 // Constructors.
3108 //
3109 ProcessingDetails (const Name_type&);
3110
3111 ProcessingDetails (::std::auto_ptr< Name_type >);
3112
3113 ProcessingDetails (const ::xercesc::DOMElement& e,
3114 ::xml_schema::flags f = 0,
3115 ::xml_schema::container* c = 0);
3116
3117 ProcessingDetails (const ProcessingDetails& x,
3118 ::xml_schema::flags f = 0,
3119 ::xml_schema::container* c = 0);
3120
3121 virtual ProcessingDetails*
3122 _clone (::xml_schema::flags f = 0,
3123 ::xml_schema::container* c = 0) const;
3124
3125 ProcessingDetails&
3126 operator= (const ProcessingDetails& x);
3127
3128 virtual
3129 ~ProcessingDetails ();
3130
3131 // Implementation.
3132 //
3133 protected:
3134 void
3135 parse (::xsd::cxx::xml::dom::parser< char >&,
3136 ::xml_schema::flags);
3137
3138 protected:
3139 ::xsd::cxx::tree::one< Name_type > Name_;
3140 ParameterValue_sequence ParameterValue_;
3141 Result_optional Result_;
3142 Notes_optional Notes_;
3143};
3144
3145class PropertyData: public ::xml_schema::type
3146{
3147 public:
3148 // Data
3149 //
3150 typedef ::Data1 Data_type;
3151 typedef ::xsd::cxx::tree::traits< Data_type, char > Data_traits;
3152
3153 const Data_type&
3154 Data () const;
3155
3156 Data_type&
3157 Data ();
3158
3159 void
3160 Data (const Data_type& x);
3161
3162 void
3163 Data (::std::auto_ptr< Data_type > p);
3164
3165 // Uncertainty
3166 //
3167 typedef ::Uncertainty Uncertainty_type;
3168 typedef ::xsd::cxx::tree::sequence< Uncertainty_type > Uncertainty_sequence;
3169 typedef Uncertainty_sequence::iterator Uncertainty_iterator;
3170 typedef Uncertainty_sequence::const_iterator Uncertainty_const_iterator;
3171 typedef ::xsd::cxx::tree::traits< Uncertainty_type, char > Uncertainty_traits;
3172
3173 const Uncertainty_sequence&
3174 Uncertainty () const;
3175
3176 Uncertainty_sequence&
3177 Uncertainty ();
3178
3179 void
3180 Uncertainty (const Uncertainty_sequence& s);
3181
3182 // Qualifier
3183 //
3184 typedef ::Qualifier Qualifier_type;
3185 typedef ::xsd::cxx::tree::sequence< Qualifier_type > Qualifier_sequence;
3186 typedef Qualifier_sequence::iterator Qualifier_iterator;
3187 typedef Qualifier_sequence::const_iterator Qualifier_const_iterator;
3188 typedef ::xsd::cxx::tree::traits< Qualifier_type, char > Qualifier_traits;
3189
3190 const Qualifier_sequence&
3191 Qualifier () const;
3192
3193 Qualifier_sequence&
3194 Qualifier ();
3195
3196 void
3197 Qualifier (const Qualifier_sequence& s);
3198
3199 // ParameterValue
3200 //
3201 typedef ::ParameterValue ParameterValue_type;
3202 typedef ::xsd::cxx::tree::sequence< ParameterValue_type > ParameterValue_sequence;
3203 typedef ParameterValue_sequence::iterator ParameterValue_iterator;
3204 typedef ParameterValue_sequence::const_iterator ParameterValue_const_iterator;
3205 typedef ::xsd::cxx::tree::traits< ParameterValue_type, char > ParameterValue_traits;
3206
3207 const ParameterValue_sequence&
3208 ParameterValue () const;
3209
3210 ParameterValue_sequence&
3211 ParameterValue ();
3212
3213 void
3214 ParameterValue (const ParameterValue_sequence& s);
3215
3216 // Notes
3217 //
3218 typedef ::Notes Notes_type;
3219 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
3220 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
3221
3222 const Notes_optional&
3223 Notes () const;
3224
3225 Notes_optional&
3226 Notes ();
3227
3228 void
3229 Notes (const Notes_type& x);
3230
3231 void
3232 Notes (const Notes_optional& x);
3233
3234 void
3235 Notes (::std::auto_ptr< Notes_type > p);
3236
3237 // property
3238 //
3239 typedef ::xml_schema::idref property_type;
3240 typedef ::xsd::cxx::tree::traits< property_type, char > property_traits;
3241
3242 const property_type&
3243 property () const;
3244
3245 property_type&
3246 property ();
3247
3248 void
3249 property (const property_type& x);
3250
3251 void
3252 property (::std::auto_ptr< property_type > p);
3253
3254 // technique
3255 //
3256 typedef ::xml_schema::idref technique_type;
3257 typedef ::xsd::cxx::tree::optional< technique_type > technique_optional;
3258 typedef ::xsd::cxx::tree::traits< technique_type, char > technique_traits;
3259
3260 const technique_optional&
3261 technique () const;
3262
3263 technique_optional&
3264 technique ();
3265
3266 void
3267 technique (const technique_type& x);
3268
3269 void
3270 technique (const technique_optional& x);
3271
3272 void
3273 technique (::std::auto_ptr< technique_type > p);
3274
3275 // source
3276 //
3277 typedef ::xml_schema::idref source_type;
3278 typedef ::xsd::cxx::tree::optional< source_type > source_optional;
3279 typedef ::xsd::cxx::tree::traits< source_type, char > source_traits;
3280
3281 const source_optional&
3282 source () const;
3283
3284 source_optional&
3285 source ();
3286
3287 void
3288 source (const source_type& x);
3289
3290 void
3291 source (const source_optional& x);
3292
3293 void
3294 source (::std::auto_ptr< source_type > p);
3295
3296 // specimen
3297 //
3298 typedef ::xml_schema::idref specimen_type;
3299 typedef ::xsd::cxx::tree::optional< specimen_type > specimen_optional;
3300 typedef ::xsd::cxx::tree::traits< specimen_type, char > specimen_traits;
3301
3302 const specimen_optional&
3303 specimen () const;
3304
3305 specimen_optional&
3306 specimen ();
3307
3308 void
3309 specimen (const specimen_type& x);
3310
3311 void
3312 specimen (const specimen_optional& x);
3313
3314 void
3315 specimen (::std::auto_ptr< specimen_type > p);
3316
3317 // test
3318 //
3319 typedef ::xml_schema::idref test_type;
3320 typedef ::xsd::cxx::tree::optional< test_type > test_optional;
3321 typedef ::xsd::cxx::tree::traits< test_type, char > test_traits;
3322
3323 const test_optional&
3324 test () const;
3325
3326 test_optional&
3327 test ();
3328
3329 void
3330 test (const test_type& x);
3331
3332 void
3333 test (const test_optional& x);
3334
3335 void
3336 test (::std::auto_ptr< test_type > p);
3337
3338 // delimiter
3339 //
3340 typedef ::delimiter delimiter_type;
3341 typedef ::xsd::cxx::tree::traits< delimiter_type, char > delimiter_traits;
3342
3343 const delimiter_type&
3344 delimiter () const;
3345
3346 delimiter_type&
3347 delimiter ();
3348
3349 void
3350 delimiter (const delimiter_type& x);
3351
3352 void
3353 delimiter (::std::auto_ptr< delimiter_type > p);
3354
3355 static const delimiter_type&
3356 delimiter_default_value ();
3357
3358 // quote
3359 //
3360 typedef ::xml_schema::string quote_type;
3361 typedef ::xsd::cxx::tree::optional< quote_type > quote_optional;
3362 typedef ::xsd::cxx::tree::traits< quote_type, char > quote_traits;
3363
3364 const quote_optional&
3365 quote () const;
3366
3367 quote_optional&
3368 quote ();
3369
3370 void
3371 quote (const quote_type& x);
3372
3373 void
3374 quote (const quote_optional& x);
3375
3376 void
3377 quote (::std::auto_ptr< quote_type > p);
3378
3379 // Constructors.
3380 //
3381 PropertyData (const Data_type&,
3382 const property_type&);
3383
3384 PropertyData (::std::auto_ptr< Data_type >,
3385 const property_type&);
3386
3387 PropertyData (const ::xercesc::DOMElement& e,
3388 ::xml_schema::flags f = 0,
3389 ::xml_schema::container* c = 0);
3390
3391 PropertyData (const PropertyData& x,
3392 ::xml_schema::flags f = 0,
3393 ::xml_schema::container* c = 0);
3394
3395 virtual PropertyData*
3396 _clone (::xml_schema::flags f = 0,
3397 ::xml_schema::container* c = 0) const;
3398
3399 PropertyData&
3400 operator= (const PropertyData& x);
3401
3402 virtual
3403 ~PropertyData ();
3404
3405 // Implementation.
3406 //
3407 protected:
3408 void
3409 parse (::xsd::cxx::xml::dom::parser< char >&,
3410 ::xml_schema::flags);
3411
3412 protected:
3413 ::xsd::cxx::tree::one< Data_type > Data_;
3414 Uncertainty_sequence Uncertainty_;
3415 Qualifier_sequence Qualifier_;
3416 ParameterValue_sequence ParameterValue_;
3417 Notes_optional Notes_;
3418 ::xsd::cxx::tree::one< property_type > property_;
3419 technique_optional technique_;
3420 source_optional source_;
3421 specimen_optional specimen_;
3422 test_optional test_;
3423 ::xsd::cxx::tree::one< delimiter_type > delimiter_;
3424 static const delimiter_type delimiter_default_value_;
3425 quote_optional quote_;
3426};
3427
3428class Qualifier: public ::xml_schema::string
3429{
3430 public:
3431 // Constructors.
3432 //
3433 Qualifier ();
3434
3435 Qualifier (const char*);
3436
3437 Qualifier (const ::std::string&);
3438
3439 Qualifier (const ::xml_schema::string&);
3440
3441 Qualifier (const ::xercesc::DOMElement& e,
3442 ::xml_schema::flags f = 0,
3443 ::xml_schema::container* c = 0);
3444
3445 Qualifier (const ::xercesc::DOMAttr& a,
3446 ::xml_schema::flags f = 0,
3447 ::xml_schema::container* c = 0);
3448
3449 Qualifier (const ::std::string& s,
3450 const ::xercesc::DOMElement* e,
3451 ::xml_schema::flags f = 0,
3452 ::xml_schema::container* c = 0);
3453
3454 Qualifier (const Qualifier& x,
3455 ::xml_schema::flags f = 0,
3456 ::xml_schema::container* c = 0);
3457
3458 virtual Qualifier*
3459 _clone (::xml_schema::flags f = 0,
3460 ::xml_schema::container* c = 0) const;
3461
3462 virtual
3463 ~Qualifier ();
3464};
3465
3466class Relationship: public ::xml_schema::string
3467{
3468 public:
3469 // Constructors.
3470 //
3471 Relationship ();
3472
3473 Relationship (const char*);
3474
3475 Relationship (const ::std::string&);
3476
3477 Relationship (const ::xml_schema::string&);
3478
3479 Relationship (const ::xercesc::DOMElement& e,
3480 ::xml_schema::flags f = 0,
3481 ::xml_schema::container* c = 0);
3482
3483 Relationship (const ::xercesc::DOMAttr& a,
3484 ::xml_schema::flags f = 0,
3485 ::xml_schema::container* c = 0);
3486
3487 Relationship (const ::std::string& s,
3488 const ::xercesc::DOMElement* e,
3489 ::xml_schema::flags f = 0,
3490 ::xml_schema::container* c = 0);
3491
3492 Relationship (const Relationship& x,
3493 ::xml_schema::flags f = 0,
3494 ::xml_schema::container* c = 0);
3495
3496 virtual Relationship*
3497 _clone (::xml_schema::flags f = 0,
3498 ::xml_schema::container* c = 0) const;
3499
3500 virtual
3501 ~Relationship ();
3502};
3503
3504class Source: public ::xml_schema::type
3505{
3506 public:
3507 // source
3508 //
3509 typedef ::xml_schema::idref source_type;
3510 typedef ::xsd::cxx::tree::optional< source_type > source_optional;
3511 typedef ::xsd::cxx::tree::traits< source_type, char > source_traits;
3512
3513 const source_optional&
3514 source () const;
3515
3516 source_optional&
3517 source ();
3518
3519 void
3520 source (const source_type& x);
3521
3522 void
3523 source (const source_optional& x);
3524
3525 void
3526 source (::std::auto_ptr< source_type > p);
3527
3528 // Constructors.
3529 //
3530 Source ();
3531
3532 Source (const ::xercesc::DOMElement& e,
3533 ::xml_schema::flags f = 0,
3534 ::xml_schema::container* c = 0);
3535
3536 Source (const Source& x,
3537 ::xml_schema::flags f = 0,
3538 ::xml_schema::container* c = 0);
3539
3540 virtual Source*
3541 _clone (::xml_schema::flags f = 0,
3542 ::xml_schema::container* c = 0) const;
3543
3544 Source&
3545 operator= (const Source& x);
3546
3547 virtual
3548 ~Source ();
3549
3550 // Implementation.
3551 //
3552 protected:
3553 void
3554 parse (::xsd::cxx::xml::dom::parser< char >&,
3555 ::xml_schema::flags);
3556
3557 protected:
3558 source_optional source_;
3559};
3560
3561class Specification: public ::xml_schema::string
3562{
3563 public:
3564 // authority
3565 //
3566 typedef ::xml_schema::idref authority_type;
3567 typedef ::xsd::cxx::tree::optional< authority_type > authority_optional;
3568 typedef ::xsd::cxx::tree::traits< authority_type, char > authority_traits;
3569
3570 const authority_optional&
3571 authority () const;
3572
3573 authority_optional&
3574 authority ();
3575
3576 void
3577 authority (const authority_type& x);
3578
3579 void
3580 authority (const authority_optional& x);
3581
3582 void
3583 authority (::std::auto_ptr< authority_type > p);
3584
3585 // Constructors.
3586 //
3587 Specification ();
3588
3589 Specification (const char*);
3590
3591 Specification (const ::std::string&);
3592
3593 Specification (const ::xml_schema::string&);
3594
3595 Specification (const ::xercesc::DOMElement& e,
3596 ::xml_schema::flags f = 0,
3597 ::xml_schema::container* c = 0);
3598
3599 Specification (const Specification& x,
3600 ::xml_schema::flags f = 0,
3601 ::xml_schema::container* c = 0);
3602
3603 virtual Specification*
3604 _clone (::xml_schema::flags f = 0,
3605 ::xml_schema::container* c = 0) const;
3606
3607 Specification&
3608 operator= (const Specification& x);
3609
3610 virtual
3611 ~Specification ();
3612
3613 // Implementation.
3614 //
3615 protected:
3616 void
3617 parse (::xsd::cxx::xml::dom::parser< char >&,
3618 ::xml_schema::flags);
3619
3620 protected:
3621 authority_optional authority_;
3622};
3623
3624class Uncertainty: public ::xml_schema::type
3625{
3626 public:
3627 // Value
3628 //
3629 typedef ::Value Value_type;
3630 typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;
3631
3632 const Value_type&
3633 Value () const;
3634
3635 Value_type&
3636 Value ();
3637
3638 void
3639 Value (const Value_type& x);
3640
3641 void
3642 Value (::std::auto_ptr< Value_type > p);
3643
3644 // Units
3645 //
3646 typedef ::Units Units_type;
3647 typedef ::xsd::cxx::tree::optional< Units_type > Units_optional;
3648 typedef ::xsd::cxx::tree::traits< Units_type, char > Units_traits;
3649
3650 const Units_optional&
3651 Units () const;
3652
3653 Units_optional&
3654 Units ();
3655
3656 void
3657 Units (const Units_type& x);
3658
3659 void
3660 Units (const Units_optional& x);
3661
3662 void
3663 Units (::std::auto_ptr< Units_type > p);
3664
3665 // Unitless
3666 //
3667 typedef ::Unitless Unitless_type;
3668 typedef ::xsd::cxx::tree::optional< Unitless_type > Unitless_optional;
3669 typedef ::xsd::cxx::tree::traits< Unitless_type, char > Unitless_traits;
3670
3671 const Unitless_optional&
3672 Unitless () const;
3673
3674 Unitless_optional&
3675 Unitless ();
3676
3677 void
3678 Unitless (const Unitless_type& x);
3679
3680 void
3681 Unitless (const Unitless_optional& x);
3682
3683 void
3684 Unitless (::std::auto_ptr< Unitless_type > p);
3685
3686 // Notes
3687 //
3688 typedef ::Notes Notes_type;
3689 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
3690 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
3691
3692 const Notes_optional&
3693 Notes () const;
3694
3695 Notes_optional&
3696 Notes ();
3697
3698 void
3699 Notes (const Notes_type& x);
3700
3701 void
3702 Notes (const Notes_optional& x);
3703
3704 void
3705 Notes (::std::auto_ptr< Notes_type > p);
3706
3707 // Scale
3708 //
3709 typedef ::Scale Scale_type;
3710 typedef ::xsd::cxx::tree::optional< Scale_type > Scale_optional;
3711 typedef ::xsd::cxx::tree::traits< Scale_type, char > Scale_traits;
3712
3713 const Scale_optional&
3714 Scale () const;
3715
3716 Scale_optional&
3717 Scale ();
3718
3719 void
3720 Scale (const Scale_type& x);
3721
3722 void
3723 Scale (const Scale_optional& x);
3724
3725 void
3726 Scale (::std::auto_ptr< Scale_type > p);
3727
3728 static const Scale_type&
3729 Scale_default_value ();
3730
3731 // DistributionType
3732 //
3733 typedef ::xml_schema::string DistributionType_type;
3734 typedef ::xsd::cxx::tree::traits< DistributionType_type, char > DistributionType_traits;
3735
3736 const DistributionType_type&
3737 DistributionType () const;
3738
3739 DistributionType_type&
3740 DistributionType ();
3741
3742 void
3743 DistributionType (const DistributionType_type& x);
3744
3745 void
3746 DistributionType (::std::auto_ptr< DistributionType_type > p);
3747
3748 static const DistributionType_type&
3749 DistributionType_default_value ();
3750
3751 // Num_Std_Dev
3752 //
3753 typedef ::xml_schema::float_ Num_Std_Dev_type;
3754 typedef ::xsd::cxx::tree::traits< Num_Std_Dev_type, char > Num_Std_Dev_traits;
3755
3756 const Num_Std_Dev_type&
3757 Num_Std_Dev () const;
3758
3759 Num_Std_Dev_type&
3760 Num_Std_Dev ();
3761
3762 void
3763 Num_Std_Dev (const Num_Std_Dev_type& x);
3764
3765 static Num_Std_Dev_type
3766 Num_Std_Dev_default_value ();
3767
3768 // Percentile
3769 //
3770 typedef ::xml_schema::float_ Percentile_type;
3771 typedef ::xsd::cxx::tree::optional< Percentile_type > Percentile_optional;
3772 typedef ::xsd::cxx::tree::traits< Percentile_type, char > Percentile_traits;
3773
3774 const Percentile_optional&
3775 Percentile () const;
3776
3777 Percentile_optional&
3778 Percentile ();
3779
3780 void
3781 Percentile (const Percentile_type& x);
3782
3783 void
3784 Percentile (const Percentile_optional& x);
3785
3786 // ConfidenceLevel
3787 //
3788 typedef ::xml_schema::float_ ConfidenceLevel_type;
3789 typedef ::xsd::cxx::tree::optional< ConfidenceLevel_type > ConfidenceLevel_optional;
3790 typedef ::xsd::cxx::tree::traits< ConfidenceLevel_type, char > ConfidenceLevel_traits;
3791
3792 const ConfidenceLevel_optional&
3793 ConfidenceLevel () const;
3794
3795 ConfidenceLevel_optional&
3796 ConfidenceLevel ();
3797
3798 void
3799 ConfidenceLevel (const ConfidenceLevel_type& x);
3800
3801 void
3802 ConfidenceLevel (const ConfidenceLevel_optional& x);
3803
3804 // Constructors.
3805 //
3806 Uncertainty (const Value_type&);
3807
3808 Uncertainty (::std::auto_ptr< Value_type >);
3809
3810 Uncertainty (const ::xercesc::DOMElement& e,
3811 ::xml_schema::flags f = 0,
3812 ::xml_schema::container* c = 0);
3813
3814 Uncertainty (const Uncertainty& x,
3815 ::xml_schema::flags f = 0,
3816 ::xml_schema::container* c = 0);
3817
3818 virtual Uncertainty*
3819 _clone (::xml_schema::flags f = 0,
3820 ::xml_schema::container* c = 0) const;
3821
3822 Uncertainty&
3823 operator= (const Uncertainty& x);
3824
3825 virtual
3826 ~Uncertainty ();
3827
3828 // Implementation.
3829 //
3830 protected:
3831 void
3832 parse (::xsd::cxx::xml::dom::parser< char >&,
3833 ::xml_schema::flags);
3834
3835 protected:
3836 ::xsd::cxx::tree::one< Value_type > Value_;
3837 Units_optional Units_;
3838 Unitless_optional Unitless_;
3839 Notes_optional Notes_;
3840 Scale_optional Scale_;
3841 static const Scale_type Scale_default_value_;
3842 ::xsd::cxx::tree::one< DistributionType_type > DistributionType_;
3843 static const DistributionType_type DistributionType_default_value_;
3844 ::xsd::cxx::tree::one< Num_Std_Dev_type > Num_Std_Dev_;
3845 Percentile_optional Percentile_;
3846 ConfidenceLevel_optional ConfidenceLevel_;
3847};
3848
3849class Unit: public ::xml_schema::type
3850{
3851 public:
3852 // Name
3853 //
3854 typedef ::xml_schema::string Name_type;
3855 typedef ::xsd::cxx::tree::optional< Name_type > Name_optional;
3856 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
3857
3858 const Name_optional&
3859 Name () const;
3860
3861 Name_optional&
3862 Name ();
3863
3864 void
3865 Name (const Name_type& x);
3866
3867 void
3868 Name (const Name_optional& x);
3869
3870 void
3871 Name (::std::auto_ptr< Name_type > p);
3872
3873 // Currency
3874 //
3875 typedef ::CurrencyCode Currency_type;
3876 typedef ::xsd::cxx::tree::optional< Currency_type > Currency_optional;
3877 typedef ::xsd::cxx::tree::traits< Currency_type, char > Currency_traits;
3878
3879 const Currency_optional&
3880 Currency () const;
3881
3882 Currency_optional&
3883 Currency ();
3884
3885 void
3886 Currency (const Currency_type& x);
3887
3888 void
3889 Currency (const Currency_optional& x);
3890
3891 void
3892 Currency (::std::auto_ptr< Currency_type > p);
3893
3894 // power
3895 //
3896 typedef ::xml_schema::decimal power_type;
3897 typedef ::xsd::cxx::tree::optional< power_type > power_optional;
3898 typedef ::xsd::cxx::tree::traits< power_type, char, ::xsd::cxx::tree::schema_type::decimal > power_traits;
3899
3900 const power_optional&
3901 power () const;
3902
3903 power_optional&
3904 power ();
3905
3906 void
3907 power (const power_type& x);
3908
3909 void
3910 power (const power_optional& x);
3911
3912 // description
3913 //
3914 typedef ::xml_schema::string description_type;
3915 typedef ::xsd::cxx::tree::optional< description_type > description_optional;
3916 typedef ::xsd::cxx::tree::traits< description_type, char > description_traits;
3917
3918 const description_optional&
3919 description () const;
3920
3921 description_optional&
3922 description ();
3923
3924 void
3925 description (const description_type& x);
3926
3927 void
3928 description (const description_optional& x);
3929
3930 void
3931 description (::std::auto_ptr< description_type > p);
3932
3933 // Constructors.
3934 //
3935 Unit ();
3936
3937 Unit (const ::xercesc::DOMElement& e,
3938 ::xml_schema::flags f = 0,
3939 ::xml_schema::container* c = 0);
3940
3941 Unit (const Unit& x,
3942 ::xml_schema::flags f = 0,
3943 ::xml_schema::container* c = 0);
3944
3945 virtual Unit*
3946 _clone (::xml_schema::flags f = 0,
3947 ::xml_schema::container* c = 0) const;
3948
3949 Unit&
3950 operator= (const Unit& x);
3951
3952 virtual
3953 ~Unit ();
3954
3955 // Implementation.
3956 //
3957 protected:
3958 void
3959 parse (::xsd::cxx::xml::dom::parser< char >&,
3960 ::xml_schema::flags);
3961
3962 protected:
3963 Name_optional Name_;
3964 Currency_optional Currency_;
3965 power_optional power_;
3966 description_optional description_;
3967};
3968
3969class Unitless: public ::xml_schema::type
3970{
3971 public:
3972 // Constructors.
3973 //
3974 Unitless ();
3975
3976 Unitless (const ::xercesc::DOMElement& e,
3977 ::xml_schema::flags f = 0,
3978 ::xml_schema::container* c = 0);
3979
3980 Unitless (const ::xercesc::DOMAttr& a,
3981 ::xml_schema::flags f = 0,
3982 ::xml_schema::container* c = 0);
3983
3984 Unitless (const ::std::string& s,
3985 const ::xercesc::DOMElement* e,
3986 ::xml_schema::flags f = 0,
3987 ::xml_schema::container* c = 0);
3988
3989 Unitless (const Unitless& x,
3990 ::xml_schema::flags f = 0,
3991 ::xml_schema::container* c = 0);
3992
3993 virtual Unitless*
3994 _clone (::xml_schema::flags f = 0,
3995 ::xml_schema::container* c = 0) const;
3996
3997 virtual
3998 ~Unitless ();
3999};
4000
4001class Units: public ::xml_schema::type
4002{
4003 public:
4004 // Unit
4005 //
4006 typedef ::Unit Unit_type;
4007 typedef ::xsd::cxx::tree::sequence< Unit_type > Unit_sequence;
4008 typedef Unit_sequence::iterator Unit_iterator;
4009 typedef Unit_sequence::const_iterator Unit_const_iterator;
4010 typedef ::xsd::cxx::tree::traits< Unit_type, char > Unit_traits;
4011
4012 const Unit_sequence&
4013 Unit () const;
4014
4015 Unit_sequence&
4016 Unit ();
4017
4018 void
4019 Unit (const Unit_sequence& s);
4020
4021 // system
4022 //
4023 typedef ::xml_schema::string system_type;
4024 typedef ::xsd::cxx::tree::optional< system_type > system_optional;
4025 typedef ::xsd::cxx::tree::traits< system_type, char > system_traits;
4026
4027 const system_optional&
4028 system () const;
4029
4030 system_optional&
4031 system ();
4032
4033 void
4034 system (const system_type& x);
4035
4036 void
4037 system (const system_optional& x);
4038
4039 void
4040 system (::std::auto_ptr< system_type > p);
4041
4042 // factor
4043 //
4044 typedef ::xml_schema::float_ factor_type;
4045 typedef ::xsd::cxx::tree::optional< factor_type > factor_optional;
4046 typedef ::xsd::cxx::tree::traits< factor_type, char > factor_traits;
4047
4048 const factor_optional&
4049 factor () const;
4050
4051 factor_optional&
4052 factor ();
4053
4054 void
4055 factor (const factor_type& x);
4056
4057 void
4058 factor (const factor_optional& x);
4059
4060 // name
4061 //
4062 typedef ::xml_schema::string name_type;
4063 typedef ::xsd::cxx::tree::optional< name_type > name_optional;
4064 typedef ::xsd::cxx::tree::traits< name_type, char > name_traits;
4065
4066 const name_optional&
4067 name () const;
4068
4069 name_optional&
4070 name ();
4071
4072 void
4073 name (const name_type& x);
4074
4075 void
4076 name (const name_optional& x);
4077
4078 void
4079 name (::std::auto_ptr< name_type > p);
4080
4081 // description
4082 //
4083 typedef ::xml_schema::string description_type;
4084 typedef ::xsd::cxx::tree::optional< description_type > description_optional;
4085 typedef ::xsd::cxx::tree::traits< description_type, char > description_traits;
4086
4087 const description_optional&
4088 description () const;
4089
4090 description_optional&
4091 description ();
4092
4093 void
4094 description (const description_type& x);
4095
4096 void
4097 description (const description_optional& x);
4098
4099 void
4100 description (::std::auto_ptr< description_type > p);
4101
4102 // Constructors.
4103 //
4104 Units ();
4105
4106 Units (const ::xercesc::DOMElement& e,
4107 ::xml_schema::flags f = 0,
4108 ::xml_schema::container* c = 0);
4109
4110 Units (const Units& x,
4111 ::xml_schema::flags f = 0,
4112 ::xml_schema::container* c = 0);
4113
4114 virtual Units*
4115 _clone (::xml_schema::flags f = 0,
4116 ::xml_schema::container* c = 0) const;
4117
4118 Units&
4119 operator= (const Units& x);
4120
4121 virtual
4122 ~Units ();
4123
4124 // Implementation.
4125 //
4126 protected:
4127 void
4128 parse (::xsd::cxx::xml::dom::parser< char >&,
4129 ::xml_schema::flags);
4130
4131 protected:
4132 Unit_sequence Unit_;
4133 system_optional system_;
4134 factor_optional factor_;
4135 name_optional name_;
4136 description_optional description_;
4137};
4138
4139class Value: public ::xml_schema::string
4140{
4141 public:
4142 // format
4143 //
4144 typedef ::DataFormat format_type;
4145 typedef ::xsd::cxx::tree::traits< format_type, char > format_traits;
4146
4147 const format_type&
4148 format () const;
4149
4150 format_type&
4151 format ();
4152
4153 void
4154 format (const format_type& x);
4155
4156 void
4157 format (::std::auto_ptr< format_type > p);
4158
4159 // Constructors.
4160 //
4161 Value (const format_type&);
4162
4163 Value (const char*,
4164 const format_type&);
4165
4166 Value (const ::std::string&,
4167 const format_type&);
4168
4169 Value (const ::xml_schema::string&,
4170 const format_type&);
4171
4172 Value (const ::xercesc::DOMElement& e,
4173 ::xml_schema::flags f = 0,
4174 ::xml_schema::container* c = 0);
4175
4176 Value (const Value& x,
4177 ::xml_schema::flags f = 0,
4178 ::xml_schema::container* c = 0);
4179
4180 virtual Value*
4181 _clone (::xml_schema::flags f = 0,
4182 ::xml_schema::container* c = 0) const;
4183
4184 Value&
4185 operator= (const Value& x);
4186
4187 virtual
4188 ~Value ();
4189
4190 // Implementation.
4191 //
4192 protected:
4193 void
4194 parse (::xsd::cxx::xml::dom::parser< char >&,
4195 ::xml_schema::flags);
4196
4197 protected:
4198 ::xsd::cxx::tree::one< format_type > format_;
4199};
4200
4201class AuthorityDetails: public ::xml_schema::type
4202{
4203 public:
4204 // Name
4205 //
4206 typedef ::Name Name_type;
4207 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4208
4209 const Name_type&
4210 Name () const;
4211
4212 Name_type&
4213 Name ();
4214
4215 void
4216 Name (const Name_type& x);
4217
4218 void
4219 Name (::std::auto_ptr< Name_type > p);
4220
4221 // Notes
4222 //
4223 typedef ::Notes Notes_type;
4224 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4225 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4226
4227 const Notes_optional&
4228 Notes () const;
4229
4230 Notes_optional&
4231 Notes ();
4232
4233 void
4234 Notes (const Notes_type& x);
4235
4236 void
4237 Notes (const Notes_optional& x);
4238
4239 void
4240 Notes (::std::auto_ptr< Notes_type > p);
4241
4242 // id
4243 //
4244 typedef ::xml_schema::id id_type;
4245 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4246
4247 const id_type&
4248 id () const;
4249
4250 id_type&
4251 id ();
4252
4253 void
4254 id (const id_type& x);
4255
4256 void
4257 id (::std::auto_ptr< id_type > p);
4258
4259 // Constructors.
4260 //
4261 AuthorityDetails (const Name_type&,
4262 const id_type&);
4263
4264 AuthorityDetails (::std::auto_ptr< Name_type >,
4265 const id_type&);
4266
4267 AuthorityDetails (const ::xercesc::DOMElement& e,
4268 ::xml_schema::flags f = 0,
4269 ::xml_schema::container* c = 0);
4270
4271 AuthorityDetails (const AuthorityDetails& x,
4272 ::xml_schema::flags f = 0,
4273 ::xml_schema::container* c = 0);
4274
4275 virtual AuthorityDetails*
4276 _clone (::xml_schema::flags f = 0,
4277 ::xml_schema::container* c = 0) const;
4278
4279 AuthorityDetails&
4280 operator= (const AuthorityDetails& x);
4281
4282 virtual
4283 ~AuthorityDetails ();
4284
4285 // Implementation.
4286 //
4287 protected:
4288 void
4289 parse (::xsd::cxx::xml::dom::parser< char >&,
4290 ::xml_schema::flags);
4291
4292 protected:
4293 ::xsd::cxx::tree::one< Name_type > Name_;
4294 Notes_optional Notes_;
4295 ::xsd::cxx::tree::one< id_type > id_;
4296};
4297
4298class DataSourceDetails: public ::xml_schema::type
4299{
4300 public:
4301 // Name
4302 //
4303 typedef ::Name Name_type;
4304 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4305
4306 const Name_type&
4307 Name () const;
4308
4309 Name_type&
4310 Name ();
4311
4312 void
4313 Name (const Name_type& x);
4314
4315 void
4316 Name (::std::auto_ptr< Name_type > p);
4317
4318 // Notes
4319 //
4320 typedef ::Notes Notes_type;
4321 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4322 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4323
4324 const Notes_optional&
4325 Notes () const;
4326
4327 Notes_optional&
4328 Notes ();
4329
4330 void
4331 Notes (const Notes_type& x);
4332
4333 void
4334 Notes (const Notes_optional& x);
4335
4336 void
4337 Notes (::std::auto_ptr< Notes_type > p);
4338
4339 // id
4340 //
4341 typedef ::xml_schema::id id_type;
4342 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4343
4344 const id_type&
4345 id () const;
4346
4347 id_type&
4348 id ();
4349
4350 void
4351 id (const id_type& x);
4352
4353 void
4354 id (::std::auto_ptr< id_type > p);
4355
4356 // type
4357 //
4358 typedef ::xml_schema::string type_type;
4359 typedef ::xsd::cxx::tree::optional< type_type > type_optional;
4360 typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
4361
4362 const type_optional&
4363 type () const;
4364
4365 type_optional&
4366 type ();
4367
4368 void
4369 type (const type_type& x);
4370
4371 void
4372 type (const type_optional& x);
4373
4374 void
4375 type (::std::auto_ptr< type_type > p);
4376
4377 // Constructors.
4378 //
4379 DataSourceDetails (const Name_type&,
4380 const id_type&);
4381
4382 DataSourceDetails (::std::auto_ptr< Name_type >,
4383 const id_type&);
4384
4385 DataSourceDetails (const ::xercesc::DOMElement& e,
4386 ::xml_schema::flags f = 0,
4387 ::xml_schema::container* c = 0);
4388
4389 DataSourceDetails (const DataSourceDetails& x,
4390 ::xml_schema::flags f = 0,
4391 ::xml_schema::container* c = 0);
4392
4393 virtual DataSourceDetails*
4394 _clone (::xml_schema::flags f = 0,
4395 ::xml_schema::container* c = 0) const;
4396
4397 DataSourceDetails&
4398 operator= (const DataSourceDetails& x);
4399
4400 virtual
4401 ~DataSourceDetails ();
4402
4403 // Implementation.
4404 //
4405 protected:
4406 void
4407 parse (::xsd::cxx::xml::dom::parser< char >&,
4408 ::xml_schema::flags);
4409
4410 protected:
4411 ::xsd::cxx::tree::one< Name_type > Name_;
4412 Notes_optional Notes_;
4413 ::xsd::cxx::tree::one< id_type > id_;
4414 type_optional type_;
4415};
4416
4417class MeasurementTechniqueDetails: public ::xml_schema::type
4418{
4419 public:
4420 // Name
4421 //
4422 typedef ::Name Name_type;
4423 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4424
4425 const Name_type&
4426 Name () const;
4427
4428 Name_type&
4429 Name ();
4430
4431 void
4432 Name (const Name_type& x);
4433
4434 void
4435 Name (::std::auto_ptr< Name_type > p);
4436
4437 // Notes
4438 //
4439 typedef ::Notes Notes_type;
4440 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4441 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4442
4443 const Notes_optional&
4444 Notes () const;
4445
4446 Notes_optional&
4447 Notes ();
4448
4449 void
4450 Notes (const Notes_type& x);
4451
4452 void
4453 Notes (const Notes_optional& x);
4454
4455 void
4456 Notes (::std::auto_ptr< Notes_type > p);
4457
4458 // id
4459 //
4460 typedef ::xml_schema::id id_type;
4461 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4462
4463 const id_type&
4464 id () const;
4465
4466 id_type&
4467 id ();
4468
4469 void
4470 id (const id_type& x);
4471
4472 void
4473 id (::std::auto_ptr< id_type > p);
4474
4475 // Constructors.
4476 //
4477 MeasurementTechniqueDetails (const Name_type&,
4478 const id_type&);
4479
4480 MeasurementTechniqueDetails (::std::auto_ptr< Name_type >,
4481 const id_type&);
4482
4483 MeasurementTechniqueDetails (const ::xercesc::DOMElement& e,
4484 ::xml_schema::flags f = 0,
4485 ::xml_schema::container* c = 0);
4486
4487 MeasurementTechniqueDetails (const MeasurementTechniqueDetails& x,
4488 ::xml_schema::flags f = 0,
4489 ::xml_schema::container* c = 0);
4490
4491 virtual MeasurementTechniqueDetails*
4492 _clone (::xml_schema::flags f = 0,
4493 ::xml_schema::container* c = 0) const;
4494
4495 MeasurementTechniqueDetails&
4496 operator= (const MeasurementTechniqueDetails& x);
4497
4498 virtual
4499 ~MeasurementTechniqueDetails ();
4500
4501 // Implementation.
4502 //
4503 protected:
4504 void
4505 parse (::xsd::cxx::xml::dom::parser< char >&,
4506 ::xml_schema::flags);
4507
4508 protected:
4509 ::xsd::cxx::tree::one< Name_type > Name_;
4510 Notes_optional Notes_;
4511 ::xsd::cxx::tree::one< id_type > id_;
4512};
4513
4514class ParameterDetails: public ::xml_schema::type
4515{
4516 public:
4517 // Name
4518 //
4519 typedef ::Name Name_type;
4520 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4521
4522 const Name_type&
4523 Name () const;
4524
4525 Name_type&
4526 Name ();
4527
4528 void
4529 Name (const Name_type& x);
4530
4531 void
4532 Name (::std::auto_ptr< Name_type > p);
4533
4534 // Units
4535 //
4536 typedef ::Units Units_type;
4537 typedef ::xsd::cxx::tree::optional< Units_type > Units_optional;
4538 typedef ::xsd::cxx::tree::traits< Units_type, char > Units_traits;
4539
4540 const Units_optional&
4541 Units () const;
4542
4543 Units_optional&
4544 Units ();
4545
4546 void
4547 Units (const Units_type& x);
4548
4549 void
4550 Units (const Units_optional& x);
4551
4552 void
4553 Units (::std::auto_ptr< Units_type > p);
4554
4555 // Unitless
4556 //
4557 typedef ::Unitless Unitless_type;
4558 typedef ::xsd::cxx::tree::optional< Unitless_type > Unitless_optional;
4559 typedef ::xsd::cxx::tree::traits< Unitless_type, char > Unitless_traits;
4560
4561 const Unitless_optional&
4562 Unitless () const;
4563
4564 Unitless_optional&
4565 Unitless ();
4566
4567 void
4568 Unitless (const Unitless_type& x);
4569
4570 void
4571 Unitless (const Unitless_optional& x);
4572
4573 void
4574 Unitless (::std::auto_ptr< Unitless_type > p);
4575
4576 // Notes
4577 //
4578 typedef ::Notes Notes_type;
4579 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4580 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4581
4582 const Notes_optional&
4583 Notes () const;
4584
4585 Notes_optional&
4586 Notes ();
4587
4588 void
4589 Notes (const Notes_type& x);
4590
4591 void
4592 Notes (const Notes_optional& x);
4593
4594 void
4595 Notes (::std::auto_ptr< Notes_type > p);
4596
4597 // id
4598 //
4599 typedef ::xml_schema::id id_type;
4600 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4601
4602 const id_type&
4603 id () const;
4604
4605 id_type&
4606 id ();
4607
4608 void
4609 id (const id_type& x);
4610
4611 void
4612 id (::std::auto_ptr< id_type > p);
4613
4614 // Constructors.
4615 //
4616 ParameterDetails (const Name_type&,
4617 const id_type&);
4618
4619 ParameterDetails (::std::auto_ptr< Name_type >,
4620 const id_type&);
4621
4622 ParameterDetails (const ::xercesc::DOMElement& e,
4623 ::xml_schema::flags f = 0,
4624 ::xml_schema::container* c = 0);
4625
4626 ParameterDetails (const ParameterDetails& x,
4627 ::xml_schema::flags f = 0,
4628 ::xml_schema::container* c = 0);
4629
4630 virtual ParameterDetails*
4631 _clone (::xml_schema::flags f = 0,
4632 ::xml_schema::container* c = 0) const;
4633
4634 ParameterDetails&
4635 operator= (const ParameterDetails& x);
4636
4637 virtual
4638 ~ParameterDetails ();
4639
4640 // Implementation.
4641 //
4642 protected:
4643 void
4644 parse (::xsd::cxx::xml::dom::parser< char >&,
4645 ::xml_schema::flags);
4646
4647 protected:
4648 ::xsd::cxx::tree::one< Name_type > Name_;
4649 Units_optional Units_;
4650 Unitless_optional Unitless_;
4651 Notes_optional Notes_;
4652 ::xsd::cxx::tree::one< id_type > id_;
4653};
4654
4655class PropertyDetails: public ::xml_schema::type
4656{
4657 public:
4658 // Name
4659 //
4660 typedef ::Name Name_type;
4661 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4662
4663 const Name_type&
4664 Name () const;
4665
4666 Name_type&
4667 Name ();
4668
4669 void
4670 Name (const Name_type& x);
4671
4672 void
4673 Name (::std::auto_ptr< Name_type > p);
4674
4675 // Units
4676 //
4677 typedef ::Units Units_type;
4678 typedef ::xsd::cxx::tree::optional< Units_type > Units_optional;
4679 typedef ::xsd::cxx::tree::traits< Units_type, char > Units_traits;
4680
4681 const Units_optional&
4682 Units () const;
4683
4684 Units_optional&
4685 Units ();
4686
4687 void
4688 Units (const Units_type& x);
4689
4690 void
4691 Units (const Units_optional& x);
4692
4693 void
4694 Units (::std::auto_ptr< Units_type > p);
4695
4696 // Unitless
4697 //
4698 typedef ::Unitless Unitless_type;
4699 typedef ::xsd::cxx::tree::optional< Unitless_type > Unitless_optional;
4700 typedef ::xsd::cxx::tree::traits< Unitless_type, char > Unitless_traits;
4701
4702 const Unitless_optional&
4703 Unitless () const;
4704
4705 Unitless_optional&
4706 Unitless ();
4707
4708 void
4709 Unitless (const Unitless_type& x);
4710
4711 void
4712 Unitless (const Unitless_optional& x);
4713
4714 void
4715 Unitless (::std::auto_ptr< Unitless_type > p);
4716
4717 // Notes
4718 //
4719 typedef ::Notes Notes_type;
4720 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4721 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4722
4723 const Notes_optional&
4724 Notes () const;
4725
4726 Notes_optional&
4727 Notes ();
4728
4729 void
4730 Notes (const Notes_type& x);
4731
4732 void
4733 Notes (const Notes_optional& x);
4734
4735 void
4736 Notes (::std::auto_ptr< Notes_type > p);
4737
4738 // id
4739 //
4740 typedef ::xml_schema::id id_type;
4741 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4742
4743 const id_type&
4744 id () const;
4745
4746 id_type&
4747 id ();
4748
4749 void
4750 id (const id_type& x);
4751
4752 void
4753 id (::std::auto_ptr< id_type > p);
4754
4755 // type
4756 //
4757 typedef ::xml_schema::string type_type;
4758 typedef ::xsd::cxx::tree::optional< type_type > type_optional;
4759 typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
4760
4761 const type_optional&
4762 type () const;
4763
4764 type_optional&
4765 type ();
4766
4767 void
4768 type (const type_type& x);
4769
4770 void
4771 type (const type_optional& x);
4772
4773 void
4774 type (::std::auto_ptr< type_type > p);
4775
4776 // Constructors.
4777 //
4778 PropertyDetails (const Name_type&,
4779 const id_type&);
4780
4781 PropertyDetails (::std::auto_ptr< Name_type >,
4782 const id_type&);
4783
4784 PropertyDetails (const ::xercesc::DOMElement& e,
4785 ::xml_schema::flags f = 0,
4786 ::xml_schema::container* c = 0);
4787
4788 PropertyDetails (const PropertyDetails& x,
4789 ::xml_schema::flags f = 0,
4790 ::xml_schema::container* c = 0);
4791
4792 virtual PropertyDetails*
4793 _clone (::xml_schema::flags f = 0,
4794 ::xml_schema::container* c = 0) const;
4795
4796 PropertyDetails&
4797 operator= (const PropertyDetails& x);
4798
4799 virtual
4800 ~PropertyDetails ();
4801
4802 // Implementation.
4803 //
4804 protected:
4805 void
4806 parse (::xsd::cxx::xml::dom::parser< char >&,
4807 ::xml_schema::flags);
4808
4809 protected:
4810 ::xsd::cxx::tree::one< Name_type > Name_;
4811 Units_optional Units_;
4812 Unitless_optional Unitless_;
4813 Notes_optional Notes_;
4814 ::xsd::cxx::tree::one< id_type > id_;
4815 type_optional type_;
4816};
4817
4818class SourceDetails: public ::xml_schema::type
4819{
4820 public:
4821 // Name
4822 //
4823 typedef ::Name Name_type;
4824 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4825
4826 const Name_type&
4827 Name () const;
4828
4829 Name_type&
4830 Name ();
4831
4832 void
4833 Name (const Name_type& x);
4834
4835 void
4836 Name (::std::auto_ptr< Name_type > p);
4837
4838 // Notes
4839 //
4840 typedef ::Notes Notes_type;
4841 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4842 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4843
4844 const Notes_optional&
4845 Notes () const;
4846
4847 Notes_optional&
4848 Notes ();
4849
4850 void
4851 Notes (const Notes_type& x);
4852
4853 void
4854 Notes (const Notes_optional& x);
4855
4856 void
4857 Notes (::std::auto_ptr< Notes_type > p);
4858
4859 // id
4860 //
4861 typedef ::xml_schema::id id_type;
4862 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
4863
4864 const id_type&
4865 id () const;
4866
4867 id_type&
4868 id ();
4869
4870 void
4871 id (const id_type& x);
4872
4873 void
4874 id (::std::auto_ptr< id_type > p);
4875
4876 // type
4877 //
4878 typedef ::xml_schema::string type_type;
4879 typedef ::xsd::cxx::tree::optional< type_type > type_optional;
4880 typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
4881
4882 const type_optional&
4883 type () const;
4884
4885 type_optional&
4886 type ();
4887
4888 void
4889 type (const type_type& x);
4890
4891 void
4892 type (const type_optional& x);
4893
4894 void
4895 type (::std::auto_ptr< type_type > p);
4896
4897 // Constructors.
4898 //
4899 SourceDetails (const Name_type&,
4900 const id_type&);
4901
4902 SourceDetails (::std::auto_ptr< Name_type >,
4903 const id_type&);
4904
4905 SourceDetails (const ::xercesc::DOMElement& e,
4906 ::xml_schema::flags f = 0,
4907 ::xml_schema::container* c = 0);
4908
4909 SourceDetails (const SourceDetails& x,
4910 ::xml_schema::flags f = 0,
4911 ::xml_schema::container* c = 0);
4912
4913 virtual SourceDetails*
4914 _clone (::xml_schema::flags f = 0,
4915 ::xml_schema::container* c = 0) const;
4916
4917 SourceDetails&
4918 operator= (const SourceDetails& x);
4919
4920 virtual
4921 ~SourceDetails ();
4922
4923 // Implementation.
4924 //
4925 protected:
4926 void
4927 parse (::xsd::cxx::xml::dom::parser< char >&,
4928 ::xml_schema::flags);
4929
4930 protected:
4931 ::xsd::cxx::tree::one< Name_type > Name_;
4932 Notes_optional Notes_;
4933 ::xsd::cxx::tree::one< id_type > id_;
4934 type_optional type_;
4935};
4936
4937class SpecimenDetails: public ::xml_schema::type
4938{
4939 public:
4940 // Name
4941 //
4942 typedef ::Name Name_type;
4943 typedef ::xsd::cxx::tree::optional< Name_type > Name_optional;
4944 typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;
4945
4946 const Name_optional&
4947 Name () const;
4948
4949 Name_optional&
4950 Name ();
4951
4952 void
4953 Name (const Name_type& x);
4954
4955 void
4956 Name (const Name_optional& x);
4957
4958 void
4959 Name (::std::auto_ptr< Name_type > p);
4960
4961 // Notes
4962 //
4963 typedef ::Notes Notes_type;
4964 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
4965 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
4966
4967 const Notes_optional&
4968 Notes () const;
4969
4970 Notes_optional&
4971 Notes ();
4972
4973 void
4974 Notes (const Notes_type& x);
4975
4976 void
4977 Notes (const Notes_optional& x);
4978
4979 void
4980 Notes (::std::auto_ptr< Notes_type > p);
4981
4982 // Geometry
4983 //
4984 typedef ::Geometry Geometry_type;
4985 typedef ::xsd::cxx::tree::optional< Geometry_type > Geometry_optional;
4986 typedef ::xsd::cxx::tree::traits< Geometry_type, char > Geometry_traits;
4987
4988 const Geometry_optional&
4989 Geometry () const;
4990
4991 Geometry_optional&
4992 Geometry ();
4993
4994 void
4995 Geometry (const Geometry_type& x);
4996
4997 void
4998 Geometry (const Geometry_optional& x);
4999
5000 void
5001 Geometry (::std::auto_ptr< Geometry_type > p);
5002
5003 // id
5004 //
5005 typedef ::xml_schema::id id_type;
5006 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
5007
5008 const id_type&
5009 id () const;
5010
5011 id_type&
5012 id ();
5013
5014 void
5015 id (const id_type& x);
5016
5017 void
5018 id (::std::auto_ptr< id_type > p);
5019
5020 // type
5021 //
5022 typedef ::xml_schema::string type_type;
5023 typedef ::xsd::cxx::tree::optional< type_type > type_optional;
5024 typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;
5025
5026 const type_optional&
5027 type () const;
5028
5029 type_optional&
5030 type ();
5031
5032 void
5033 type (const type_type& x);
5034
5035 void
5036 type (const type_optional& x);
5037
5038 void
5039 type (::std::auto_ptr< type_type > p);
5040
5041 // Constructors.
5042 //
5043 SpecimenDetails (const id_type&);
5044
5045 SpecimenDetails (const ::xercesc::DOMElement& e,
5046 ::xml_schema::flags f = 0,
5047 ::xml_schema::container* c = 0);
5048
5049 SpecimenDetails (const SpecimenDetails& x,
5050 ::xml_schema::flags f = 0,
5051 ::xml_schema::container* c = 0);
5052
5053 virtual SpecimenDetails*
5054 _clone (::xml_schema::flags f = 0,
5055 ::xml_schema::container* c = 0) const;
5056
5057 SpecimenDetails&
5058 operator= (const SpecimenDetails& x);
5059
5060 virtual
5061 ~SpecimenDetails ();
5062
5063 // Implementation.
5064 //
5065 protected:
5066 void
5067 parse (::xsd::cxx::xml::dom::parser< char >&,
5068 ::xml_schema::flags);
5069
5070 protected:
5071 Name_optional Name_;
5072 Notes_optional Notes_;
5073 Geometry_optional Geometry_;
5074 ::xsd::cxx::tree::one< id_type > id_;
5075 type_optional type_;
5076};
5077
5078class TestConditionDetails: public ::xml_schema::type
5079{
5080 public:
5081 // ParameterValue
5082 //
5083 typedef ::ParameterValue ParameterValue_type;
5084 typedef ::xsd::cxx::tree::sequence< ParameterValue_type > ParameterValue_sequence;
5085 typedef ParameterValue_sequence::iterator ParameterValue_iterator;
5086 typedef ParameterValue_sequence::const_iterator ParameterValue_const_iterator;
5087 typedef ::xsd::cxx::tree::traits< ParameterValue_type, char > ParameterValue_traits;
5088
5089 const ParameterValue_sequence&
5090 ParameterValue () const;
5091
5092 ParameterValue_sequence&
5093 ParameterValue ();
5094
5095 void
5096 ParameterValue (const ParameterValue_sequence& s);
5097
5098 // Notes
5099 //
5100 typedef ::Notes Notes_type;
5101 typedef ::xsd::cxx::tree::optional< Notes_type > Notes_optional;
5102 typedef ::xsd::cxx::tree::traits< Notes_type, char > Notes_traits;
5103
5104 const Notes_optional&
5105 Notes () const;
5106
5107 Notes_optional&
5108 Notes ();
5109
5110 void
5111 Notes (const Notes_type& x);
5112
5113 void
5114 Notes (const Notes_optional& x);
5115
5116 void
5117 Notes (::std::auto_ptr< Notes_type > p);
5118
5119 // id
5120 //
5121 typedef ::xml_schema::id id_type;
5122 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
5123
5124 const id_type&
5125 id () const;
5126
5127 id_type&
5128 id ();
5129
5130 void
5131 id (const id_type& x);
5132
5133 void
5134 id (::std::auto_ptr< id_type > p);
5135
5136 // Constructors.
5137 //
5138 TestConditionDetails (const id_type&);
5139
5140 TestConditionDetails (const ::xercesc::DOMElement& e,
5141 ::xml_schema::flags f = 0,
5142 ::xml_schema::container* c = 0);
5143
5144 TestConditionDetails (const TestConditionDetails& x,
5145 ::xml_schema::flags f = 0,
5146 ::xml_schema::container* c = 0);
5147
5148 virtual TestConditionDetails*
5149 _clone (::xml_schema::flags f = 0,
5150 ::xml_schema::container* c = 0) const;
5151
5152 TestConditionDetails&
5153 operator= (const TestConditionDetails& x);
5154
5155 virtual
5156 ~TestConditionDetails ();
5157
5158 // Implementation.
5159 //
5160 protected:
5161 void
5162 parse (::xsd::cxx::xml::dom::parser< char >&,
5163 ::xml_schema::flags);
5164
5165 protected:
5166 ParameterValue_sequence ParameterValue_;
5167 Notes_optional Notes_;
5168 ::xsd::cxx::tree::one< id_type > id_;
5169};
5170
5171class ChemicalElementSymbol: public ::xml_schema::string
5172{
5173 public:
5174 enum value
5175 {
5176 H,
5177 He,
5178 Li,
5179 Be,
5180 B,
5181 C,
5182 N,
5183 O,
5184 F,
5185 Ne,
5186 Na,
5187 Mg,
5188 Al,
5189 Si,
5190 P,
5191 S,
5192 Cl,
5193 Ar,
5194 K,
5195 Ca,
5196 Sc,
5197 Ti,
5198 V,
5199 Cr,
5200 Mn,
5201 Fe,
5202 Co,
5203 Ni,
5204 Cu,
5205 Zn,
5206 Ga,
5207 Ge,
5208 As,
5209 Se,
5210 Br,
5211 Kr,
5212 Rb,
5213 Sr,
5214 Y,
5215 Zr,
5216 Nb,
5217 Mo,
5218 Tc,
5219 Ru,
5220 Rh,
5221 Pd,
5222 Ag,
5223 Cd,
5224 In,
5225 Sn,
5226 Sb,
5227 Te,
5228 I,
5229 Xe,
5230 Cs,
5231 Ba,
5232 La,
5233 Ce,
5234 Pr,
5235 Nd,
5236 Pm,
5237 Sm,
5238 Eu,
5239 Gd,
5240 Tb,
5241 Dy,
5242 Ho,
5243 Er,
5244 Tm,
5245 Yb,
5246 Lu,
5247 Hf,
5248 Ta,
5249 W,
5250 Re,
5251 Os,
5252 Ir,
5253 Pt,
5254 Au,
5255 Hg,
5256 Tl,
5257 Pb,
5258 Bi,
5259 Po,
5260 At,
5261 Rn,
5262 Fr,
5263 Ra,
5264 Ac,
5265 Th,
5266 Pa,
5267 U,
5268 Np,
5269 Pu,
5270 Am,
5271 Cm,
5272 Bk,
5273 Cf,
5274 Es,
5275 Fm,
5276 Md,
5277 No,
5278 Lr,
5279 Rf,
5280 Db,
5281 Sg,
5282 Bh,
5283 Hs,
5284 Mt,
5285 Uun,
5286 Uuu,
5287 Uub,
5288 Uuq,
5289 Uuh,
5290 Uuo
5291 };
5292
5293 ChemicalElementSymbol (value v);
5294
5295 ChemicalElementSymbol (const char* v);
5296
5297 ChemicalElementSymbol (const ::std::string& v);
5298
5299 ChemicalElementSymbol (const ::xml_schema::string& v);
5300
5301 ChemicalElementSymbol (const ::xercesc::DOMElement& e,
5302 ::xml_schema::flags f = 0,
5303 ::xml_schema::container* c = 0);
5304
5305 ChemicalElementSymbol (const ::xercesc::DOMAttr& a,
5306 ::xml_schema::flags f = 0,
5307 ::xml_schema::container* c = 0);
5308
5309 ChemicalElementSymbol (const ::std::string& s,
5310 const ::xercesc::DOMElement* e,
5311 ::xml_schema::flags f = 0,
5312 ::xml_schema::container* c = 0);
5313
5314 ChemicalElementSymbol (const ChemicalElementSymbol& x,
5315 ::xml_schema::flags f = 0,
5316 ::xml_schema::container* c = 0);
5317
5318 virtual ChemicalElementSymbol*
5319 _clone (::xml_schema::flags f = 0,
5320 ::xml_schema::container* c = 0) const;
5321
5322 ChemicalElementSymbol&
5323 operator= (value v);
5324
5325 virtual
5326 operator value () const
5327 {
5328 return _xsd_ChemicalElementSymbol_convert ();
5329 }
5330
5331 protected:
5332 value
5333 _xsd_ChemicalElementSymbol_convert () const;
5334
5335 public:
5336 static const char* const _xsd_ChemicalElementSymbol_literals_[115];
5337 static const value _xsd_ChemicalElementSymbol_indexes_[115];
5338};
5339
5340class CurrencyCode: public ::xml_schema::string
5341{
5342 public:
5343 enum value
5344 {
5345 AFA,
5346 ALL,
5347 AMD,
5348 ANG,
5349 AOA,
5350 ARS,
5351 ATS,
5352 AUD,
5353 AWG,
5354 AZM,
5355 BAM,
5356 BBD,
5357 BDT,
5358 BEF,
5359 BGL,
5360 BGN,
5361 BHD,
5362 BIF,
5363 BMD,
5364 BND,
5365 BOB,
5366 BOV,
5367 BRL,
5368 BSD,
5369 BTN,
5370 BWP,
5371 BYB,
5372 BYR,
5373 BZD,
5374 CAD,
5375 CDF,
5376 CHF,
5377 CLF,
5378 CLP,
5379 CNY,
5380 COP,
5381 CRC,
5382 CUP,
5383 CVE,
5384 CYP,
5385 CZK,
5386 DEM,
5387 DJF,
5388 DKK,
5389 DOP,
5390 DZD,
5391 EEK,
5392 EGP,
5393 ERN,
5394 ESP,
5395 ETB,
5396 EUR,
5397 FIM,
5398 FJD,
5399 FKP,
5400 FRF,
5401 GBP,
5402 GEL,
5403 GHC,
5404 GIP,
5405 GMD,
5406 GNF,
5407 GRD,
5408 GTQ,
5409 GWP,
5410 GYD,
5411 HKD,
5412 HNL,
5413 HRK,
5414 HTG,
5415 HUF,
5416 IDR,
5417 IEP,
5418 ILS,
5419 INR,
5420 IQD,
5421 IRR,
5422 ISK,
5423 ITL,
5424 JMD,
5425 JOD,
5426 JPY,
5427 KES,
5428 KGS,
5429 KHR,
5430 KMF,
5431 KPW,
5432 KRW,
5433 KWD,
5434 KYD,
5435 KZT,
5436 LAK,
5437 LBP,
5438 LKR,
5439 LRD,
5440 LSL,
5441 LTL,
5442 LUF,
5443 LVL,
5444 LYD,
5445 MAD,
5446 MDL,
5447 MGF,
5448 MKD,
5449 MMK,
5450 MNT,
5451 MOP,
5452 MRO,
5453 MTL,
5454 MUR,
5455 MVR,
5456 MWK,
5457 MXN,
5458 MXV,
5459 MYR,
5460 MZM,
5461 NAD,
5462 NGN,
5463 NIO,
5464 NLG,
5465 NOK,
5466 NPR,
5467 NZD,
5468 OMR,
5469 PAB,
5470 PEN,
5471 PGK,
5472 PHP,
5473 PKR,
5474 PLN,
5475 PTE,
5476 PYG,
5477 QAR,
5478 ROL,
5479 RUB,
5480 RUR,
5481 RWF,
5482 SAR,
5483 SBD,
5484 SCR,
5485 SDD,
5486 SEK,
5487 SGD,
5488 SHP,
5489 SIT,
5490 SKK,
5491 SLL,
5492 SOS,
5493 SRG,
5494 STD,
5495 SVC,
5496 SYP,
5497 SZL,
5498 THB,
5499 TJR,
5500 TMM,
5501 TND,
5502 TOP,
5503 TPE,
5504 TRL,
5505 TTD,
5506 TWD,
5507 TZS,
5508 UAH,
5509 UGX,
5510 USD,
5511 UYU,
5512 UZS,
5513 VEB,
5514 VND,
5515 VUV,
5516 WST,
5517 XAF,
5518 XCD,
5519 XDR,
5520 XOF,
5521 XPF,
5522 YER,
5523 YUM,
5524 ZAR,
5525 ZMK,
5526 ZWD
5527 };
5528
5529 CurrencyCode (value v);
5530
5531 CurrencyCode (const char* v);
5532
5533 CurrencyCode (const ::std::string& v);
5534
5535 CurrencyCode (const ::xml_schema::string& v);
5536
5537 CurrencyCode (const ::xercesc::DOMElement& e,
5538 ::xml_schema::flags f = 0,
5539 ::xml_schema::container* c = 0);
5540
5541 CurrencyCode (const ::xercesc::DOMAttr& a,
5542 ::xml_schema::flags f = 0,
5543 ::xml_schema::container* c = 0);
5544
5545 CurrencyCode (const ::std::string& s,
5546 const ::xercesc::DOMElement* e,
5547 ::xml_schema::flags f = 0,
5548 ::xml_schema::container* c = 0);
5549
5550 CurrencyCode (const CurrencyCode& x,
5551 ::xml_schema::flags f = 0,
5552 ::xml_schema::container* c = 0);
5553
5554 virtual CurrencyCode*
5555 _clone (::xml_schema::flags f = 0,
5556 ::xml_schema::container* c = 0) const;
5557
5558 CurrencyCode&
5559 operator= (value v);
5560
5561 virtual
5562 operator value () const
5563 {
5564 return _xsd_CurrencyCode_convert ();
5565 }
5566
5567 protected:
5568 value
5569 _xsd_CurrencyCode_convert () const;
5570
5571 public:
5572 static const char* const _xsd_CurrencyCode_literals_[182];
5573 static const value _xsd_CurrencyCode_indexes_[182];
5574};
5575
5576class MatML_Doc: public ::xml_schema::type
5577{
5578 public:
5579 // Material
5580 //
5581 typedef ::Material Material_type;
5582 typedef ::xsd::cxx::tree::sequence< Material_type > Material_sequence;
5583 typedef Material_sequence::iterator Material_iterator;
5584 typedef Material_sequence::const_iterator Material_const_iterator;
5585 typedef ::xsd::cxx::tree::traits< Material_type, char > Material_traits;
5586
5587 const Material_sequence&
5588 Material () const;
5589
5590 Material_sequence&
5591 Material ();
5592
5593 void
5594 Material (const Material_sequence& s);
5595
5596 // Metadata
5597 //
5598 typedef ::Metadata Metadata_type;
5599 typedef ::xsd::cxx::tree::optional< Metadata_type > Metadata_optional;
5600 typedef ::xsd::cxx::tree::traits< Metadata_type, char > Metadata_traits;
5601
5602 const Metadata_optional&
5603 Metadata () const;
5604
5605 Metadata_optional&
5606 Metadata ();
5607
5608 void
5609 Metadata (const Metadata_type& x);
5610
5611 void
5612 Metadata (const Metadata_optional& x);
5613
5614 void
5615 Metadata (::std::auto_ptr< Metadata_type > p);
5616
5617 // Constructors.
5618 //
5619 MatML_Doc ();
5620
5621 MatML_Doc (const ::xercesc::DOMElement& e,
5622 ::xml_schema::flags f = 0,
5623 ::xml_schema::container* c = 0);
5624
5625 MatML_Doc (const MatML_Doc& x,
5626 ::xml_schema::flags f = 0,
5627 ::xml_schema::container* c = 0);
5628
5629 virtual MatML_Doc*
5630 _clone (::xml_schema::flags f = 0,
5631 ::xml_schema::container* c = 0) const;
5632
5633 MatML_Doc&
5634 operator= (const MatML_Doc& x);
5635
5636 virtual
5637 ~MatML_Doc ();
5638
5639 // Implementation.
5640 //
5641 protected:
5642 void
5643 parse (::xsd::cxx::xml::dom::parser< char >&,
5644 ::xml_schema::flags);
5645
5646 protected:
5647 Material_sequence Material_;
5648 Metadata_optional Metadata_;
5649};
5650
5651class ParentMaterial: public ::xml_schema::type
5652{
5653 public:
5654 // id
5655 //
5656 typedef ::xml_schema::idref id_type;
5657 typedef ::xsd::cxx::tree::traits< id_type, char > id_traits;
5658
5659 const id_type&
5660 id () const;
5661
5662 id_type&
5663 id ();
5664
5665 void
5666 id (const id_type& x);
5667
5668 void
5669 id (::std::auto_ptr< id_type > p);
5670
5671 // Constructors.
5672 //
5673 ParentMaterial (const id_type&);
5674
5675 ParentMaterial (const ::xercesc::DOMElement& e,
5676 ::xml_schema::flags f = 0,
5677 ::xml_schema::container* c = 0);
5678
5679 ParentMaterial (const ParentMaterial& x,
5680 ::xml_schema::flags f = 0,
5681 ::xml_schema::container* c = 0);
5682
5683 virtual ParentMaterial*
5684 _clone (::xml_schema::flags f = 0,
5685 ::xml_schema::container* c = 0) const;
5686
5687 ParentMaterial&
5688 operator= (const ParentMaterial& x);
5689
5690 virtual
5691 ~ParentMaterial ();
5692
5693 // Implementation.
5694 //
5695 protected:
5696 void
5697 parse (::xsd::cxx::xml::dom::parser< char >&,
5698 ::xml_schema::flags);
5699
5700 protected:
5701 ::xsd::cxx::tree::one< id_type > id_;
5702};
5703
5704class Symbol: public ::ChemicalElementSymbol
5705{
5706 public:
5707 // subscript
5708 //
5709 typedef ::xml_schema::string subscript_type;
5710 typedef ::xsd::cxx::tree::traits< subscript_type, char > subscript_traits;
5711
5712 const subscript_type&
5713 subscript () const;
5714
5715 subscript_type&
5716 subscript ();
5717
5718 void
5719 subscript (const subscript_type& x);
5720
5721 void
5722 subscript (::std::auto_ptr< subscript_type > p);
5723
5724 static const subscript_type&
5725 subscript_default_value ();
5726
5727 // Constructors.
5728 //
5729 Symbol (::ChemicalElementSymbol::value);
5730
5731 Symbol (const char*);
5732
5733 Symbol (const ::std::string&);
5734
5735 Symbol (const ::ChemicalElementSymbol&);
5736
5737 Symbol (const ::xercesc::DOMElement& e,
5738 ::xml_schema::flags f = 0,
5739 ::xml_schema::container* c = 0);
5740
5741 Symbol (const Symbol& x,
5742 ::xml_schema::flags f = 0,
5743 ::xml_schema::container* c = 0);
5744
5745 virtual Symbol*
5746 _clone (::xml_schema::flags f = 0,
5747 ::xml_schema::container* c = 0) const;
5748
5749 Symbol&
5750 operator= (const Symbol& x);
5751
5752 virtual
5753 ~Symbol ();
5754
5755 // Implementation.
5756 //
5757 protected:
5758 void
5759 parse (::xsd::cxx::xml::dom::parser< char >&,
5760 ::xml_schema::flags);
5761
5762 protected:
5763 ::xsd::cxx::tree::one< subscript_type > subscript_;
5764 static const subscript_type subscript_default_value_;
5765};
5766
5767class Graph: public ::xml_schema::type
5768{
5769 public:
5770 // Constructors.
5771 //
5772 Graph ();
5773
5774 Graph (const ::xercesc::DOMElement& e,
5775 ::xml_schema::flags f = 0,
5776 ::xml_schema::container* c = 0);
5777
5778 Graph (const Graph& x,
5779 ::xml_schema::flags f = 0,
5780 ::xml_schema::container* c = 0);
5781
5782 virtual Graph*
5783 _clone (::xml_schema::flags f = 0,
5784 ::xml_schema::container* c = 0) const;
5785
5786 virtual
5787 ~Graph ();
5788
5789 // Implementation.
5790 //
5791 protected:
5792 void
5793 parse (::xsd::cxx::xml::dom::parser< char >&,
5794 ::xml_schema::flags);
5795
5796 protected:
5797};
5798
5799class Data: public ::xml_schema::string
5800{
5801 public:
5802 // format
5803 //
5804 typedef ::DataFormat format_type;
5805 typedef ::xsd::cxx::tree::optional< format_type > format_optional;
5806 typedef ::xsd::cxx::tree::traits< format_type, char > format_traits;
5807
5808 const format_optional&
5809 format () const;
5810
5811 format_optional&
5812 format ();
5813
5814 void
5815 format (const format_type& x);
5816
5817 void
5818 format (const format_optional& x);
5819
5820 void
5821 format (::std::auto_ptr< format_type > p);
5822
5823 // Constructors.
5824 //
5825 Data ();
5826
5827 Data (const char*);
5828
5829 Data (const ::std::string&);
5830
5831 Data (const ::xml_schema::string&);
5832
5833 Data (const ::xercesc::DOMElement& e,
5834 ::xml_schema::flags f = 0,
5835 ::xml_schema::container* c = 0);
5836
5837 Data (const Data& x,
5838 ::xml_schema::flags f = 0,
5839 ::xml_schema::container* c = 0);
5840
5841 virtual Data*
5842 _clone (::xml_schema::flags f = 0,
5843 ::xml_schema::container* c = 0) const;
5844
5845 Data&
5846 operator= (const Data& x);
5847
5848 virtual
5849 ~Data ();
5850
5851 // Implementation.
5852 //
5853 protected:
5854 void
5855 parse (::xsd::cxx::xml::dom::parser< char >&,
5856 ::xml_schema::flags);
5857
5858 protected:
5859 format_optional format_;
5860};
5861
5862class Data1: public ::xml_schema::string
5863{
5864 public:
5865 // format
5866 //
5867 typedef ::DataFormat format_type;
5868 typedef ::xsd::cxx::tree::traits< format_type, char > format_traits;
5869
5870 const format_type&
5871 format () const;
5872
5873 format_type&
5874 format ();
5875
5876 void
5877 format (const format_type& x);
5878
5879 void
5880 format (::std::auto_ptr< format_type > p);
5881
5882 // Constructors.
5883 //
5884 Data1 (const format_type&);
5885
5886 Data1 (const char*,
5887 const format_type&);
5888
5889 Data1 (const ::std::string&,
5890 const format_type&);
5891
5892 Data1 (const ::xml_schema::string&,
5893 const format_type&);
5894
5895 Data1 (const ::xercesc::DOMElement& e,
5896 ::xml_schema::flags f = 0,
5897 ::xml_schema::container* c = 0);
5898
5899 Data1 (const Data1& x,
5900 ::xml_schema::flags f = 0,
5901 ::xml_schema::container* c = 0);
5902
5903 virtual Data1*
5904 _clone (::xml_schema::flags f = 0,
5905 ::xml_schema::container* c = 0) const;
5906
5907 Data1&
5908 operator= (const Data1& x);
5909
5910 virtual
5911 ~Data1 ();
5912
5913 // Implementation.
5914 //
5915 protected:
5916 void
5917 parse (::xsd::cxx::xml::dom::parser< char >&,
5918 ::xml_schema::flags);
5919
5920 protected:
5921 ::xsd::cxx::tree::one< format_type > format_;
5922};
5923
5924class delimiter: public ::xml_schema::string
5925{
5926 public:
5927 // Constructors.
5928 //
5929 delimiter ();
5930
5931 delimiter (const char*);
5932
5933 delimiter (const ::std::string&);
5934
5935 delimiter (const ::xml_schema::string&);
5936
5937 delimiter (const ::xercesc::DOMElement& e,
5938 ::xml_schema::flags f = 0,
5939 ::xml_schema::container* c = 0);
5940
5941 delimiter (const ::xercesc::DOMAttr& a,
5942 ::xml_schema::flags f = 0,
5943 ::xml_schema::container* c = 0);
5944
5945 delimiter (const ::std::string& s,
5946 const ::xercesc::DOMElement* e,
5947 ::xml_schema::flags f = 0,
5948 ::xml_schema::container* c = 0);
5949
5950 delimiter (const delimiter& x,
5951 ::xml_schema::flags f = 0,
5952 ::xml_schema::container* c = 0);
5953
5954 virtual delimiter*
5955 _clone (::xml_schema::flags f = 0,
5956 ::xml_schema::container* c = 0) const;
5957
5958 virtual
5959 ~delimiter ();
5960};
5961
5962class Scale: public ::xml_schema::string
5963{
5964 public:
5965 enum value
5966 {
5967 Linear,
5968 Logarithmic
5969 };
5970
5971 Scale (value v);
5972
5973 Scale (const char* v);
5974
5975 Scale (const ::std::string& v);
5976
5977 Scale (const ::xml_schema::string& v);
5978
5979 Scale (const ::xercesc::DOMElement& e,
5980 ::xml_schema::flags f = 0,
5981 ::xml_schema::container* c = 0);
5982
5983 Scale (const ::xercesc::DOMAttr& a,
5984 ::xml_schema::flags f = 0,
5985 ::xml_schema::container* c = 0);
5986
5987 Scale (const ::std::string& s,
5988 const ::xercesc::DOMElement* e,
5989 ::xml_schema::flags f = 0,
5990 ::xml_schema::container* c = 0);
5991
5992 Scale (const Scale& x,
5993 ::xml_schema::flags f = 0,
5994 ::xml_schema::container* c = 0);
5995
5996 virtual Scale*
5997 _clone (::xml_schema::flags f = 0,
5998 ::xml_schema::container* c = 0) const;
5999
6000 Scale&
6001 operator= (value v);
6002
6003 virtual
6004 operator value () const
6005 {
6006 return _xsd_Scale_convert ();
6007 }
6008
6009 protected:
6010 value
6011 _xsd_Scale_convert () const;
6012
6013 public:
6014 static const char* const _xsd_Scale_literals_[2];
6015 static const value _xsd_Scale_indexes_[2];
6016};
6017
6018#include <iosfwd>
6019
6020::std::ostream&
6021operator<< (::std::ostream&, const Associate&);
6022
6023::std::ostream&
6024operator<< (::std::ostream&, const AssociationDetails&);
6025
6026::std::ostream&
6027operator<< (::std::ostream&, const BulkDetails&);
6028
6029::std::ostream&
6030operator<< (::std::ostream&, const Characterization&);
6031
6032::std::ostream&
6033operator<< (::std::ostream&, const ChemicalComposition&);
6034
6035::std::ostream&
6036operator<< (::std::ostream&, const Class&);
6037
6038::std::ostream&
6039operator<< (::std::ostream&, const ComponentDetails&);
6040
6041::std::ostream&
6042operator<< (::std::ostream&, const Compound&);
6043
6044::std::ostream&
6045operator<< (::std::ostream&, const Concentration&);
6046
6047::std::ostream&
6048operator<< (::std::ostream&, DataFormat::value);
6049
6050::std::ostream&
6051operator<< (::std::ostream&, const DataFormat&);
6052
6053::std::ostream&
6054operator<< (::std::ostream&, const DimensionalDetails&);
6055
6056::std::ostream&
6057operator<< (::std::ostream&, const Element&);
6058
6059::std::ostream&
6060operator<< (::std::ostream&, const Form&);
6061
6062::std::ostream&
6063operator<< (::std::ostream&, const Formula&);
6064
6065::std::ostream&
6066operator<< (::std::ostream&, const Geometry&);
6067
6068::std::ostream&
6069operator<< (::std::ostream&, const Glossary&);
6070
6071::std::ostream&
6072operator<< (::std::ostream&, const GlossaryTerm&);
6073
6074::std::ostream&
6075operator<< (::std::ostream&, const Graphs&);
6076
6077::std::ostream&
6078operator<< (::std::ostream&, const Material&);
6079
6080::std::ostream&
6081operator<< (::std::ostream&, const Metadata&);
6082
6083::std::ostream&
6084operator<< (::std::ostream&, const Name&);
6085
6086::std::ostream&
6087operator<< (::std::ostream&, const Notes&);
6088
6089::std::ostream&
6090operator<< (::std::ostream&, const ParameterValue&);
6091
6092::std::ostream&
6093operator<< (::std::ostream&, const PhaseComposition&);
6094
6095::std::ostream&
6096operator<< (::std::ostream&, const ProcessingDetails&);
6097
6098::std::ostream&
6099operator<< (::std::ostream&, const PropertyData&);
6100
6101::std::ostream&
6102operator<< (::std::ostream&, const Qualifier&);
6103
6104::std::ostream&
6105operator<< (::std::ostream&, const Relationship&);
6106
6107::std::ostream&
6108operator<< (::std::ostream&, const Source&);
6109
6110::std::ostream&
6111operator<< (::std::ostream&, const Specification&);
6112
6113::std::ostream&
6114operator<< (::std::ostream&, const Uncertainty&);
6115
6116::std::ostream&
6117operator<< (::std::ostream&, const Unit&);
6118
6119::std::ostream&
6120operator<< (::std::ostream&, const Unitless&);
6121
6122::std::ostream&
6123operator<< (::std::ostream&, const Units&);
6124
6125::std::ostream&
6126operator<< (::std::ostream&, const Value&);
6127
6128::std::ostream&
6129operator<< (::std::ostream&, const AuthorityDetails&);
6130
6131::std::ostream&
6132operator<< (::std::ostream&, const DataSourceDetails&);
6133
6134::std::ostream&
6135operator<< (::std::ostream&, const MeasurementTechniqueDetails&);
6136
6137::std::ostream&
6138operator<< (::std::ostream&, const ParameterDetails&);
6139
6140::std::ostream&
6141operator<< (::std::ostream&, const PropertyDetails&);
6142
6143::std::ostream&
6144operator<< (::std::ostream&, const SourceDetails&);
6145
6146::std::ostream&
6147operator<< (::std::ostream&, const SpecimenDetails&);
6148
6149::std::ostream&
6150operator<< (::std::ostream&, const TestConditionDetails&);
6151
6152::std::ostream&
6153operator<< (::std::ostream&, ChemicalElementSymbol::value);
6154
6155::std::ostream&
6156operator<< (::std::ostream&, const ChemicalElementSymbol&);
6157
6158::std::ostream&
6159operator<< (::std::ostream&, CurrencyCode::value);
6160
6161::std::ostream&
6162operator<< (::std::ostream&, const CurrencyCode&);
6163
6164::std::ostream&
6165operator<< (::std::ostream&, const MatML_Doc&);
6166
6167::std::ostream&
6168operator<< (::std::ostream&, const ParentMaterial&);
6169
6170::std::ostream&
6171operator<< (::std::ostream&, const Symbol&);
6172
6173::std::ostream&
6174operator<< (::std::ostream&, const Graph&);
6175
6176::std::ostream&
6177operator<< (::std::ostream&, const Data&);
6178
6179::std::ostream&
6180operator<< (::std::ostream&, const Data1&);
6181
6182::std::ostream&
6183operator<< (::std::ostream&, const delimiter&);
6184
6185::std::ostream&
6186operator<< (::std::ostream&, Scale::value);
6187
6188::std::ostream&
6189operator<< (::std::ostream&, const Scale&);
6190
6191#include <iosfwd>
6192
6193#include <xercesc/sax/InputSource.hpp>
6194#include <xercesc/dom/DOMDocument.hpp>
6195#include <xercesc/dom/DOMErrorHandler.hpp>
6196
6197// Parse a URI or a local file.
6198//
6199
6200::std::auto_ptr< ::MatML_Doc >
6201MatML_Doc_ (const ::std::string& uri,
6202 ::xml_schema::flags f = 0,
6203 const ::xml_schema::properties& p = ::xml_schema::properties ());
6204
6205::std::auto_ptr< ::MatML_Doc >
6206MatML_Doc_ (const ::std::string& uri,
6207 ::xml_schema::error_handler& eh,
6208 ::xml_schema::flags f = 0,
6209 const ::xml_schema::properties& p = ::xml_schema::properties ());
6210
6211::std::auto_ptr< ::MatML_Doc >
6212MatML_Doc_ (const ::std::string& uri,
6213 ::xercesc::DOMErrorHandler& eh,
6214 ::xml_schema::flags f = 0,
6215 const ::xml_schema::properties& p = ::xml_schema::properties ());
6216
6217// Parse std::istream.
6218//
6219
6220::std::auto_ptr< ::MatML_Doc >
6221MatML_Doc_ (::std::istream& is,
6222 ::xml_schema::flags f = 0,
6223 const ::xml_schema::properties& p = ::xml_schema::properties ());
6224
6225::std::auto_ptr< ::MatML_Doc >
6226MatML_Doc_ (::std::istream& is,
6227 ::xml_schema::error_handler& eh,
6228 ::xml_schema::flags f = 0,
6229 const ::xml_schema::properties& p = ::xml_schema::properties ());
6230
6231::std::auto_ptr< ::MatML_Doc >
6232MatML_Doc_ (::std::istream& is,
6233 ::xercesc::DOMErrorHandler& eh,
6234 ::xml_schema::flags f = 0,
6235 const ::xml_schema::properties& p = ::xml_schema::properties ());
6236
6237::std::auto_ptr< ::MatML_Doc >
6238MatML_Doc_ (::std::istream& is,
6239 const ::std::string& id,
6240 ::xml_schema::flags f = 0,
6241 const ::xml_schema::properties& p = ::xml_schema::properties ());
6242
6243::std::auto_ptr< ::MatML_Doc >
6244MatML_Doc_ (::std::istream& is,
6245 const ::std::string& id,
6246 ::xml_schema::error_handler& eh,
6247 ::xml_schema::flags f = 0,
6248 const ::xml_schema::properties& p = ::xml_schema::properties ());
6249
6250::std::auto_ptr< ::MatML_Doc >
6251MatML_Doc_ (::std::istream& is,
6252 const ::std::string& id,
6253 ::xercesc::DOMErrorHandler& eh,
6254 ::xml_schema::flags f = 0,
6255 const ::xml_schema::properties& p = ::xml_schema::properties ());
6256
6257// Parse xercesc::InputSource.
6258//
6259
6260::std::auto_ptr< ::MatML_Doc >
6261MatML_Doc_ (::xercesc::InputSource& is,
6262 ::xml_schema::flags f = 0,
6263 const ::xml_schema::properties& p = ::xml_schema::properties ());
6264
6265::std::auto_ptr< ::MatML_Doc >
6266MatML_Doc_ (::xercesc::InputSource& is,
6267 ::xml_schema::error_handler& eh,
6268 ::xml_schema::flags f = 0,
6269 const ::xml_schema::properties& p = ::xml_schema::properties ());
6270
6271::std::auto_ptr< ::MatML_Doc >
6272MatML_Doc_ (::xercesc::InputSource& is,
6273 ::xercesc::DOMErrorHandler& eh,
6274 ::xml_schema::flags f = 0,
6275 const ::xml_schema::properties& p = ::xml_schema::properties ());
6276
6277// Parse xercesc::DOMDocument.
6278//
6279
6280::std::auto_ptr< ::MatML_Doc >
6281MatML_Doc_ (const ::xercesc::DOMDocument& d,
6282 ::xml_schema::flags f = 0,
6283 const ::xml_schema::properties& p = ::xml_schema::properties ());
6284
6285::std::auto_ptr< ::MatML_Doc >
6286MatML_Doc_ (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d,
6287 ::xml_schema::flags f = 0,
6288 const ::xml_schema::properties& p = ::xml_schema::properties ());
6289
6290#include <iosfwd>
6291
6292#include <xercesc/dom/DOMDocument.hpp>
6293#include <xercesc/dom/DOMErrorHandler.hpp>
6294#include <xercesc/framework/XMLFormatter.hpp>
6295
6296#include <xsd/cxx/xml/dom/auto-ptr.hxx>
6297
6298// Serialize to std::ostream.
6299//
6300
6301void
6302MatML_Doc_ (::std::ostream& os,
6303 const ::MatML_Doc& x,
6304 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6305 const ::std::string& e = "UTF-8",
6306 ::xml_schema::flags f = 0);
6307
6308void
6309MatML_Doc_ (::std::ostream& os,
6310 const ::MatML_Doc& x,
6311 ::xml_schema::error_handler& eh,
6312 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6313 const ::std::string& e = "UTF-8",
6314 ::xml_schema::flags f = 0);
6315
6316void
6317MatML_Doc_ (::std::ostream& os,
6318 const ::MatML_Doc& x,
6319 ::xercesc::DOMErrorHandler& eh,
6320 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6321 const ::std::string& e = "UTF-8",
6322 ::xml_schema::flags f = 0);
6323
6324// Serialize to xercesc::XMLFormatTarget.
6325//
6326
6327void
6328MatML_Doc_ (::xercesc::XMLFormatTarget& ft,
6329 const ::MatML_Doc& x,
6330 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6331 const ::std::string& e = "UTF-8",
6332 ::xml_schema::flags f = 0);
6333
6334void
6335MatML_Doc_ (::xercesc::XMLFormatTarget& ft,
6336 const ::MatML_Doc& x,
6337 ::xml_schema::error_handler& eh,
6338 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6339 const ::std::string& e = "UTF-8",
6340 ::xml_schema::flags f = 0);
6341
6342void
6343MatML_Doc_ (::xercesc::XMLFormatTarget& ft,
6344 const ::MatML_Doc& x,
6345 ::xercesc::DOMErrorHandler& eh,
6346 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6347 const ::std::string& e = "UTF-8",
6348 ::xml_schema::flags f = 0);
6349
6350// Serialize to an existing xercesc::DOMDocument.
6351//
6352
6353void
6354MatML_Doc_ (::xercesc::DOMDocument& d,
6355 const ::MatML_Doc& x,
6356 ::xml_schema::flags f = 0);
6357
6358// Serialize to a new xercesc::DOMDocument.
6359//
6360
6361::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >
6362MatML_Doc_ (const ::MatML_Doc& x,
6363 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
6364 ::xml_schema::flags f = 0);
6365
6366void
6367operator<< (::xercesc::DOMElement&, const Associate&);
6368
6369void
6370operator<< (::xercesc::DOMAttr&, const Associate&);
6371
6372void
6373operator<< (::xml_schema::list_stream&,
6374 const Associate&);
6375
6376void
6377operator<< (::xercesc::DOMElement&, const AssociationDetails&);
6378
6379void
6380operator<< (::xercesc::DOMElement&, const BulkDetails&);
6381
6382void
6383operator<< (::xercesc::DOMElement&, const Characterization&);
6384
6385void
6386operator<< (::xercesc::DOMElement&, const ChemicalComposition&);
6387
6388void
6389operator<< (::xercesc::DOMElement&, const Class&);
6390
6391void
6392operator<< (::xercesc::DOMElement&, const ComponentDetails&);
6393
6394void
6395operator<< (::xercesc::DOMElement&, const Compound&);
6396
6397void
6398operator<< (::xercesc::DOMElement&, const Concentration&);
6399
6400void
6401operator<< (::xercesc::DOMElement&, const DataFormat&);
6402
6403void
6404operator<< (::xercesc::DOMAttr&, const DataFormat&);
6405
6406void
6407operator<< (::xml_schema::list_stream&,
6408 const DataFormat&);
6409
6410void
6411operator<< (::xercesc::DOMElement&, const DimensionalDetails&);
6412
6413void
6414operator<< (::xercesc::DOMElement&, const Element&);
6415
6416void
6417operator<< (::xercesc::DOMElement&, const Form&);
6418
6419void
6420operator<< (::xercesc::DOMElement&, const Formula&);
6421
6422void
6423operator<< (::xercesc::DOMAttr&, const Formula&);
6424
6425void
6426operator<< (::xml_schema::list_stream&,
6427 const Formula&);
6428
6429void
6430operator<< (::xercesc::DOMElement&, const Geometry&);
6431
6432void
6433operator<< (::xercesc::DOMElement&, const Glossary&);
6434
6435void
6436operator<< (::xercesc::DOMElement&, const GlossaryTerm&);
6437
6438void
6439operator<< (::xercesc::DOMElement&, const Graphs&);
6440
6441void
6442operator<< (::xercesc::DOMElement&, const Material&);
6443
6444void
6445operator<< (::xercesc::DOMElement&, const Metadata&);
6446
6447void
6448operator<< (::xercesc::DOMElement&, const Name&);
6449
6450void
6451operator<< (::xercesc::DOMElement&, const Notes&);
6452
6453void
6454operator<< (::xercesc::DOMAttr&, const Notes&);
6455
6456void
6457operator<< (::xml_schema::list_stream&,
6458 const Notes&);
6459
6460void
6461operator<< (::xercesc::DOMElement&, const ParameterValue&);
6462
6463void
6464operator<< (::xercesc::DOMElement&, const PhaseComposition&);
6465
6466void
6467operator<< (::xercesc::DOMElement&, const ProcessingDetails&);
6468
6469void
6470operator<< (::xercesc::DOMElement&, const PropertyData&);
6471
6472void
6473operator<< (::xercesc::DOMElement&, const Qualifier&);
6474
6475void
6476operator<< (::xercesc::DOMAttr&, const Qualifier&);
6477
6478void
6479operator<< (::xml_schema::list_stream&,
6480 const Qualifier&);
6481
6482void
6483operator<< (::xercesc::DOMElement&, const Relationship&);
6484
6485void
6486operator<< (::xercesc::DOMAttr&, const Relationship&);
6487
6488void
6489operator<< (::xml_schema::list_stream&,
6490 const Relationship&);
6491
6492void
6493operator<< (::xercesc::DOMElement&, const Source&);
6494
6495void
6496operator<< (::xercesc::DOMElement&, const Specification&);
6497
6498void
6499operator<< (::xercesc::DOMElement&, const Uncertainty&);
6500
6501void
6502operator<< (::xercesc::DOMElement&, const Unit&);
6503
6504void
6505operator<< (::xercesc::DOMElement&, const Unitless&);
6506
6507void
6508operator<< (::xercesc::DOMAttr&, const Unitless&);
6509
6510void
6511operator<< (::xml_schema::list_stream&,
6512 const Unitless&);
6513
6514void
6515operator<< (::xercesc::DOMElement&, const Units&);
6516
6517void
6518operator<< (::xercesc::DOMElement&, const Value&);
6519
6520void
6521operator<< (::xercesc::DOMElement&, const AuthorityDetails&);
6522
6523void
6524operator<< (::xercesc::DOMElement&, const DataSourceDetails&);
6525
6526void
6527operator<< (::xercesc::DOMElement&, const MeasurementTechniqueDetails&);
6528
6529void
6530operator<< (::xercesc::DOMElement&, const ParameterDetails&);
6531
6532void
6533operator<< (::xercesc::DOMElement&, const PropertyDetails&);
6534
6535void
6536operator<< (::xercesc::DOMElement&, const SourceDetails&);
6537
6538void
6539operator<< (::xercesc::DOMElement&, const SpecimenDetails&);
6540
6541void
6542operator<< (::xercesc::DOMElement&, const TestConditionDetails&);
6543
6544void
6545operator<< (::xercesc::DOMElement&, const ChemicalElementSymbol&);
6546
6547void
6548operator<< (::xercesc::DOMAttr&, const ChemicalElementSymbol&);
6549
6550void
6551operator<< (::xml_schema::list_stream&,
6552 const ChemicalElementSymbol&);
6553
6554void
6555operator<< (::xercesc::DOMElement&, const CurrencyCode&);
6556
6557void
6558operator<< (::xercesc::DOMAttr&, const CurrencyCode&);
6559
6560void
6561operator<< (::xml_schema::list_stream&,
6562 const CurrencyCode&);
6563
6564void
6565operator<< (::xercesc::DOMElement&, const MatML_Doc&);
6566
6567void
6568operator<< (::xercesc::DOMElement&, const ParentMaterial&);
6569
6570void
6571operator<< (::xercesc::DOMElement&, const Symbol&);
6572
6573void
6574operator<< (::xercesc::DOMElement&, const Graph&);
6575
6576void
6577operator<< (::xercesc::DOMElement&, const Data&);
6578
6579void
6580operator<< (::xercesc::DOMElement&, const Data1&);
6581
6582void
6583operator<< (::xercesc::DOMElement&, const delimiter&);
6584
6585void
6586operator<< (::xercesc::DOMAttr&, const delimiter&);
6587
6588void
6589operator<< (::xml_schema::list_stream&,
6590 const delimiter&);
6591
6592void
6593operator<< (::xercesc::DOMElement&, const Scale&);
6594
6595void
6596operator<< (::xercesc::DOMAttr&, const Scale&);
6597
6598void
6599operator<< (::xml_schema::list_stream&,
6600 const Scale&);
6601
6602#include <xsd/cxx/post.hxx>
6603
6604// Begin epilogue.
6605//
6606//
6607// End epilogue.
6608
6609#endif // MATML31_HXX
Associate
Definition: matml31.hxx:321
AssociationDetails
Definition: matml31.hxx:359
AuthorityDetails
Definition: matml31.hxx:4202
BulkDetails
Definition: matml31.hxx:460
Characterization
Definition: matml31.hxx:693
ChemicalComposition
Definition: matml31.hxx:826
ChemicalElementSymbol
Definition: matml31.hxx:5172
Class
Definition: matml31.hxx:897
ComponentDetails
Definition: matml31.hxx:990
Compound
Definition: matml31.hxx:1259
Concentration
Definition: matml31.hxx:1356
CurrencyCode
Definition: matml31.hxx:5341
Data1
Definition: matml31.hxx:5863
DataFormat
Definition: matml31.hxx:1489
Data
Definition: matml31.hxx:5800
DataSourceDetails
Definition: matml31.hxx:4299
DimensionalDetails
Definition: matml31.hxx:1548
Element
Definition: matml31.hxx:1705
Form
Definition: matml31.hxx:1804
Formula
Definition: matml31.hxx:1903
Geometry
Definition: matml31.hxx:1941
Glossary
Definition: matml31.hxx:2060
GlossaryTerm
Definition: matml31.hxx:2113
Graph
Definition: matml31.hxx:5768
Graphs
Definition: matml31.hxx:2246
MatML_Doc
Definition: matml31.hxx:5577
Material
Definition: matml31.hxx:2299
MeasurementTechniqueDetails
Definition: matml31.hxx:4418
Metadata
Definition: matml31.hxx:2479
Name
Definition: matml31.hxx:2658
Notes
Definition: matml31.hxx:2721
ParameterDetails
Definition: matml31.hxx:4515
ParameterValue
Definition: matml31.hxx:2759
ParentMaterial
Definition: matml31.hxx:5652
PhaseComposition
Definition: matml31.hxx:2912
ProcessingDetails
Definition: matml31.hxx:3029
PropertyData
Definition: matml31.hxx:3146
PropertyDetails
Definition: matml31.hxx:4656
Qualifier
Definition: matml31.hxx:3429
Relationship
Definition: matml31.hxx:3467
Scale
Definition: matml31.hxx:5963
SourceDetails
Definition: matml31.hxx:4819
Source
Definition: matml31.hxx:3505
Specification
Definition: matml31.hxx:3562
SpecimenDetails
Definition: matml31.hxx:4938
Symbol
Definition: matml31.hxx:5705
TestConditionDetails
Definition: matml31.hxx:5079
Uncertainty
Definition: matml31.hxx:3625
Unit
Definition: matml31.hxx:3850
Unitless
Definition: matml31.hxx:3970
Units
Definition: matml31.hxx:4002
Value
Definition: matml31.hxx:4140
delimiter
Definition: matml31.hxx:5925
Generated by doxygen 1.9.3