Oracle8i XML Reference Guide Release 3 (8.1.7) Part Number A83730-01 |
|
This chapter details the XML Class Generator for C++ and how it defines each element. It contains:
Document Type Defintiions
XML Documents with DTD
C++ Source files
Sample/Example Usage
Class: XMLClass Generator
Class: generated
The XML Class Generator takes a Document Type Definition (DTD) and
generates classes for each defined element. Those classes are then used
in a C++ program to construct XML documents conforming to the DTD.
Supported operating systems are Solaris 2.6, Linux 2.2, and NT 4 (Service
Pack 3 and above).
Input is an XML document containing a DTD. The document body itself is
ignored; only the DTD is relevant, though the dummy document must conform
to the DTD. The underlying XML parser only accepts file names for the
document and associated external entities. In future releases, no dummy
document will be required, and URIs for additional protocols will be accepted.
The following input file encodings are supported:
UTF-8, UTF-16, US-ASCII, ISO-10646-UCS-2, ISO-8859-1, ISO-8859-2, ISO-8859-3, ISO-8859-4, ISO-8859-5, ISO-8859-6, ISO-8859-7, ISO-8859-8, ISO-8859-9, EUC-JP, SHIFT_JIS, BIG5, GB2312, KOI8-R, EBCDIC-CP-US, EBCDIC-CP-CA, EBCDIC-CP-NL, EBCDIC-CP-WT, EBCDIC-CP-DK, EBCDIC-CP-NO, EBCDIC-CP-FI, EBCDIC-CP-SE, EBCDIC-CP-IT, EBCDIC-CP-ES, EBCDIC-CP-GB, EBCDIC-CP-FR, EBCDIC-CP-HE, EBCDIC-CP-BE, EBCDIC-CP-CH, EBCDIC-CP-ROECE, EBCDIC-CP-YU, and EBCDIC-CP-IS.
In addition, any character set specified in Appendix A, Character Sets,
of the Oracle National Language Support Guide may be used.
The default encoding is UTF-8. It is recommended that you set
the default encoding explicitly if using only single byte character sets
(such as US-ASCII or any of the ISO-8859 character sets) for performance
up to 25% faster than with multibyte character sets such as UTF-8.
Output is a pair of C++ source files, .cpp and .h, named after the DTD.
Constructors are provided for each class (element) that allow an object to
be created in two different ways: initially empty, then adding the children
or data after the initial creation, or created with the initial full set of
children or initial data. A method is provided for #PCDATA (and Mixed)
elements to set the data and, when appropriate, set an element's attributes.
The W3C recommendation for Extensible Markup Language (XML) 1.0
The W3C recommendation for Document Object Model Level 1 1.0
The W3C proposed recommendation for Namespaces in XML
The Simple API for XML (SAX) 1.0
The standalone parser may be called as an executable by invoking
bin/xmlcg like xmlcg [flags] <XML document>
where the optional flags are as follows:
-d directory Specify output directory (default is current directory)
-e
encoding
Specify default input file encoding
-h help
show this usage help
Class: XMLClassGeneratorThis class contain the method for generating classes based on a DTD.
generate |
Generate classes |
Generates classes for the given DTD. Two files are created in the output directory outdir (or in the currect directory if outdir is NULL): DTDname.h and DTDname.cpp, both named after the DTD. One class is generated for each defined element in the DTD.
uword generate(DocumentType *dtd, char *outdir)Arguments:
dtd -- DTD whose elements to generate classes for
outdir -- directory in which to place output files
Returns:uword -- error code, 0 on success
Class: generated
A generated class is produced for each element defined in the DTD. It has the same name as the element.
Constructors are provided which create an empty element, or make it with an initial set of children or data. Methods are provided to add children or data after construction, and to set attributes. There are two styles of creation: make an empty element, then add the children one at a time, or construct the element with initial data or children. For example, given the element declaration
<!ELEMENT B (#PCDATA | F)*>
The following constructors will be provided:
B(Document *doc);
B(Document *doc, String data);
B(Document *doc, F *theF);
The first constructor just makes an empty element with no children. The second initializes it with PCDATA, and the third with a single child node of element F. An element like B which may contain PCDATA is also given a method to add the data post-construction:
void addData(Document *doc, String data);
The following usages are equivalent:
b = new B("data");
and
b = new B();
b->addData("data");
Similarly, the following are also equivalent:
f = new F(...);
b = new B(f);
and
f = new F(...);
b = new B();
b->addNode(f);
The presense of modifiers '?' (optional), '*' (zero or more), and '+' (one or more) is ignored when forming the constructors. For example, for the element
<!ELEMENT Sample (A* | (B, (C? | (D, E)*)) | F)+>
the following constructors are made:
Sample(Document *doc);
Sample(Document *doc, A *theA);
Sample(Document *doc, B *theB, C *theC);
Sample(Document *doc, B *theB, D *theD, E *theE);
Sample(Document *doc, F *theF);
as if the modifiers were not present. If you cannot make the desired final element using one of the forms which take initial children, you must start with the empty element and add nodes as needed with addNode as above.
For each attribute for an element, a method is provided to set its value, named setattrname. For example, for the element declaration
<!ELEMENT D (#PCDATA)> <!ATTLIST D foo CDATA #REQUIRED>
the class D will have the method
Attr* setfoo(String value);
Note: The constructed element is not tested for validity as it is being made. The user to explicitly call the XMLParser's validate method on the final element.
Constructors |
Constructors for the class |
addData |
Adds PCDATA to the element |
addNode |
Adds a node to the element |
setattribute |
Sets one of the element's attributes |
Constructs an element which will belong to the given document. The first form makes the element with no children (use addData and addNode as appropriate to fill it out). The second variable form is used to provide initial data or children, the exact choices of which depend on the element definition. See the example at the beginning of this document.
class(Document *doc) class(Document *doc, ...)
doc -- document which the element belongs to
... -- varying arguments depending on the element definition
none
Adds data to the element. That is, appends to it a PCDATA subnode with the given value. If multiple addData calls are made, the node will have multiple PCDATA subnodes, which should be normalized when construction is finished.
void addData(Document *doc, String data)
doc -- document which the element belongs to
data -- data to be added
none
Adds (append) a child node to the element. No effort is made to validate the resulting element structure at this time; it is the user's responsibility to form the element properly, which may be verified with XMLParser::validate.
void addNode(node thenode)
the node -- node to be added
none
Sets the element's attribute with the given value. One method is provided for each attribute, named after the attribute as setattribute.
Attr* setattribute(String value)
value -- the attribute's value
Attr* -- the created attribute
|
![]() Copyright © 1996-2000, Oracle Corporation. All Rights Reserved. |
|