C++/Tree Mapping

one · touch-up

+<?xml version="1.0"?>
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+  
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+    <xs:sequence>
+      <xs:element name="greeting" type="xs:string"/>
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t"/>
+
+</xs:schema>
+  
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+      
+$ xsd cxx-tree hello.xsd
+  
+class hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::string greeting_type;
+
+  const greeting_type&
+  greeting () const;
+
+  greeting_type&
+  greeting ();
+
+  void
+  greeting (const greeting_type& x);
+
+  // name
+  //
+  typedef xml_schema::string name_type;
+  typedef xsd::sequence<name_type> name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&
+  name () const;
+
+  name_sequence&
+  name ();
+
+  void
+  name (const name_sequence& s);
+
+  // Constructor.
+  //
+  hello_t (const greeting_type&);
+
+  ...
+
+};
+
+std::auto_ptr<hello_t>
+hello (const std::string& uri);
+
+std::auto_ptr<hello_t>
+hello (std::istream&);
+  
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    auto_ptr<hello_t> h (hello (argv[1]));
+
+    for (hello_t::name_const_iterator i (h->name ().begin ());
+         i != h->name ().end ();
+         ++i)
+    {
+      cerr << h->greeting () << ", " << *i << "!" << endl;
+    }
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+  
+$ c++ -I.../libxsd -c driver.cxx hello.cxx
+$ c++ -o driver driver.o hello.o -lxerces-c
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+  
+$ xsd cxx-tree --generate-serialization hello.xsd
+  
+void
+hello (std::ostream&,
+       const hello_t&,
+       const xml_schema::namespace_infomap& =
+         xml_schema::namespace_infomap ());
+
+  
+#include <iostream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    auto_ptr<hello_t> h (hello (argv[1]));
+
+    // Change the greeting phrase.
+    //
+    h->greeting ("Hi");
+
+    // Add another entry to the name sequence.
+    //
+    h->name ().push_back ("mars");
+
+    // Serialize the modified object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    hello (cout, *h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+  
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+  <name>mars</name>
+
+</hello>
+  
+#include <iostream>
+#include <fstream>
+#include "hello.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello_t h ("Hi");
+
+    hello_t::name_sequence& ns (h.name ());
+
+    ns.push_back ("Jane");
+    ns.push_back ("John");
+
+    // Serialize the object model to XML.
+    //
+    xml_schema::namespace_infomap map;
+    map[""].name = "";
+    map[""].schema = "hello.xsd";
+
+    std::ofstream ofs (argv[1]);
+    hello (ofs, h, map);
+  }
+  catch (const xml_schema::exception& e)
+  {
+    cerr << e << endl;
+    return 1;
+  }
+}
+  
+<?xml version="1.0"?>
+<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="hello.xsd">
+
+  <greeting>Hi</greeting>
+
+  <name>Jane</name>
+  <name>John</name>
+
+</hello>
+  
+$ xsd cxx-tree --type-naming ucc hello.xsd
+  
+class Hello_t
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello_t (const GreetingType&);
+
+  ...
+
+};
+
+std::auto_ptr<Hello_t>
+hello (const std::string& uri);
+
+std::auto_ptr<Hello_t>
+hello (std::istream&);
+  
+$ xsd cxx-tree --type-naming ucc --type-regex '/ (.+)_t/\u$1/' hello.xsd
+  
+class Hello
+{
+public:
+  // greeting
+  //
+  typedef xml_schema::String GreetingType;
+
+  const GreetingType&
+  greeting () const;
+
+  GreetingType&
+  greeting ();
+
+  void
+  greeting (const GreetingType& x);
+
+  // name
+  //
+  typedef xml_schema::String NameType;
+  typedef xsd::sequence<NameType> NameSequence;
+  typedef NameSequence::iterator NameIterator;
+  typedef NameSequence::const_iterator NameConstIterator;
+
+  const NameSequence&
+  name () const;
+
+  NameSequence&
+  name ();
+
+  void
+  name (const NameSequence& s);
+
+  // Constructor.
+  //
+  Hello (const GreetingType&);
+
+  ...
+
+};
+
+std::auto_ptr<Hello>
+hello (const std::string& uri);
+
+std::auto_ptr<Hello>
+hello (std::istream&);
+  
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello_t">
+
+    <xs:annotation>
+      <xs:documentation>
+        The hello_t type consists of a greeting phrase and a
+        collection of names to which this greeting applies.
+      </xs:documentation>
+    </xs:annotation>
+
+    <xs:sequence>
+
+      <xs:element name="greeting" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>
+            The greeting element contains the greeting phrase
+            for this hello object.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+      <xs:element name="name" type="xs:string" maxOccurs="unbounded">
+        <xs:annotation>
+          <xs:documentation>
+            The name elements contains names to be greeted.
+          </xs:documentation>
+        </xs:annotation>
+      </xs:element>
+
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="hello" type="hello_t">
+    <xs:annotation>
+      <xs:documentation>
+        The hello element is a root of the Hello XML vocabulary.
+        Every conforming document should start with this element.
+      </xs:documentation>
+    </xs:annotation>
+  </xs:element>
+
+</xs:schema>
+  
+$ xsd cxx-tree --generate-serialization --generate-doxygen hello.xsd
+  
+$ doxygen -g hello.doxygen
+  
+$ doxygen hello.doxygen
+  
+--namespace-map http://www.codesynthesis.com/my=cs::my
+  
+--namespace-map =cs
+  
+#include <xercesc/util/PlatformUtils.hpp>
+
+int
+main ()
+{
+  xercesc::XMLPlatformUtils::Initialize ();
+
+  {
+    // Start/terminate threads and parse/serialize here.
+  }
+
+  xercesc::XMLPlatformUtils::Terminate ();
+}
+  
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender_t">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person_t">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="middle-name" type="xs:string" minOccurs="0"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender_t"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+    <xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="people_t">
+    <xs:sequence>
+      <xs:element name="person" type="person_t" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people_t"/>
+
+</xs:schema>
+  
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+  
+class gender_t: public xml_schema::string
+{
+public:
+  enum value
+  {
+    male,
+    female
+  };
+
+  gender_t (value);
+  gender_t (const xml_schema::string&);
+
+  gender_t&
+  operator= (value);
+
+  operator value () const;
+};
+  
+gender_t m (gender_t::male);
+gender_t f ("female");
+
+if (m == "female" || f == gender_t::male)
+{
+  ...
+}
+
+switch (m)
+{
+case gender_t::male:
+  {
+    ...
+  }
+case gender_t::female:
+  {
+    ...
+  }
+}
+  
+class person_t
+{
+  // gender
+  //
+  typedef gender_t gender_type;
+
+  const gender_type&
+  gender () const;
+
+  gender_type&
+  gender ();
+
+  void
+  gender (const gender_type&);
+};
+  
+class person_t
+{
+  // middle-name
+  //
+  typedef xml_schema::string middle_name_type;
+  typedef xsd::optional<middle_name_type> middle_name_optional;
+
+  const middle_name_optional&
+  middle_name () const;
+
+  middle_name_optional&
+  middle_name ();
+
+  void
+  middle_name (const middle_name_type&);
+
+  void
+  middle_name (const middle_name_optional&);
+};
+  
+person_t::middle_name_optional n ("John");
+
+if (n.present ())
+{
+  cout << n.get () << endl;
+}
+
+n.set ("Jane");
+n.reset ();
+  
+class people_t
+{
+  // person
+  //
+  typedef person_t person_type;
+  typedef xsd::sequence<person_type> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+
+  void
+  person (const person_sequence&);
+};
+  
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  auto_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    person_t& p (*i);
+
+    // Print names: first-name and last-name are required elements,
+    // middle-name is optional.
+    //
+    cout << "name:   " << p.first_name () << " ";
+
+    if (p.middle_name ().present ())
+      cout << p.middle_name ().get () << " ";
+
+    cout << p.last_name () << endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout << "gender: " << p.gender () << endl
+         << "age:    " << p.age () << endl
+         << "id:     " << p.id () << endl
+         << endl;
+  }
+}
+  
+name:   John Doe
+gender: male
+age:    32
+id:     1
+
+name:   Jane Mary Doe
+gender: female
+age:    28
+id:     2
+  
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  auto_ptr<people_t> ppl (people ("people.xml"));
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people_t::person_sequence& ps (ppl->person ());
+
+  for (people_t::person_iterator i (ps.begin ()); i != ps.end (); ++i)
+  {
+    // Alternative way: i->age ()++;
+    //
+    i->age (i->age () + 1);
+  }
+
+  // Add middle-name to the first record and remove it from
+  // the second.
+  //
+  person_t& john (ps[0]);
+  person_t& jane (ps[1]);
+
+  john.middle_name ("Mary");
+  jane.middle_name ().reset ();
+
+  // Add another John record.
+  //
+  ps.push_back (john);
+
+  // Serialize the modified object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, *ppl, map);
+}
+  
+<?xml version="1.0"?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>29</age>
+  </person>
+
+  <person id="1">
+    <first-name>John</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>33</age>
+  </person>
+
+</people>
+  
+#include <iostream>
+#include "people.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people_t ppl;
+  people_t::person_sequence& ps (ppl.person ());
+
+  // Add the John Doe record.
+  //
+  ps.push_back (
+    person_t ("John",         // first-name
+              "Doe",          // last-name
+              gender_t::male, // gender
+              32,             // age
+              1));
+
+  // Add the Jane Doe record.
+  //
+  ps.push_back (
+    person_t ("Jane",           // first-name
+              "Doe",            // last-name
+              gender_t::female, // gender
+              28,               // age
+              2));              // id
+
+  // Add middle name to the Jane Doe record.
+  //
+  person_t& jane (ps.back ());
+  jane.middle_name ("Mary");
+
+  // Serialize the object model to XML.
+  //
+  xml_schema::namespace_infomap map;
+  map[""].name = "";
+  map[""].schema = "people.xsd";
+
+  people (cout, ppl, map);
+}
+  
+class person_t
+{
+  person_t (const first_name_type&,
+            const last_name_type&,
+            const gender_type&,
+            const age_type&,
+            const id_type&);
+};
+
+class people_t
+{
+  people_t ();
+};
+  
+// Add the Jane Doe record.
+//
+person_t jane ("Jane",           // first-name
+               "Doe",            // last-name
+               gender_t::female, // gender
+               28,               // age
+               2);               // id
+
+jane.middle_name ("Mary");
+
+ps.push_back (jane);
+  
+// Add the John Doe record.
+//
+auto_ptr<person_t> john_p (
+  new person_t ("John",           // first-name
+                "Doe",            // last-name
+                gender_t::male,   // gender
+                32,               // age
+                1));
+ps.push_back (john_p); // assumes ownership
+
+// Add the Jane Doe record.
+//
+auto_ptr<person_t> jane_p (
+  new person_t ("Jane",           // first-name
+                "Doe",            // last-name
+                gender_t::female, // gender
+                28,               // age
+                2));              // id
+ps.push_back (jane_p); // assumes ownership
+  
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd">
+
+  <person id="1">
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person id="2">
+    <first-name>Jane</first-name>
+    <middle-name>Mary</middle-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+</people>
+  
+std::auto_ptr<people_t>
+people (const std::string& uri,
+	xml_schema::flags f = 0,
+	const xml_schema::properties& p = xml_schema::properties ());
+
+std::auto_ptr<people_t>
+people (std::istream& is,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = xml_schema::properties ());
+
+std::auto_ptr<people_t>
+people (std::istream& is,
+        const std::string& resource_id,
+        xml_schema::flags f = 0,
+        const xml_schema::properties& p = ::xml_schema::properties ());
+  
+using std::auto_ptr;
+
+// Parse a local file or URI.
+//
+auto_ptr<people_t> p1 (people ("people.xml"));
+auto_ptr<people_t> p2 (people ("http://example.com/people.xml"));
+
+// Parse a local file via ifstream.
+//
+std::ifstream ifs ("people.xml");
+auto_ptr<people_t> p3 (people (ifs, "people.xml"));
+
+// Parse an XML string.
+//
+std::string str ("..."); // XML in a string.
+std::istringstream iss (str);
+auto_ptr<people_t> p4 (people (iss));
+  
+auto_ptr<people_t> p (
+  people ("people.xml", xml_schema::flags::dont_validate));
+  
+<?xml version="1.0" ?>
+<people xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="people.xsd"
+        xsi:schemaLocation="http://www.w3.org/XML/1998/namespace xml.xsd">
+  
+xml_schema::properties props;
+props.no_namespace_schema_location ("people.xsd");
+props.schema_location ("http://www.w3.org/XML/1998/namespace", "xml.xsd");
+
+auto_ptr<people_t> p (people ("people.xml", 0, props));
+  
+#include <unistd.h> // getcwd
+#include <limits.h> // PATH_MAX
+
+char cwd[PATH_MAX];
+if (getcwd (cwd, PATH_MAX) == 0)
+{
+  // Buffer too small?
+}
+
+xml_schema::properties props;
+
+props.no_namespace_schema_location (
+  "file:///" + std::string (cwd) + "people.xsd");
+
+props.schema_location (
+  "http://www.w3.org/XML/1998/namespace",
+  "file:///" + std::string (cwd) + "xml.xsd");
+
+auto_ptr<people_t> p (people ("people.xml", 0, props));
+  
+people.xml:2:63 error: no declaration found for element 'people'
+people.xml:4:18 error: no declaration found for element 'person'
+people.xml:4:18 error: attribute 'id' is not declared for element 'person'
+people.xml:5:17 error: no declaration found for element 'first-name'
+people.xml:6:18 error: no declaration found for element 'middle-name'
+people.xml:7:16 error: no declaration found for element 'last-name'
+people.xml:8:13 error: no declaration found for element 'gender'
+people.xml:9:10 error: no declaration found for element 'age'
+  
+try
+{
+  auto_ptr<people_t> p (people ("people.xml"));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+  
+std::ifstream ifs ("people.xml");
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+auto_ptr<people_t> p (people (ifs, "people.xml"));
+
+if (ifs.fail ())
+{
+  cerr << "people.xml: read error" << endl;
+  return 1;
+}
+  
+try
+{
+  std::ifstream ifs;
+  ifs.exceptions (std::ifstream::badbit | std::ifstream::failbit);
+  ifs.open ("people.xml");
+
+  auto_ptr<people_t> p (people (ifs, "people.xml"));
+}
+catch (const std::ifstream::failure&)
+{
+  cerr << "people.xml: unable to open or read error" << endl;
+  return 1;
+}
+  
+void
+people (std::ostream& os,
+        const people_t& x,
+        const xml_schema::namespace_infomap& map =
+          xml_schema::namespace_infomap (),
+        const std::string& encoding = "UTF-8",
+        xml_schema::flags f = 0);
+  
+people_t& p = ...
+
+xml_schema::namespace_infomap map;
+map[""].schema = "people.xsd";
+
+// Serialize to stdout.
+//
+people (std::cout, p, map);
+
+// Serialize to a file.
+//
+std::ofstream ofs ("people.xml");
+people (ofs, p, map);
+
+// Serialize to a string.
+//
+std::ostringstream oss;
+people (oss, p, map);
+std::string xml (oss.str ());
+  
+xml_schema::namespace_infomap map;
+
+map[""].name = "http://www.example.com/example";
+map[""].schema = "example.xsd";
+
+map["x"].name = "http://www.w3.org/XML/1998/namespace";
+map["x"].schema = "xml.xsd";
+  
+<?xml version="1.0" ?>
+<example
+  xmlns="http://www.example.com/example"
+  xmlns:x="http://www.w3.org/XML/1998/namespace"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.example.com/example example.xsd
+                      http://www.w3.org/XML/1998/namespace xml.xsd">
+  
+xml_schema::namespace_infomap map;
+
+map[""].name = "";
+map[""].schema = "example.xsd";
+  
+try
+{
+  people_t& p = ...
+
+  xml_schema::namespace_infomap map;
+  map[""].schema = "people.xsd";
+
+  people (std::cout, p, map));
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+  
+std::ofstream ofs ("people.xml");
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: unable to open" << endl;
+  return 1;
+}
+
+people (ofs, p, map));
+
+if (ofs.fail ())
+{
+  cerr << "people.xml: write error" << endl;
+  return 1;
+}
+  
+try
+{
+  std::ofstream ofs;
+  ofs.exceptions (std::ofstream::badbit | std::ofstream::failbit);
+  ofs.open ("people.xml");
+
+  people (ofs, p, map));
+}
+catch (const std::ofstream::failure&)
+{
+  cerr << "people.xml: unable to open or write error" << endl;
+  return 1;
+}
+  
+<element name="object">
+  <complexType>
+    ...
+  </complexType>
+</element>
+  
+struct exception: virtual std::exception
+{
+  friend
+  std::basic_ostream<C>&
+  operator<< (std::basic_ostream<C>& os, const exception& e)
+  {
+    e.print (os);
+    return os;
+  }
+
+protected:
+  virtual void
+  print (std::basic_ostream<C>&) const = 0;
+};
+  
+try
+{
+  ...
+}
+catch (const xml_schema::exception& e)
+{
+  cerr << e << endl;
+}
+  
+struct duplicate_id: virtual exception
+{
+  duplicate_id (const std::basic_string<C>& id);
+
+  const std::basic_string<C>&
+  id () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+<import namespace="http://www.codesynthesis.com/test"
+        schemaLocation="test.xsd"/>
+  
+#include "test.hxx"
+  
+<-- common.xsd -->
+<schema>
+  <complexType name="type">
+  ...
+  </complexType>
+</schema>
+
+<-- test.xsd -->
+<schema targetNamespace="http://www.codesynthesis.com/test">
+  <include schemaLocation="common.xsd"/>
+</schema>
+  
+// test.hxx
+namespace test
+{
+  class type
+  {
+    ...
+  };
+}
+  
+<schema targetNamespace="http://www.codesynthesis.com/system/test">
+  ...
+</schema>
+  
+namespace system
+{
+  namespace test
+  {
+    ...
+  }
+}
+  
+<simpleType name="my_int">
+  <restriction base="int"/>
+</simpleType>
+  
+class my_int: public fundamental_base<int>
+{
+  ...
+};
+  
+template <typename X>
+class fundamental_base: public simple_type
+{
+public:
+  fundamental_base ();
+  fundamental_base (X)
+  fundamental_base (const fundamental_base&)
+
+public:
+  fundamental_base&
+  operator= (const X&);
+
+public:
+  operator const X & () const;
+  operator X& ();
+
+  template <typename Y>
+  operator Y () const;
+
+  template <typename Y>
+  operator Y ();
+};
+  
+class type
+{
+public:
+  virtual
+  ~type ();
+
+public:
+  type ();
+  type (const type&);
+
+public:
+  type&
+  operator= (const type&);
+
+public:
+  virtual type*
+  _clone () const;
+
+  // DOM association.
+  //
+public:
+  const xercesc::DOMNode*
+  _node () const;
+
+  xercesc::DOMNode*
+  _node ();
+};
+  
+class simple_type: public type
+{
+public:
+  simple_type ();
+  simple_type (const simple_type&);
+
+public:
+  simple_type&
+  operator= (const simple_type&);
+
+public:
+  virtual simple_type*
+  _clone () const;
+};
+  
+class qname: public simple_type
+{
+public:
+  qname (const ncname&);
+  qname (const uri&, const ncname&);
+  qname (const qname&);
+
+public:
+  qname&
+  operator= (const qname&);
+
+public:
+  virtual qname*
+  _clone () const;
+
+public:
+  bool
+  qualified () const;
+
+  const uri&
+  namespace_ () const;
+
+  const ncname&
+  name () const;
+};
+  
+class idref: public ncname
+{
+public:
+  idref (const C* s);
+  idref (const C* s, std::size_t n);
+  idref (std::size_t n, C c);
+  idref (const std::basic_string<C>&);
+  idref (const std::basic_string<C>&,
+         std::size_t pos,
+         std::size_t n = npos);
+
+public:
+  idref (const idref&);
+
+public:
+  virtual idref*
+  _clone () const;
+
+public:
+  idref&
+  operator= (C c);
+
+  idref&
+  operator= (const C* s);
+
+  idref&
+  operator= (const std::basic_string<C>&)
+
+  idref&
+  operator= (const idref&);
+
+public:
+  const type*
+  operator-> () const;
+
+  type*
+  operator-> ();
+
+  const type&
+  operator* () const;
+
+  type&
+  operator* ();
+
+  const type*
+  get () const;
+
+  type*
+  get ();
+
+  // Conversion to bool.
+  //
+public:
+  typedef void (idref::*bool_convertible)();
+  operator bool_convertible () const;
+};
+  
+<!-- test.xml -->
+<root>
+  <object id="obj-1" text="hello"/>
+  <reference>obj-1</reference>
+</root>
+
+<!-- test.xsd -->
+<schema>
+  <complexType name="object_type">
+    <attribute name="id" type="ID"/>
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="object" type="object_type"/>
+      <element name="reference" type="IDREF"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+  
+root_type& root = ...;
+xml_schema::idref& ref (root.reference ());
+object_type& obj (dynamic_cast<object_type&> (*ref));
+cout << obj.text () << endl;
+  
+<!-- test.xsd -->
+<schema
+  xmlns:xse="http://www.codesynthesis.com/xmlns/xml-schema-extension">
+
+  ...
+
+      <element name="reference" type="IDREF" xse:refType="object_type"/>
+
+  ...
+
+</schema>
+  
+root_type& root = ...;
+root_type::reference_type& ref (root.reference ());
+object_type& obj (*ref);
+cout << ref->text () << endl;
+  
+class bounds: public virtual exception
+{
+public:
+  virtual const char*
+  what () const throw ();
+};
+
+class buffer
+{
+public:
+  typedef std::size_t size_t;
+
+public:
+  buffer (size_t size = 0);
+  buffer (size_t size, size_t capacity);
+  buffer (const void* data, size_t size);
+  buffer (const void* data, size_t size, size_t capacity);
+  buffer (void* data,
+          size_t size,
+          size_t capacity,
+          bool assume_ownership);
+
+public:
+  buffer (const buffer&);
+
+  buffer&
+  operator= (const buffer&);
+
+  void
+  swap (buffer&);
+
+public:
+  size_t
+  capacity () const;
+
+  bool
+  capacity (size_t);
+
+public:
+  size_t
+  size () const;
+
+  bool
+  size (size_t);
+
+public:
+  const char*
+  data () const;
+
+  char*
+  data ();
+
+  const char*
+  begin () const;
+
+  char*
+  begin ();
+
+  const char*
+  end () const;
+
+  char*
+  end ();
+};
+  
+class base64_binary: public simple_type, public buffer
+{
+public:
+  base64_binary (size_t size = 0);
+  base64_binary (size_t size, size_t capacity);
+  base64_binary (const void* data, size_t size);
+  base64_binary (const void* data, size_t size, size_t capacity);
+  base64_binary (void* data,
+                 size_t size,
+                 size_t capacity,
+                 bool assume_ownership);
+
+public:
+  base64_binary (const base64_binary&);
+
+  base64_binary&
+  operator= (const base64_binary&);
+
+  virtual base64_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+  
+class hex_binary: public simple_type, public buffer
+{
+public:
+  hex_binary (size_t size = 0);
+  hex_binary (size_t size, size_t capacity);
+  hex_binary (const void* data, size_t size);
+  hex_binary (const void* data, size_t size, size_t capacity);
+  hex_binary (void* data,
+              size_t size,
+              size_t capacity,
+              bool assume_ownership);
+
+public:
+  hex_binary (const hex_binary&);
+
+  hex_binary&
+  operator= (const hex_binary&);
+
+  virtual hex_binary*
+  _clone () const;
+
+public:
+  std::basic_string<C>
+  encode () const;
+};
+  
+class time_zone
+{
+public:
+  time_zone ();
+  time_zone (short hours, short minutes);
+
+  bool
+  zone_present () const;
+
+  void
+  zone_reset ();
+
+  short
+  zone_hours () const;
+
+  void
+  zone_hours (short);
+
+  short
+  zone_minutes () const;
+
+  void
+  zone_minutes (short);
+};
+
+bool
+operator== (const time_zone&, const time_zone&);
+
+bool
+operator!= (const time_zone&, const time_zone&);
+  
+class date: public simple_type, public time_zone
+{
+public:
+  date (int year, unsigned short month, unsigned short day);
+  date (int year, unsigned short month, unsigned short day,
+        short zone_hours, short zone_minutes);
+
+public:
+  date (const date&);
+
+  date&
+  operator= (const date&);
+
+  virtual date*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const date&, const date&);
+
+bool
+operator!= (const date&, const date&);
+  
+class date_time: public simple_type, public time_zone
+{
+public:
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds);
+
+  date_time (int year, unsigned short month, unsigned short day,
+             unsigned short hours, unsigned short minutes,
+             double seconds, short zone_hours, short zone_minutes);
+public:
+  date_time (const date_time&);
+
+  date_time&
+  operator= (const date_time&);
+
+  virtual date_time*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const date_time&, const date_time&);
+
+bool
+operator!= (const date_time&, const date_time&);
+  
+class duration: public simple_type
+{
+public:
+  duration (bool negative,
+            unsigned int years, unsigned int months, unsigned int days,
+            unsigned int hours, unsigned int minutes, double seconds);
+public:
+  duration (const duration&);
+
+  duration&
+  operator= (const duration&);
+
+  virtual duration*
+  _clone () const;
+
+public:
+  bool
+  negative () const;
+
+  void
+  negative (bool);
+
+  unsigned int
+  years () const;
+
+  void
+  years (unsigned int);
+
+  unsigned int
+  months () const;
+
+  void
+  months (unsigned int);
+
+  unsigned int
+  days () const;
+
+  void
+  days (unsigned int);
+
+  unsigned int
+  hours () const;
+
+  void
+  hours (unsigned int);
+
+  unsigned int
+  minutes () const;
+
+  void
+  minutes (unsigned int);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const duration&, const duration&);
+
+bool
+operator!= (const duration&, const duration&);
+  
+class gday: public simple_type, public time_zone
+{
+public:
+  explicit
+  gday (unsigned short day);
+  gday (unsigned short day, short zone_hours, short zone_minutes);
+
+public:
+  gday (const gday&);
+
+  gday&
+  operator= (const gday&);
+
+  virtual gday*
+  _clone () const;
+
+public:
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gday&, const gday&);
+
+bool
+operator!= (const gday&, const gday&);
+  
+class gmonth: public simple_type, public time_zone
+{
+public:
+  explicit
+  gmonth (unsigned short month);
+  gmonth (unsigned short month,
+          short zone_hours, short zone_minutes);
+
+public:
+  gmonth (const gmonth&);
+
+  gmonth&
+  operator= (const gmonth&);
+
+  virtual gmonth*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gmonth&, const gmonth&);
+
+bool
+operator!= (const gmonth&, const gmonth&);
+  
+class gmonth_day: public simple_type, public time_zone
+{
+public:
+  gmonth_day (unsigned short month, unsigned short day);
+  gmonth_day (unsigned short month, unsigned short day,
+              short zone_hours, short zone_minutes);
+
+public:
+  gmonth_day (const gmonth_day&);
+
+  gmonth_day&
+  operator= (const gmonth_day&);
+
+  virtual gmonth_day*
+  _clone () const;
+
+public:
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+
+  unsigned short
+  day () const;
+
+  void
+  day (unsigned short);
+};
+
+bool
+operator== (const gmonth_day&, const gmonth_day&);
+
+bool
+operator!= (const gmonth_day&, const gmonth_day&);
+  
+class gyear: public simple_type, public time_zone
+{
+public:
+  explicit
+  gyear (int year);
+  gyear (int year, short zone_hours, short zone_minutes);
+
+public:
+  gyear (const gyear&);
+
+  gyear&
+  operator= (const gyear&);
+
+  virtual gyear*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+};
+
+bool
+operator== (const gyear&, const gyear&);
+
+bool
+operator!= (const gyear&, const gyear&);
+  
+class gyear_month: public simple_type, public time_zone
+{
+public:
+  gyear_month (int year, unsigned short month);
+  gyear_month (int year, unsigned short month,
+               short zone_hours, short zone_minutes);
+public:
+  gyear_month (const gyear_month&);
+
+  gyear_month&
+  operator= (const gyear_month&);
+
+  virtual gyear_month*
+  _clone () const;
+
+public:
+  int
+  year () const;
+
+  void
+  year (int);
+
+  unsigned short
+  month () const;
+
+  void
+  month (unsigned short);
+};
+
+bool
+operator== (const gyear_month&, const gyear_month&);
+
+bool
+operator!= (const gyear_month&, const gyear_month&);
+  
+class time: public simple_type, public time_zone
+{
+public:
+  time (unsigned short hours, unsigned short minutes, double seconds);
+  time (unsigned short hours, unsigned short minutes, double seconds,
+        short zone_hours, short zone_minutes);
+
+public:
+  time (const time&);
+
+  time&
+  operator= (const time&);
+
+  virtual time*
+  _clone () const;
+
+public:
+  unsigned short
+  hours () const;
+
+  void
+  hours (unsigned short);
+
+  unsigned short
+  minutes () const;
+
+  void
+  minutes (unsigned short);
+
+  double
+  seconds () const;
+
+  void
+  seconds (double);
+};
+
+bool
+operator== (const time&, const time&);
+
+bool
+operator!= (const time&, const time&);
+  
+<simpleType name="object">
+  ...
+</simpleType>
+  
+class object: ...
+{
+public:
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  
+<simpleType name="object">
+  <restriction base="base">
+    ...
+  </restriction>
+</simpleType>
+  
+class object: public base
+{
+public:
+  object (const base&);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+};
+  
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+  
+class color: xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+  color (const xml_schema::string&);
+  color (const color&);
+
+public:
+  color&
+  operator= (value);
+
+  color&
+  operator= (const color&);
+
+public:
+  virtual color*
+  _clone () const;
+
+public:
+  operator value () const;
+};
+  
+<simpleType name="int_list">
+  <list itemType="int"/>
+</simpleType>
+  
+class int_list: public simple_type,
+                public sequence<int>
+{
+public:
+  int_list ();
+  int_list (size_type n, int x);
+
+  template <typename I>
+  int_list (const I& begin, const I& end);
+  int_list (const int_list&);
+
+public:
+  int_list&
+  operator= (const int_list&);
+
+public:
+  virtual int_list*
+  _clone () const;
+};
+  
+<simpleType name="int_string_union">
+  <xsd:union memberTypes="xsd:int xsd:string"/>
+</simpleType>
+  
+class int_string_union: public simple_type,
+                        public std::basic_string<C>
+{
+public:
+  int_string_union (const C*);
+  int_string_union (const std::basic_string<C>&);
+  int_string_union (const int_string_union&);
+
+public:
+  int_string_union&
+  operator= (const int_string_union&);
+
+public:
+  virtual int_string_union*
+  _clone () const;
+};
+  
+<complexType name="complex">
+  <sequence>
+    <element name="a" type="int"/>
+    <element name="b" type="string"/>
+  </sequence>
+</complexType>
+
+<complexType name="object">
+  <sequence>
+    <element name="s-one" type="boolean"/>
+    <element name="c-one" type="complex"/>
+    <element name="optional" type="int" minOccurs="0"/>
+    <element name="sequence" type="string" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+  
+class complex: xml_schema::type
+{
+public:
+  object (const int& a, const xml_schema::string& b);
+  object (const complex&);
+
+public:
+  object&
+  operator= (const complex&);
+
+public:
+  virtual complex*
+  _clone () const;
+
+  ...
+
+};
+
+class object: xml_schema::type
+{
+public:
+  object (const bool& s_one, const complex& c_one);
+  object (const bool& s_one, std::auto_ptr<complex>& c_one);
+  object (const object&);
+
+public:
+  object&
+  operator= (const object&);
+
+public:
+  virtual object*
+  _clone () const;
+
+  ...
+
+};
+  
+<complexType name="object">
+  <simpleContent>
+    <extension base="date">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+  
+class object: xml_schema::string
+{
+public:
+  object (const xml_schema::language& lang);
+
+  object (const xml_schema::date& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+  
+<simpleType name="color">
+  <restriction base="string">
+    <enumeration value="red"/>
+    <enumeration value="green"/>
+    <enumeration value="blue"/>
+  </restriction>
+</simpleType>
+
+<complexType name="object">
+  <simpleContent>
+    <extension base="color">
+      <attribute name="lang" type="language" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+  
+class color: xml_schema::string
+{
+public:
+  enum value
+  {
+    red,
+    green,
+    blue
+  };
+
+public:
+  color (value);
+  color (const C*);
+  color (const std::basic_string<C>&);
+
+  ...
+
+};
+
+class object: color
+{
+public:
+  object (const color& base,
+          const xml_schema::language& lang);
+
+  object (const color::value& base,
+          const xml_schema::language& lang);
+
+  object (const C* base,
+          const xml_schema::language& lang);
+
+  object (const std::basic_string<C>& base,
+          const xml_schema::language& lang);
+
+  ...
+
+};
+  
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  typedef xml_schema::string member_type;
+
+  const member_type&
+  member () const;
+
+  ...
+
+};
+  
+<complexType name="object">
+  <attribute name="data" type="string" default="test"/>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  typedef xml_schema::string data_type;
+
+  const data_type&
+  data () const;
+
+  static const data_type&
+  data_default_value ();
+
+  ...
+
+};
+  
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+
+  // Accessors.
+  //
+  const member_type&
+  member () const;
+
+  member_type&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::auto_ptr<member_type>);
+  ...
+
+};
+  
+class object: xml_schema::type
+{
+public:
+  ...
+
+  std::auto_ptr<member_type>
+  detach_member ();
+  ...
+
+};
+  
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  string s (o.member ());                // get
+  object::member_type& sr (o.member ()); // get
+
+  o.member ("hello");           // set, deep copy
+  o.member () = "hello";        // set, deep copy
+
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                 // set, assumes ownership
+  p = o.detach_member ();       // detach, member is uninitialized
+  o.member (p);                 // re-attach
+}
+  
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="0"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef optional<member_type> member_optional;
+
+  // Accessors.
+  //
+  const member_optional&
+  member () const;
+
+  member_optional&
+  member ();
+
+  // Modifiers.
+  //
+  void
+  member (const member_type&);
+
+  void
+  member (std::auto_ptr<member_type>);
+
+  void
+  member (const member_optional&);
+
+  ...
+
+};
+  
+template <typename X>
+class optional
+{
+public:
+  optional ();
+
+  // Makes a deep copy.
+  //
+  explicit
+  optional (const X&);
+
+  // Assumes ownership.
+  //
+  explicit
+  optional (std::auto_ptr<X>);
+
+  optional (const optional&);
+
+public:
+  optional&
+  operator= (const X&);
+
+  optional&
+  operator= (const optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const X*
+  operator-> () const;
+
+  X*
+  operator-> ();
+
+  const X&
+  operator* () const;
+
+  X&
+  operator* ();
+
+  typedef void (optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const X&
+  get () const;
+
+  X&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const X&);
+
+  // Assumes ownership.
+  //
+  void
+  set (std::auto_ptr<X>);
+
+  // Detach and return the contained value.
+  //
+  std::auto_ptr<X>
+  detach ();
+
+  void
+  reset ();
+};
+
+template <typename X>
+bool
+operator== (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator!= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator< (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator> (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator<= (const optional<X>&, const optional<X>&);
+
+template <typename X>
+bool
+operator>= (const optional<X>&, const optional<X>&);
+  
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  if (o.member ().present ())       // test
+  {
+    string& s (o.member ().get ()); // get
+    o.member ("hello");             // set, deep copy
+    o.member ().set ("hello");      // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                  // test
+  {
+    string& s (*o.member ());       // get
+    o.member ("hello");             // set, deep copy
+    *o.member () = "hello";         // set, deep copy
+    o.member ().reset ();           // reset
+  }
+
+  std::auto_ptr<string> p (new string ("hello"));
+  o.member (p);                     // set, assumes ownership
+
+  p = new string ("hello");
+  o.member ().set (p);              // set, assumes ownership
+
+  p = o.member ().detach ();        // detach, member is reset
+  o.member ().set (p);              // re-attach
+}
+  
+<complexType name="object">
+  <sequence>
+    <element name="member" type="string" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef xml_schema::string member_type;
+  typedef sequence<member_type> member_sequence;
+  typedef member_sequence::iterator member_iterator;
+  typedef member_sequence::const_iterator member_const_iterator;
+
+  // Accessors.
+  //
+  const member_sequence&
+  member () const;
+
+  member_sequence&
+  member ();
+
+  // Modifier.
+  //
+  void
+  member (const member_sequence&);
+
+  ...
+
+};
+  
+template <typename X>
+class sequence
+{
+public:
+  ...
+
+  void
+  push_back (std::auto_ptr<X>)
+
+  iterator
+  insert (iterator position, std::auto_ptr<X>)
+
+  std::auto_ptr<X>
+  detach_back (bool pop = true);
+
+  iterator
+  detach (iterator position,
+          std::auto_ptr<X>& result,
+          bool erase = true)
+
+  ...
+}
+  
+void
+f (object& o)
+{
+  using xml_schema::string;
+
+  object::member_sequence& s (o.member ());
+
+  // Iteration.
+  //
+  for (object::member_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    string& value (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back ("hello");  // deep copy
+
+  std::auto_ptr<string> p (new string ("hello"));
+  s.push_back (p);        // assumes ownership
+  p = s.detach_back ();   // detach and pop
+  s.push_back (p);        // re-append
+
+  // Setting a new container.
+  //
+  object::member_sequence n;
+  n.push_back ("one");
+  n.push_back ("two");
+  o.member (n);           // deep copy
+}
+  
+std::auto_ptr<type>
+name (....);
+  
+void
+name (<stream type>&, const type&, ....);
+  
+<complexType name="type">
+  <sequence>
+    ...
+  </sequence>
+</complexType>
+
+<element name="root" type="type"/>
+  
+class type
+{
+  ...
+};
+
+class root: public xml_schema::element_type
+{
+public:
+  // Element value.
+  //
+  typedef type value_type;
+
+  const value_type&
+  value () const;
+
+  value_type&
+  value ();
+
+  void
+  value (const value_type&);
+
+  void
+  value (std::auto_ptr<value_type>);
+
+  // Constructors.
+  //
+  root (const value_type&);
+
+  root (std::auto_ptr<value_type>);
+
+  root (const xercesc::DOMElement&, xml_schema::flags = 0);
+
+  root (const root&, xml_schema::flags = 0);
+
+  virtual root*
+  _clone (xml_schema::flags = 0) const;
+
+  // Element name and namespace.
+  //
+  static const std::string&
+  name ();
+
+  static const std::string&
+  namespace_ ();
+
+  virtual const std::string&
+  _name () const;
+
+  virtual const std::string&
+  _namespace () const;
+
+  // Element value as xml_schema::type.
+  //
+  virtual const xml_schema::type*
+  _value () const;
+
+  virtual xml_schema::type*
+  _value ();
+};
+
+void
+operator<< (xercesc::DOMElement&, const root&);
+  
+namespace xml_schema
+{
+  class element_type
+  {
+  public:
+    virtual
+    ~element_type ();
+
+    virtual element_type*
+    _clone (flags f = 0) const = 0;
+
+    virtual const std::basic_string<C>&
+    _name () const = 0;
+
+    virtual const std::basic_string<C>&
+    _namespace () const = 0;
+
+    virtual xml_schema::type*
+    _value () = 0;
+
+    virtual const xml_schema::type*
+    _value () const = 0;
+  };
+}
+  
+namespace xml_schema
+{
+  class element_map
+  {
+  public:
+    static std::auto_ptr<xml_schema::element_type>
+    parse (const xercesc::DOMElement&, flags = 0);
+
+    static void
+    serialize (xercesc::DOMElement&, const element_type&);
+  };
+}
+  
+struct no_element_info: virtual exception
+{
+  no_element_info (const std::basic_string<C>& element_name,
+                   const std::basic_string<C>& element_namespace);
+
+  const std::basic_string<C>&
+  element_name () const;
+
+  const std::basic_string<C>&
+  element_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+// Parsing.
+//
+DOMElement& e = ... // Parse XML to DOM.
+
+auto_ptr<xml_schema::element_type> r (
+  xml_schema::element_map::parse (e));
+
+if (root1 r1 = dynamic_cast<root1*> (r.get ()))
+{
+  ...
+}
+else if (r->_name == root2::name () &&
+         r->_namespace () == root2::namespace_ ())
+{
+  root2& r2 (static_cast<root2&> (*r));
+
+  ...
+}
+  
+// Serialization.
+//
+xml_schema::element_type& r = ...
+
+string name (r._name ());
+string ns (r._namespace ());
+
+DOMDocument& doc = ... // Create a new DOMDocument with name and ns.
+DOMElement& e (*doc->getDocumentElement ());
+
+xml_schema::element_map::serialize (e, r);
+
+// Serialize DOMDocument to XML.
+  
+<!-- test.xsd -->
+<schema>
+  <complexType name="base">
+    <attribute name="text" type="string"/>
+  </complexType>
+
+  <complexType name="derived">
+    <complexContent>
+      <extension base="base">
+        <attribute name="extra-text" type="string"/>
+      </extension>
+    </complexContent>
+  </complexType>
+
+  <complexType name="root_type">
+    <sequence>
+      <element name="item" type="base" maxOccurs="unbounded"/>
+    </sequence>
+  </complexType>
+
+  <element name="root" type="root_type"/>
+</schema>
+
+<!-- test.xml -->
+<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <item text="hello"/>
+  <item text="hello" extra-text="world" xsi:type="derived"/>
+</root>
+  
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    if (derived* d = dynamic_cast<derived*> (&(*i)))
+    {
+      // derived
+    }
+    else
+    {
+      // base
+    }
+  }
+}
+  
+void
+f (root& r)
+{
+  for (root::item_const_iterator i (r.item ().begin ());
+       i != r.item ().end ()
+       ++i)
+  {
+    std::auto_ptr<base> c (i->_clone ());
+  }
+}
+  
+<!-- base.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="base">
+    <xs:sequence>
+      <xs:element name="b" type="xs:int"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="base" type="base"/>
+
+</xs:schema>
+  
+<!-- derived.xsd -->
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <include schemaLocation="base.xsd"/>
+
+  <xs:complexType name="derived">
+    <xs:complexContent>
+      <xs:extension base="base">
+        <xs:sequence>
+          <xs:element name="d" type="xs:string"/>
+        </xs:sequence>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="derived" type="derived" substitutionGroup="base"/>
+
+</xs:schema>
+  
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // any
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  void
+  any (const xercesc::DOMElement&);
+
+  ...
+
+  // any_attribute
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  ...
+
+  // DOMDocument object for wildcard content.
+  //
+  const xercesc::DOMDocument&
+  dom_document () const;
+
+  xercesc::DOMDocument&
+  dom_document ();
+
+  ...
+};
+  
+<complexType name="object">
+  <sequence>
+    <any namespace="##other"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Accessors.
+  //
+  const xercesc::DOMElement&
+  any () const;
+
+  xercesc::DOMElement&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  ...
+
+};
+  
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMElement& e1 (o.any ());             // get
+  o.any (e)                              // set, deep copy
+  DOMDocument& doc (o.dom_document ());
+  o.any (doc.createElement (...));       // set, assumes ownership
+}
+  
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="0"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_optional any_optional;
+
+  // Accessors.
+  //
+  const any_optional&
+  any () const;
+
+  any_optional&
+  any ();
+
+  // Modifiers.
+  //
+  void
+  any (const xercesc::DOMElement&);
+
+  void
+  any (xercesc::DOMElement*);
+
+  void
+  any (const any_optional&);
+
+  ...
+
+};
+  
+class element_optional
+{
+public:
+  explicit
+  element_optional (xercesc::DOMDocument&);
+
+  // Makes a deep copy.
+  //
+  element_optional (const xercesc::DOMElement&, xercesc::DOMDocument&);
+
+  // Assumes ownership.
+  //
+  element_optional (xercesc::DOMElement*, xercesc::DOMDocument&);
+
+  element_optional (const element_optional&, xercesc::DOMDocument&);
+
+public:
+  element_optional&
+  operator= (const xercesc::DOMElement&);
+
+  element_optional&
+  operator= (const element_optional&);
+
+  // Pointer-like interface.
+  //
+public:
+  const xercesc::DOMElement*
+  operator-> () const;
+
+  xercesc::DOMElement*
+  operator-> ();
+
+  const xercesc::DOMElement&
+  operator* () const;
+
+  xercesc::DOMElement&
+  operator* ();
+
+  typedef void (element_optional::*bool_convertible) ();
+  operator bool_convertible () const;
+
+  // Get/set interface.
+  //
+public:
+  bool
+  present () const;
+
+  const xercesc::DOMElement&
+  get () const;
+
+  xercesc::DOMElement&
+  get ();
+
+  // Makes a deep copy.
+  //
+  void
+  set (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  set (xercesc::DOMElement*);
+
+  void
+  reset ();
+};
+
+bool
+operator== (const element_optional&, const element_optional&);
+
+bool
+operator!= (const element_optional&, const element_optional&);
+  
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  DOMDocument& doc (o.dom_document ());
+
+  if (o.any ().present ())                  // test
+  {
+    DOMElement& e1 (o.any ().get ());       // get
+    o.any ().set (e);                       // set, deep copy
+    o.any ().set (doc.createElement (...)); // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+
+  // Same as above but using pointer notation:
+  //
+  if (o.member ())                          // test
+  {
+    DOMElement& e1 (*o.any ());             // get
+    o.any (e);                              // set, deep copy
+    o.any (doc.createElement (...));        // set, assumes ownership
+    o.any ().reset ();                      // reset
+  }
+}
+  
+<complexType name="object">
+  <sequence>
+    <any namespace="##other" minOccurs="unbounded"/>
+  </sequence>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef element_sequence any_sequence;
+  typedef any_sequence::iterator any_iterator;
+  typedef any_sequence::const_iterator any_const_iterator;
+
+  // Accessors.
+  //
+  const any_sequence&
+  any () const;
+
+  any_sequence&
+  any ();
+
+  // Modifier.
+  //
+  void
+  any (const any_sequence&);
+
+  ...
+
+};
+  
+class element_sequence
+{
+public:
+  typedef xercesc::DOMElement        value_type;
+  typedef xercesc::DOMElement*       pointer;
+  typedef const xercesc::DOMElement* const_pointer;
+  typedef xercesc::DOMElement&       reference;
+  typedef const xercesc::DOMElement& const_reference;
+
+  typedef <implementation-defined>   iterator;
+  typedef <implementation-defined>   const_iterator;
+  typedef <implementation-defined>   reverse_iterator;
+  typedef <implementation-defined>   const_reverse_iterator;
+
+  typedef <implementation-defined>   size_type;
+  typedef <implementation-defined>   difference_type;
+  typedef <implementation-defined>   allocator_type;
+
+public:
+  explicit
+  element_sequence (xercesc::DOMDocument&);
+
+  // DOMElement cannot be default-constructed.
+  //
+  // explicit
+  // element_sequence (size_type n);
+
+  element_sequence (size_type n,
+                    const xercesc::DOMElement&,
+                    xercesc::DOMDocument&);
+
+  template <typename I>
+  element_sequence (const I& begin,
+                    const I& end,
+                    xercesc::DOMDocument&);
+
+  element_sequence (const element_sequence&, xercesc::DOMDocument&);
+
+  element_sequence&
+  operator= (const element_sequence&);
+
+public:
+  void
+  assign (size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  assign (const I& begin, const I& end);
+
+public:
+  // This version of resize can only be used to shrink the
+  // sequence because DOMElement cannot be default-constructed.
+  //
+  void
+  resize (size_type);
+
+  void
+  resize (size_type, const xercesc::DOMElement&);
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  size_type
+  capacity () const;
+
+  bool
+  empty () const;
+
+  void
+  reserve (size_type);
+
+  void
+  clear ();
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const
+
+    reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  xercesc::DOMElement&
+  operator[] (size_type);
+
+  const xercesc::DOMElement&
+  operator[] (size_type) const;
+
+  xercesc::DOMElement&
+  at (size_type);
+
+  const xercesc::DOMElement&
+  at (size_type) const;
+
+  xercesc::DOMElement&
+  front ();
+
+  const xercesc::DOMElement&
+  front () const;
+
+  xercesc::DOMElement&
+  back ();
+
+  const xercesc::DOMElement&
+  back () const;
+
+public:
+  // Makes a deep copy.
+  //
+  void
+  push_back (const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  void
+  push_back (xercesc::DOMElement*);
+
+  void
+  pop_back ();
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMElement&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMElement*);
+
+  void
+  insert (iterator position, size_type n, const xercesc::DOMElement&);
+
+  template <typename I>
+  void
+  insert (iterator position, const I& begin, const I& end);
+
+  iterator
+  erase (iterator position);
+
+  iterator
+  erase (iterator begin, iterator end);
+
+public:
+  // Note that the DOMDocument object of the two sequences being
+  // swapped should be the same.
+  //
+  void
+  swap (sequence& x);
+};
+
+inline bool
+operator== (const element_sequence&, const element_sequence&);
+
+inline bool
+operator!= (const element_sequence&, const element_sequence&);
+  
+void
+f (object& o, const xercesc::DOMElement& e)
+{
+  using namespace xercesc;
+
+  object::any_sequence& s (o.any ());
+
+  // Iteration.
+  //
+  for (object::any_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMElement& e (*i);
+  }
+
+  // Modification.
+  //
+  s.push_back (e);                       // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.push_back (doc.createElement (...)); // assumes ownership
+}
+  
+<complexType name="object">
+  <sequence>
+    ...
+  </sequence>
+  <anyAttribute namespace="##other"/>
+</complexType>
+  
+class object: xml_schema::type
+{
+public:
+  // Type definitions.
+  //
+  typedef attribute_set any_attribute_set;
+  typedef any_attribute_set::iterator any_attribute_iterator;
+  typedef any_attribute_set::const_iterator any_attribute_const_iterator;
+
+  // Accessors.
+  //
+  const any_attribute_set&
+  any_attribute () const;
+
+  any_attribute_set&
+  any_attribute ();
+
+  // Modifier.
+  //
+  void
+  any_attribute (const any_attribute_set&);
+
+  ...
+
+};
+  
+class attribute_set
+{
+public:
+  typedef xercesc::DOMAttr         key_type;
+  typedef xercesc::DOMAttr         value_type;
+  typedef xercesc::DOMAttr*        pointer;
+  typedef const xercesc::DOMAttr*  const_pointer;
+  typedef xercesc::DOMAttr&        reference;
+  typedef const xercesc::DOMAttr&  const_reference;
+
+  typedef <implementation-defined> iterator;
+  typedef <implementation-defined> const_iterator;
+  typedef <implementation-defined> reverse_iterator;
+  typedef <implementation-defined> const_reverse_iterator;
+
+  typedef <implementation-defined> size_type;
+  typedef <implementation-defined> difference_type;
+  typedef <implementation-defined> allocator_type;
+
+public:
+  attribute_set (xercesc::DOMDocument&);
+
+  template <typename I>
+  attribute_set (const I& begin, const I& end, xercesc::DOMDocument&);
+
+  attribute_set (const attribute_set&, xercesc::DOMDocument&);
+
+  attribute_set&
+  operator= (const attribute_set&);
+
+public:
+  const_iterator
+  begin () const;
+
+  const_iterator
+  end () const;
+
+  iterator
+  begin ();
+
+  iterator
+  end ();
+
+  const_reverse_iterator
+  rbegin () const;
+
+  const_reverse_iterator
+  rend () const;
+
+  reverse_iterator
+  rbegin ();
+
+  reverse_iterator
+  rend ();
+
+public:
+  size_type
+  size () const;
+
+  size_type
+  max_size () const;
+
+  bool
+  empty () const;
+
+  void
+  clear ();
+
+public:
+  // Makes a deep copy.
+  //
+  std::pair<iterator, bool>
+  insert (const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  std::pair<iterator, bool>
+  insert (xercesc::DOMAttr*);
+
+  // Makes a deep copy.
+  //
+  iterator
+  insert (iterator position, const xercesc::DOMAttr&);
+
+  // Assumes ownership.
+  //
+  iterator
+  insert (iterator position, xercesc::DOMAttr*);
+
+  template <typename I>
+  void
+  insert (const I& begin, const I& end);
+
+public:
+  void
+  erase (iterator position);
+
+  size_type
+  erase (const std::basic_string<C>& name);
+
+  size_type
+  erase (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name);
+
+  size_type
+  erase (const XMLCh* name);
+
+  size_type
+  erase (const XMLCh* namespace_, const XMLCh* name);
+
+  void
+  erase (iterator begin, iterator end);
+
+public:
+  size_type
+  count (const std::basic_string<C>& name) const;
+
+  size_type
+  count (const std::basic_string<C>& namespace_,
+         const std::basic_string<C>& name) const;
+
+  size_type
+  count (const XMLCh* name) const;
+
+  size_type
+  count (const XMLCh* namespace_, const XMLCh* name) const;
+
+  iterator
+  find (const std::basic_string<C>& name);
+
+  iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name);
+
+  iterator
+  find (const XMLCh* name);
+
+  iterator
+  find (const XMLCh* namespace_, const XMLCh* name);
+
+  const_iterator
+  find (const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const std::basic_string<C>& namespace_,
+        const std::basic_string<C>& name) const;
+
+  const_iterator
+  find (const XMLCh* name) const;
+
+  const_iterator
+  find (const XMLCh* namespace_, const XMLCh* name) const;
+
+public:
+  // Note that the DOMDocument object of the two sets being
+  // swapped should be the same.
+  //
+  void
+  swap (attribute_set&);
+};
+
+bool
+operator== (const attribute_set&, const attribute_set&);
+
+bool
+operator!= (const attribute_set&, const attribute_set&);
+  
+void
+f (object& o, const xercesc::DOMAttr& a)
+{
+  using namespace xercesc;
+
+  object::any_attribute_set& s (o.any_attribute ());
+
+  // Iteration.
+  //
+  for (object::any_attribute_iterator i (s.begin ()); i != s.end (); ++i)
+  {
+    DOMAttr& a (*i);
+  }
+
+  // Modification.
+  //
+  s.insert (a);                         // deep copy
+  DOMDocument& doc (o.dom_document ());
+  s.insert (doc.createAttribute (...)); // assumes ownership
+
+  // Searching.
+  //
+  object::any_attribute_iterator i (s.find ("name"));
+  i = s.find ("http://www.w3.org/XML/1998/namespace", "lang");
+}
+  
+<element name="name" type="type"/>
+  
+// Read from a URI or a local file.
+//
+
+std::auto_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (const std::basic_string<C>& uri,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (const std::basic_string<C>& uri,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from std::istream.
+//
+
+std::auto_ptr<type>
+name (std::istream&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (std::istream&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (std::istream&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+std::auto_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (std::istream&,
+      const std::basic_string<C>& id,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from InputSource.
+//
+
+std::auto_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (xercesc::InputSource&,
+      xml_schema::error_handler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (xercesc::InputSource&,
+      xercesc::DOMErrorHandler&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+
+// Read from DOM.
+//
+
+std::auto_ptr<type>
+name (const xercesc::DOMDocument&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+
+std::auto_ptr<type>
+name (xml_schema::dom::auto_ptr<xercesc::DOMDocument>&,
+      xml_schema::flags = 0,
+      const xml_schema::properties& = xml_schema::properties ());
+  
+using xml_schema::flags;
+
+std::auto_ptr<type> r (
+  name ("test.xml", flags::keep_dom | flags::dont_validate));
+  
+class properties
+{
+public:
+  void
+  schema_location (const std::basic_string<C>& namespace_,
+                   const std::basic_string<C>& location);
+  void
+  no_namespace_schema_location (const std::basic_string<C>& location);
+};
+  
+class error_handler
+{
+public:
+  struct severity
+  {
+    enum value
+    {
+      warning,
+      error,
+      fatal
+    };
+  };
+
+  virtual bool
+  handle (const std::basic_string<C>& id,
+          unsigned long line,
+          unsigned long column,
+          severity,
+          const std::basic_string<C>& message) = 0;
+
+  virtual
+  ~error_handler ();
+};
+  
+struct severity
+{
+  enum value
+  {
+    warning,
+    error
+  };
+
+  severity (value);
+  operator value () const;
+};
+
+struct error
+{
+  error (severity,
+         const std::basic_string<C>& id,
+         unsigned long line,
+         unsigned long column,
+         const std::basic_string<C>& message);
+
+  severity
+  severity () const;
+
+  const std::basic_string<C>&
+  id () const;
+
+  unsigned long
+  line () const;
+
+  unsigned long
+  column () const;
+
+  const std::basic_string<C>&
+  message () const;
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const error&);
+
+struct diagnostics: std::vector<error>
+{
+};
+
+std::basic_ostream<C>&
+operator<< (std::basic_ostream<C>&, const diagnostics&);
+
+struct parsing: virtual exception
+{
+  parsing ();
+  parsing (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct expected_element: virtual exception
+{
+  expected_element (const std::basic_string<C>& name,
+                    const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct unexpected_element: virtual exception
+{
+  unexpected_element (const std::basic_string<C>& encountered_name,
+                      const std::basic_string<C>& encountered_namespace,
+                      const std::basic_string<C>& expected_name,
+                      const std::basic_string<C>& expected_namespace)
+
+
+  const std::basic_string<C>&
+  encountered_name () const;
+
+  const std::basic_string<C>&
+  encountered_namespace () const;
+
+
+  const std::basic_string<C>&
+  expected_name () const;
+
+  const std::basic_string<C>&
+  expected_namespace () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct expected_attribute: virtual exception
+{
+  expected_attribute (const std::basic_string<C>& name,
+                      const std::basic_string<C>& namespace_);
+
+
+  const std::basic_string<C>&
+  name () const;
+
+  const std::basic_string<C>&
+  namespace_ () const;
+
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct unexpected_enumerator: virtual exception
+{
+  unexpected_enumerator (const std::basic_string<C>& enumerator);
+
+  const std::basic_string<C>&
+  enumerator () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct expected_text_content: virtual exception
+{
+  virtual const char*
+  what () const throw ();
+};
+  
+struct no_type_info: virtual exception
+{
+  no_type_info (const std::basic_string<C>& type_name,
+                const std::basic_string<C>& type_namespace);
+
+  const std::basic_string<C>&
+  type_name () const;
+
+  const std::basic_string<C>&
+  type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct not_derived: virtual exception
+{
+  not_derived (const std::basic_string<C>& base_type_name,
+               const std::basic_string<C>& base_type_namespace,
+               const std::basic_string<C>& derived_type_name,
+               const std::basic_string<C>& derived_type_namespace);
+
+  const std::basic_string<C>&
+  base_type_name () const;
+
+  const std::basic_string<C>&
+  base_type_namespace () const;
+
+
+  const std::basic_string<C>&
+  derived_type_name () const;
+
+  const std::basic_string<C>&
+  derived_type_namespace () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+struct no_prefix_mapping: virtual exception
+{
+  no_prefix_mapping (const std::basic_string<C>& prefix);
+
+  const std::basic_string<C>&
+  prefix () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+using std::auto_ptr;
+
+auto_ptr<type> r1 (name ("test.xml"));
+auto_ptr<type> r2 (name ("http://www.codesynthesis.com/test.xml"));
+  
+using std::auto_ptr;
+
+{
+  std::ifstream ifs ("test.xml");
+  auto_ptr<type> r (name (ifs, "test.xml"));
+}
+
+{
+  std::string str ("..."); // Some XML fragment.
+  std::istringstream iss (str);
+  auto_ptr<type> r (name (iss));
+}
+  
+xercesc::StdInInputSource is;
+std::auto_ptr<type> r (name (is));
+  
+xml_schema::dom::auto_ptr<xercesc::DOMDocument> doc = ...
+
+std::auto_ptr<type> r (
+  name (doc, xml_schema::flags::keep_dom | xml_schema::flags::own_dom));
+
+// At this point doc is reset to 0.
+  
+<xsd:element name="name" type="type"/>
+  
+// Serialize to std::ostream.
+//
+void
+name (std::ostream&,
+      const type&,
+      const xml_schema::namespace_fomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (std::ostream&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to XMLFormatTarget.
+//
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xml_schema::error_handler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+void
+name (xercesc::XMLFormatTarget&,
+      const type&,
+      xercesc::DOMErrorHandler&,
+      const xml_schema::namespace_infomap& =
+        xml_schema::namespace_infomap (),
+      const std::basic_string<C>& encoding = "UTF-8",
+      xml_schema::flags = 0);
+
+
+// Serialize to DOM.
+//
+xml_schema::dom::auto_ptr<xercesc::DOMDocument>
+name (const type&,
+      const xml_schema::namespace_infomap&
+        xml_schema::namespace_infomap (),
+      xml_schema::flags = 0);
+
+void
+name (xercesc::DOMDocument&,
+      const type&,
+      xml_schema::flags = 0);
+  
+struct namespace_info
+{
+  namespace_info ();
+  namespace_info (const std::basic_string<C>& name,
+                  const std::basic_string<C>& schema);
+
+  std::basic_string<C> name;
+  std::basic_string<C> schema;
+};
+
+// Map of namespace prefix to namespace_info.
+//
+struct namespace_infomap: public std::map<std::basic_string<C>,
+                                          namespace_info>
+{
+};
+  
+xml_schema::namespace_infomap map;
+
+map["t"].name = "http://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+  
+<?xml version="1.0" ?>
+<t:name xmlns:t="http://www.codesynthesis.com/test"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://www.codesynthesis.com/test test.xsd">
+  
+xml_schema::namespace_infomap map;
+
+map["xsn"].name = "http://www.w3.org/2001/XMLSchema-instance";
+
+map["t"].name = "http://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+  
+<?xml version="1.0" ?>
+<t:name xmlns:t="http://www.codesynthesis.com/test"
+        xmlns:xsn="http://www.w3.org/2001/XMLSchema-instance"
+        xsn:schemaLocation="http://www.codesynthesis.com/test test.xsd">
+  
+xml_schema::namespace_infomap map;
+
+map[""].schema = "test.xsd";
+  
+<?xml version="1.0" ?>
+<name xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:noNamespaceSchemaLocation="test.xsd">
+  
+xml_schema::namespace_infomap map;
+
+map[""].name = "http://www.codesynthesis.com/test";
+map[""].schema = "test.xsd";
+  
+<?xml version="1.0" ?>
+<name xmlns="http://www.codesynthesis.com/test"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://www.codesynthesis.com/test test.xsd">
+  
+std::auto_ptr<type> r = ...
+std::ofstream ofs ("test.xml");
+xml_schema::namespace_infomap map;
+name (ofs,
+      *r,
+      map,
+      "UTF-8",
+      xml_schema::flags::no_xml_declaration |
+      xml_schema::flags::dont_pretty_print);
+  
+struct serialization: virtual exception
+{
+  serialization ();
+  serialization (const diagnostics&);
+
+  const diagnostics&
+  diagnostics () const;
+
+  virtual const char*
+  what () const throw ();
+};
+  
+// Obtain the object model.
+//
+std::auto_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "http://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+// Write it out.
+//
+name (std::cout, *r, map);
+  
+using std::auto_ptr;
+
+// Obtain the object model.
+//
+auto_ptr<type> r = ...
+
+// Prepare namespace mapping and schema location information.
+//
+xml_schema::namespace_infomap map;
+
+map["t"].name = "http://www.codesynthesis.com/test";
+map["t"].schema = "test.xsd";
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Choose a target.
+  //
+  auto_ptr<XMLFormatTarget> ft;
+
+  if (argc != 2)
+  {
+    ft = auto_ptr<XMLFormatTarget> (new StdOutFormatTarget ());
+  }
+  else
+  {
+    ft = auto_ptr<XMLFormatTarget> (
+      new LocalFileFormatTarget (argv[1]));
+  }
+
+  // Write it out.
+  //
+  name (*ft, *r, map);
+}
+
+XMLPlatformUtils::Terminate ();
+  
+// Obtain the object model.
+//
+std::auto_ptr<type> r = ...
+
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Create a DOM instance. Set custom namespace mapping and schema
+  // location attributes.
+  //
+  DOMDocument& doc = ...
+
+  // Serialize to DOM.
+  //
+  name (doc, *r);
+
+  // Serialize the DOM document to XML.
+  //
+  ...
+}
+
+XMLPlatformUtils::Terminate ();
+  
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::auto_ptr<type> r = root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize);
+
+   // Copy without DOM association.
+   //
+   type copy1 (*r);
+
+   // Copy with DOM association.
+   //
+   type copy2 (*r, xml_schema::flags::keep_dom);
+}
+
+XMLPlatformUtils::Terminate ();
+  
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+  
+using namespace xercesc;
+
+XMLPlatformUtils::Initialize ();
+
+{
+  // Parse XML to object model.
+  //
+  std::auto_ptr<type> r = root (
+    "root.xml",
+     xml_schema::flags::keep_dom |
+     xml_schema::flags::dont_initialize);
+
+  DOMNode* n = root->_node ();
+  assert (n->getNodeType () == DOMNode::ELEMENT_NODE);
+  DOMElement* re = static_cast<DOMElement*> (n);
+
+  // Get the 'a' element. Note that it is not necessarily the
+  // first child node of 'root' since there could be whitespace
+  // nodes before it.
+  //
+  DOMElement* ae;
+
+  for (n = re->getFirstChild (); n != 0; n = n->getNextSibling ())
+  {
+    if (n->getNodeType () == DOMNode::ELEMENT_NODE)
+    {
+      ae = static_cast<DOMElement*> (n);
+      break;
+    }
+  }
+
+  // Get from the 'a' DOM element to xml_schema::string object model
+  // node.
+  //
+  xml_schema::type& t (
+    *reinterpret_cast<xml_schema::type*> (
+       ae->getUserData (xml_schema::dom::tree_node_key)));
+
+  xml_schema::string& a (dynamic_cast<xml_schema::string&> (t));
+}
+
+XMLPlatformUtils::Terminate ();
+  
+<complexType name="object">
+  <sequence>
+    <element name="a" type="string"/>
+    <element name="b" type="int"/>
+  </sequence>
+</complexType>
+
+<element name="root" type="object"/>
+  
+// Parse XML to object model.
+//
+std::auto_ptr<type> r = root ("root.xml");
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ostream<ACE_OutputCDR> ocdr (ace_ocdr);
+
+ocdr << *r;
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::istream<ACE_InputCDR> icdr (ace_icdr);
+
+std::auto_ptr<object> copy (new object (icdr));
+
+// Serialize to XML.
+//
+root (std::cout, *copy);
+

XML Schema type	Alias in the `xml_schema` namespace	C++ type
fixed-length integral types
`byte`	`byte`	`signed char`
`unsignedByte`	`unsigned_byte`	`unsigned char`
`short`	`short_`	`short`
`unsignedShort`	`unsigned_short`	`unsigned short`
`int`	`int_`	`int`
`unsignedInt`	`unsigned_int`	`unsigned int`
`long`	`long_`	`long long`
`unsignedLong`	`unsigned_long`	`unsigned long long`
arbitrary-length integral types
`integer`	`integer`	`long long`
`nonPositiveInteger`	`non_positive_integer`	`long long`
`nonNegativeInteger`	`non_negative_integer`	`unsigned long long`
`positiveInteger`	`positive_integer`	`unsigned long long`
`negativeInteger`	`negative_integer`	`long long`
boolean types
`boolean`	`boolean`	`bool`
fixed-precision floating-point types
`float`	`float_`	`float`
`double`	`double_`	`double`
arbitrary-precision floating-point types
`decimal`	`decimal`	`double`
string types
`string`	`string`	type derived from `std::basic_string`
`normalizedString`	`normalized_string`	type derived from `string`
`token`	`token`	type derived from `normalized_string`
`Name`	`name`	type derived from `token`
`NMTOKEN`	`nmtoken`	type derived from `token`
`NMTOKENS`	`nmtokens`	type derived from `sequence<nmtoken>`
`NCName`	`ncname`	type derived from `name`
`language`	`language`	type derived from `token`
qualified name
`QName`	`qname`	`xml_schema::qname`
ID/IDREF types
`ID`	`id`	type derived from `ncname`
`IDREF`	`idref`	type derived from `ncname`
`IDREFS`	`idrefs`	type derived from `sequence<idref>`
URI types
`anyURI`	`uri`	type derived from `std::basic_string`
binary types
`base64Binary`	`base64_binary`	`xml_schema::base64_binary`
`hexBinary`	`hex_binary`	`xml_schema::hex_binary`
date/time types
`date`	`date`	`xml_schema::date`
`dateTime`	`date_time`	`xml_schema::date_time`
`duration`	`duration`	`xml_schema::duration`
`gDay`	`gday`	`xml_schema::gday`
`gMonth`	`gmonth`	`xml_schema::gmonth`
`gMonthDay`	`gmonth_day`	`xml_schema::gmonth_day`
`gYear`	`gyear`	`xml_schema::gyear`
`gYearMonth`	`gyear_month`	`xml_schema::gyear_month`
`time`	`time`	`xml_schema::time`
entity types
`ENTITY`	`entity`	type derived from `name`
`ENTITIES`	`entities`	type derived from `sequence<entity>`

XML Schema type	Alias in the `xml_schema` namespace	C++ type
anyType and anySimpleType types
`anyType`	`type`	Section 2.5.2, "Mapping for `anyType`"
`anySimpleType`	`simple_type`	Section 2.5.3, "Mapping for `anySimpleType`"
fixed-length integral types
`byte`	`byte`	`signed char`
`unsignedByte`	`unsigned_byte`	`unsigned char`
`short`	`short_`	`short`
`unsignedShort`	`unsigned_short`	`unsigned short`
`int`	`int_`	`int`
`unsignedInt`	`unsigned_int`	`unsigned int`
`long`	`long_`	`long long`
`unsignedLong`	`unsigned_long`	`unsigned long long`
arbitrary-length integral types
`integer`	`integer`	`long long`
`nonPositiveInteger`	`non_positive_integer`	`long long`
`nonNegativeInteger`	`non_negative_integer`	`unsigned long long`
`positiveInteger`	`positive_integer`	`unsigned long long`
`negativeInteger`	`negative_integer`	`long long`
boolean types
`boolean`	`boolean`	`bool`
fixed-precision floating-point types
`float`	`float_`	`float`
`double`	`double_`	`double`
arbitrary-precision floating-point types
`decimal`	`decimal`	`double`
string types
`string`	`string`	type derived from `std::basic_string`
`normalizedString`	`normalized_string`	type derived from `string`
`token`	`token`	type derived from `normalized_string`
`Name`	`name`	type derived from `token`
`NMTOKEN`	`nmtoken`	type derived from `token`
`NMTOKENS`	`nmtokens`	type derived from `sequence<nmtoken>`
`NCName`	`ncname`	type derived from `name`
`language`	`language`	type derived from `token`
qualified name
`QName`	`qname`	Section 2.5.4, "Mapping for `QName`"
ID/IDREF types
`ID`	`id`	type derived from `ncname`
`IDREF`	`idref`	Section 2.5.5, "Mapping for `IDREF`"
`IDREFS`	`idrefs`	type derived from `sequence<idref>`
URI types
`anyURI`	`uri`	type derived from `std::basic_string`
binary types
`base64Binary`	`base64_binary`	Section 2.5.6, "Mapping for + `base64Binary` and `hexBinary`"
`hexBinary`	`hex_binary`
date/time types
`date`	`date`	Section 2.5.8, "Mapping for + `date`"
`dateTime`	`date_time`	Section 2.5.9, "Mapping for + `dateTime`"
`duration`	`duration`	Section 2.5.10, "Mapping for + `duration`"
`gDay`	`gday`	Section 2.5.11, "Mapping for + `gDay`"
`gMonth`	`gmonth`	Section 2.5.12, "Mapping for + `gMonth`"
`gMonthDay`	`gmonth_day`	Section 2.5.13, "Mapping for + `gMonthDay`"
`gYear`	`gyear`	Section 2.5.14, "Mapping for + `gYear`"
`gYearMonth`	`gyear_month`	Section 2.5.15, "Mapping for + `gYearMonth`"
`time`	`time`	Section 2.5.16, "Mapping for + `time`"
entity types
`ENTITY`	`entity`	type derived from `name`
`ENTITIES`	`entities`	type derived from `sequence<entity>`

		default		fixed
element	not present	optional	required	optional	required
	not present	not present	invalid instance	not present	invalid instance
	empty	default value is used		fixed value is used
	value	value is used		value is used provided it's the same as fixed
attribute	not present	optional	required	optional	required
	not present	default value is used	invalid schema	fixed value is used	invalid instance
	empty	empty value is used		empty value is used provided it's the same as fixed
	value	value is used		value is used provided it's the same as fixed

C++/Tree Mapping

Getting Started Guide

Table of Contents

Table of Contents

C++/Tree Mapping User Manual