Embedded C++/Hybrid Mapping

name · mixin

+<?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">
+    <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"/>
+
+</xs:schema>
+  
+$ xsde cxx-hybrid --generate-parser --generate-aggregate hello.xsd
+  
+class hello
+{
+public:
+  hello ();
+
+  // greeting
+  //
+  const std::string&
+  greeting () const;
+
+  std::string&
+  greeting ();
+
+  void
+  greeting (const std::string&);
+
+  // name
+  //
+  typedef xml_schema::string_sequence name_sequence;
+  typedef name_sequence::iterator name_iterator;
+  typedef name_sequence::const_iterator name_const_iterator;
+
+  const name_sequence&
+  name () const;
+
+  name_sequence&
+  name ();
+
+private:
+  ...
+};
+  
+#include <iostream>
+
+#include "hello.hxx"
+#include "hello-pimpl.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+    //
+    hello_paggr hello_p;
+    xml_schema::document_pimpl doc_p (hello_p.root_parser (),
+                                      hello_p.root_name ());
+    hello_p.pre ();
+    doc_p.parse (argv[1]);
+    hello* h = hello_p.post ();
+
+    // Print what we've got.
+    //
+    for (hello::name_const_iterator i = h->name ().begin ();
+         i != h->name ().end ();
+         ++i)
+    {
+      cout << h->greeting () << ", " << *i << "!" << endl;
+    }
+
+    delete h;
+  }
+  catch (const xml_schema::parser_exception& e)
+  {
+    cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+         << ": " << e.text () << endl;
+    return 1;
+  }
+}
+  
+$ c++ -I.../libxsde -c driver.cxx hello.cxx hello-pskel.cxx \
+  hello-pimpl.cxx
+
+$ c++ -o driver driver.o hello.o hello-pskel.o hello-pimpl.o \
+  .../libxsde/xsde/libxsde.a
+
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+  
+$ ./driver hello.hxx
+hello.hxx:1:0: not well-formed (invalid token)
+  
+$ ./driver hello.xsd
+hello.xsd:2:57: unexpected element encountered
+  
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+  --generate-aggregate hello.xsd
+  
+#include <iostream>
+
+#include "hello.hxx"
+#include "hello-pimpl.hxx"
+#include "hello-simpl.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse.
+    //
+    hello_paggr hello_p;
+    xml_schema::document_pimpl doc_p (hello_p.root_parser (),
+                                      hello_p.root_name ());
+    hello_p.pre ();
+    doc_p.parse (argv[1]);
+    hello* h = hello_p.post ();
+
+    // 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.
+    //
+    hello_saggr hello_s;
+    xml_schema::document_simpl doc_s (hello_s.root_serializer (),
+                                      hello_s.root_name ());
+    hello_s.pre (*h);
+    doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+    hello_s.post ();
+
+    delete h;
+  }
+  catch (const xml_schema::parser_exception& e)
+  {
+    cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+         << ": " << e.text () << endl;
+    return 1;
+  }
+  catch (const xml_schema::serializer_exception& e)
+  {
+    cerr << "error: " << e.text () << endl;
+    return 1;
+  }
+}
+  
+<hello>
+  <greeting>Hi</greeting>
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+  <name>mars</name>
+</hello>
+  
+h->name ().clear ();
+  
+$ ./driver hello.xml
+error: expected element not encountered
+  
+#include <sstream>
+#include <iostream>
+
+#include "hello.hxx"
+#include "hello-simpl.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    hello h;
+    h.greeting ("Hi");
+
+    hello::name_sequence& ns = h.name ();
+    ns.push_back ("Jane");
+    ns.push_back ("John");
+
+    // Serialize the object model to XML.
+    //
+    hello_saggr hello_s;
+    xml_schema::document_simpl doc_s (hello_s.root_serializer (),
+                                      hello_s.root_name ());
+    ostringstream ostr;
+
+    hello_s.pre (h);
+    doc_s.serialize (ostr, xml_schema::document_simpl::pretty_print);
+    hello_s.post ();
+
+    cout << ostr.str () << endl;
+  }
+  catch (const xml_schema::serializer_exception& e)
+  {
+    cerr << "error: " << e.text () << endl;
+    return 1;
+  }
+}
+  
+<hello>
+  <greeting>Hi</greeting>
+  <name>Jane</name>
+  <name>John</name>
+</hello>
+  
+$ xsde cxx-hybrid --no-stl --no-iostream --no-exceptions \
+  --generate-parser --generate-serializer --generate-aggregate \
+  hello.xsd
+  
+#include <stdio.h>
+
+#include "people.hxx"
+
+#include "people-pimpl.hxx"
+#include "people-simpl.hxx"
+
+using namespace std;
+
+struct writer: xml_schema::writer
+{
+  virtual bool
+  write (const char* s, size_t n)
+  {
+    return fwrite (s, n, 1, stdout) == 1;
+  }
+
+  virtual bool
+  flush ()
+  {
+    return fflush (stdout) == 0;
+  }
+};
+
+int
+main (int argc, char* argv[])
+{
+  // Open the file or use STDIN.
+  //
+  FILE* f = fopen (argv[1], "rb");
+
+  if (f == 0)
+  {
+    fprintf (stderr, "%s: unable to open\n", argc);
+    return 1;
+  }
+
+  // Parse.
+  //
+  using xml_schema::parser_error;
+
+  parser_error pe;
+  bool io_error = false;
+  hello* h = 0;
+
+  do
+  {
+    hello_paggr hello_p;
+    xml_schema::document_pimpl doc_p (hello_p.root_parser (),
+                                      hello_p.root_name ());
+    if (pe = doc_p._error ())
+      break;
+
+    hello_p.pre ();
+
+    if (pe = hello_p._error ())
+      break;
+
+    char buf[4096];
+
+    do
+    {
+      size_t s = fread (buf, 1, sizeof (buf), f);
+
+      if (s != sizeof (buf) && ferror (f))
+      {
+        io_error = true;
+        break;
+      }
+
+      doc_p.parse (buf, s, feof (f) != 0);
+      pe = doc_p._error ();
+
+    } while (!pe && !feof (f));
+
+    if (io_error || pe)
+      break;
+
+    h = hello_p.post ();
+    pe = hello_p._error ();
+
+  } while (false);
+
+  fclose (f);
+
+  // Handle parsing errors.
+  //
+  if (io_error)
+  {
+    fprintf (stderr, "%s: read failure\n", argc);
+    return 1;
+  }
+
+  if (pe)
+  {
+    switch (pe.type ())
+    {
+    case parser_error::sys:
+      {
+        fprintf (stderr, "%s: %s\n", argc, pe.sys_text ());
+        break;
+      }
+    case parser_error::xml:
+      {
+        fprintf (stderr, "%s:%lu:%lu: %s\n",
+                 argc, pe.line (), pe.column (), pe.xml_text ());
+        break;
+      }
+    case parser_error::schema:
+      {
+        fprintf (stderr, "%s:%lu:%lu: %s\n",
+                 argc, pe.line (), pe.column (), pe.schema_text ());
+        break;
+      }
+    default:
+      break;
+    }
+
+    return 1;
+  }
+
+  // Print what we've got.
+  //
+  for (hello::name_const_iterator i = h->name ().begin ();
+       i != h->name ().end ();
+       ++i)
+  {
+    printf ("%s, %s!\n", h->greeting (), *i);
+  }
+
+  using xml_schema::strdupx;
+
+  // Change the greeting phrase.
+  //
+  char* str = strdupx ("Hi");
+
+  if (str == 0)
+  {
+    fprintf (stderr, "error: no memory\n");
+    delete h;
+    return 1;
+  }
+
+  h->greeting (str);
+
+  // Add another entry to the name sequence.
+  //
+  str = strdupx ("mars");
+
+  if (str == 0)
+  {
+    fprintf (stderr, "error: no memory\n");
+    delete h;
+    return 1;
+  }
+
+  if (h->name ().push_back (str) != 0)
+  {
+    // The sequence has already freed str.
+    //
+    fprintf (stderr, "error: no memory\n");
+    delete h;
+    return 1;
+  }
+
+  // Serialize.
+  //
+  using xml_schema::serializer_error;
+
+  serializer_error se;
+  writer w;
+
+  do
+  {
+    hello_saggr hello_s;
+    xml_schema::document_simpl doc_s (hello_s.root_serializer (),
+                                      hello_s.root_name ());
+    if (se = doc_s._error ())
+      break;
+
+    hello_s.pre (*h);
+
+    if (se = hello_s._error ())
+      break;
+
+    doc_s.serialize (w, xml_schema::document_simpl::pretty_print);
+
+    if (se = doc_s._error ())
+      break;
+
+    hello_s.post ();
+
+    se = hello_s._error ();
+
+  } while (false);
+
+  delete h;
+
+  // Handle serializer errors.
+  //
+  if (se)
+  {
+    switch (se.type ())
+    {
+    case serializer_error::sys:
+      {
+        fprintf (stderr, "error: %s\n", se.sys_text ());
+        break;
+      }
+    case serializer_error::xml:
+      {
+        fprintf (stderr, "error: %s\n", se.xml_text ());
+        break;
+      }
+    case serializer_error::schema:
+      {
+        fprintf (stderr, "error: %s\n", se.schema_text ());
+        break;
+      }
+    default:
+      break;
+    }
+
+    return 1;
+  }
+}
+  
+xml_schema::iso8859_1::unrep_char ('?');
+  
+namespace xml_schema
+{
+  char*
+  strdupx (const char*);
+
+  char*
+  strndupx (const char*, size_t);
+}
+  
+<!-- 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>
+  
+<!-- 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:complexType name="root">
+    <xs:sequence>
+      <xs:element ref="base" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- document root -->
+  <xs:element name="root" type="root"/>
+
+</xs:schema>
+  
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+--generate-polymorphic --polymorphic-type base \
+--generate-aggregate --root-element root base.xsd
+  
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+--generate-polymorphic --polymorphic-type base \
+--generate-aggregate --root-element root base.xsd derived.xsd
+  
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+--generate-polymorphic --polymorphic-type base \
+--generate-aggregate --root-element root \
+--polymorphic-schema derived.xsd base.xsd
+
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+--generate-polymorphic --polymorphic-type base derived.xsd
+  
+extern "C" void*
+xsde_alloc (size_t);
+
+extern "C" void*
+xsde_realloc (void*, size_t);
+
+extern "C" void
+xsde_free (void*);
+  
+namespace xml_schema
+{
+  void*
+  alloc (size_t);
+
+  void
+  free (void*);
+
+  struct alloc_guard
+  {
+    alloc_guard (void*);
+    ~alloc_guard ();
+
+    void*
+    get () const;
+
+    void
+    release ();
+
+  private:
+    ...
+  };
+}
+  
+void* v = xml_schema::alloc (sizeof (type));
+
+if (v == 0)
+{
+  // Handle out of memory condition.
+}
+
+type* x = new (v) type (1, 2);
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+xml_schema::alloc_guard g (xml_schema::alloc (sizeof (type)));
+type* x = new (g.get ()) type (1, 2);
+g.release ();
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person">
+    <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"/>
+      <xs:element name="age" type="xs:unsignedShort"/>
+    </xs:sequence>
+    <xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  </xs:complexType>
+
+  <xs:complexType name="people">
+    <xs:sequence>
+      <xs:element name="person" type="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people"/>
+
+</xs:schema>
+  
+<?xml version="1.0"?>
+<people>
+
+  <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>
+  
+// gender (fixed-length)
+//
+class gender
+{
+public:
+  enum value_type
+  {
+    male,
+    female
+  };
+
+  gender ();
+  gender (value_type);
+  gender (const gender&);
+  gender& operator= (const gender&);
+
+  void
+  value (value_type);
+
+  operator value_type () const;
+
+  const char*
+  string () const;
+
+private:
+  ...
+};
+
+// person (fixed-length)
+//
+class person
+{
+public:
+  person ();
+  person (const person&);
+  person& operator= (const person&);
+
+  // id
+  //
+  unsigned int
+  id () const;
+
+  unsigned int&
+  id ();
+
+  void
+  id (unsigned int);
+
+  // first-name
+  //
+  const std::string&
+  first_name () const;
+
+  std::string&
+  first_name ();
+
+  void
+  first_name (const std::string&);
+
+  // middle-name
+  //
+  bool
+  middle_name_present () const;
+
+  void
+  middle_name_present (bool);
+
+  const std::string&
+  middle_name () const;
+
+  std::string&
+  middle_name ();
+
+  void
+  middle_name (const std::string&);
+
+  // last-name
+  //
+  const std::string&
+  last_name () const;
+
+  std::string&
+  last_name ();
+
+  void
+  last_name (const std::string&);
+
+  // gender
+  //
+  const ::gender&
+  gender () const;
+
+  ::gender&
+  gender ();
+
+  void
+  gender (const ::gender&);
+
+  // age
+  //
+  unsigned short
+  age () const;
+
+  unsigned short&
+  age ();
+
+  void
+  age (unsigned short);
+
+private:
+  ...
+};
+
+// people (variable-length)
+//
+class people
+{
+public:
+  people ();
+
+private:
+  people (const people&);
+  people& operator= (const people&);
+
+public:
+  // person
+  //
+  typedef xml_schema::fix_sequence<person> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+
+private:
+  ...
+};
+  
+--namespace-map http://www.codesynthesis.com/my=cs::my
+  
+--namespace-map =records
+  
+<xs:complexType name="staff">
+  <xs:sequence>
+    <xs:element name="permanent" type="people"/>
+    <xs:element name="contract" type="people"/>
+  </xs:sequence>
+</xs:complexType>
+  
+// staff (variable-length)
+//
+class staff
+{
+public:
+  staff ();
+
+  staff*
+  _clone () const;
+
+private:
+  staff (const staff&);
+  staff& operator= (const staff&);
+
+public:
+  // permanent
+  //
+  const people&
+  permanent () const;
+
+  people&
+  permanent ();
+
+  void
+  permanent (people*);
+
+  people*
+  permanent_detach ();
+
+  // contract
+  //
+  const people&
+  contract () const;
+
+  people&
+  contract ();
+
+  void
+  contract (people*);
+
+  people*
+  contract_detach ();
+
+private:
+  ...
+};
+  
+people* per = new people;
+people* con = new people;
+
+// Populate per and con.
+
+staff s;
+s->permanent (per) // Assumes ownership of per.
+s->contract (con)  // Assumes ownership of con.
+  
+// gender (fixed-length)
+//
+class gender
+{
+public:
+  enum value_type
+  {
+    male,
+    female
+  };
+
+  gender ();
+  gender (value_type);
+  gender (const gender&);
+  gender& operator= (const gender&);
+
+  void
+  value (value_type);
+
+  operator value_type () const;
+
+  const char*
+  string () const;
+
+private:
+  value_type v_;
+};
+
+gender g = gender::male;
+g = gender::female;
+g.value (gender::female); // Same as above.
+
+cerr << g.string () << endl;
+
+if (g != gender::male)
+  ...
+
+switch (g)
+{
+case gender::male:
+  ...
+case gender::female:
+  ...
+}
+  
+class person
+{
+  // first-name
+  //
+  const std::string&
+  first_name () const;
+
+  std::string&
+  first_name ();
+
+  void
+  first_name (const std::string&);
+};
+  
+class person
+{
+  // middle-name
+  //
+  bool
+  middle_name_present () const;
+
+  void
+  middle_name_present (bool);
+
+  const std::string&
+  middle_name () const;
+
+  std::string&
+  middle_name ();
+
+  void
+  middle_name (const std::string&);
+};
+  
+person& p = ...
+
+if (p.middle_name_present ())
+{
+  cout << p.middle_name () << endl;
+  p.middle_name_present (false); // Reset to the "not present" state.
+}
+  
+person& p = ...
+
+if (p.middle_name_present ())
+{
+  cout << *p.middle_name () << endl;
+  p.middle_name (0); // Reset to the "not present" state.
+}
+  
+<xs:complexType name="person">
+  <xs:sequence>
+    <xs:element name="first-name" type="xs:string"/>
+    ...
+  </xs:sequence>
+  <xs:attribute name="id" type="xs:unsignedInt" use="required"/>
+  <xs:attribute name="verified" type="xs:boolean" default="false"/>
+</xs:complexType>
+  
+class person
+{
+  // verified
+  //
+  bool
+  verified_default () const;
+
+  void
+  verified_default (bool);
+
+  bool
+  verified () const;
+
+  bool&
+  verified ();
+
+  void
+  verified (bool);
+
+  static bool
+  verified_default_value ();
+};
+  
+person p; // verified is set to the default value (false).
+
+if (p.verified_default ())
+  p.verified (true);
+else
+  p.verified_default (true); // Revert to the default value.
+
+bool v = p.verified (); // Ok, can always be called.
+bool vd = person::verified_default_value ();
+  
+type& x = ...
+
+if (x.foo_default ())
+{
+  foo& f = x.foo (); // foo is variable-length, for example NMTOKENS
+  f.push_back ("aaa"); // Illegal.
+}
+
+if (x.foo_default ())
+{
+  foo* f = new foo;
+  f->push_back ("aaa");
+  x.foo (f); // Ok.
+}
+  
+<xs:complexType name="person">
+  ...
+  <xs:attribute name="verified" type="xs:boolean" fixed="true"/>
+</xs:complexType>
+  
+class person
+{
+  // verified
+  //
+  bool
+  verified () const;
+
+  static bool
+  verified_fixed_value ();
+};
+  
+class people
+{
+  // person
+  //
+  typedef xml_schema::fix_sequence<person> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+};
+  
+namespace xml_schema
+{
+  template <typename T>
+  class fix_sequence
+  {
+  public:
+    typedef T         value_type;
+    typedef T*        pointer;
+    typedef const T*  const_pointer;
+    typedef T&        reference;
+    typedef const T&  const_reference;
+
+    typedef size_t    size_type;
+    typedef ptrdiff_t difference_type;
+
+    typedef T*        iterator;
+    typedef const T*  const_iterator;
+
+  public:
+    fix_sequence ();
+
+    void
+    swap (fix_sequence&);
+
+  private:
+    fix_sequence (const fix_sequence&);
+
+    fix_sequence&
+    operator= (fix_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    T&
+    front ();
+
+    const T&
+    front () const;
+
+    T&
+    back ();
+
+    const T&
+    back () const;
+
+    T&
+    operator[] (size_t);
+
+    const T&
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (const T&);
+
+    iterator
+    insert (iterator, const T&);
+
+    void
+    reserve (size_t);
+
+    void
+    assign (const T* src, size_t n);
+  };
+}
+  
+namespace xml_schema
+{
+  template <typename T>
+  class fix_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (const T&);
+
+    error
+    insert (iterator, const T&);
+
+    error
+    insert (iterator, const T&, iterator& result);
+
+    error
+    reserve (size_t);
+
+    error
+    assign (const T* src, size_t n);
+  };
+}
+  
+namespace xml_schema
+{
+  template <typename T>
+  class var_sequence
+  {
+  public:
+    typedef T         value_type;
+    typedef T*        pointer;
+    typedef const T*  const_pointer;
+    typedef T&        reference;
+    typedef const T&  const_reference;
+
+    typedef size_t    size_type;
+    typedef ptrdiff_t difference_type;
+
+    typedef <implementation details> iterator;
+    typedef <implementation details> const_iterator;
+
+  public:
+    var_sequence ();
+
+    void
+    swap (var_sequence&);
+
+  private:
+    var_sequence (const var_sequence&);
+
+    var_sequence&
+    operator= (var_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    T&
+    front ();
+
+    const T&
+    front () const;
+
+    T&
+    back ();
+
+    const T&
+    back () const;
+
+    T&
+    operator[] (size_t);
+
+    const T&
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    push_back (T*);
+
+    iterator
+    insert (iterator, T*);
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    reserve (size_t);
+
+    T*
+    detach (iterator);
+
+    void
+    attach (iterator, T*);
+  };
+}
+  
+namespace xml_schema
+{
+  template <typename T>
+  class var_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (T*);
+
+    error
+    insert (iterator, T*);
+
+    error
+    insert (iterator, T*, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    typedef char*         value_type;
+    typedef char**        pointer;
+    typedef const char**  const_pointer;
+    typedef char*         reference;
+    typedef const char*   const_reference;
+
+    typedef size_t        size_type;
+    typedef ptrdiff_t     difference_type;
+
+    typedef char** iterator;
+    typedef const char* const* const_iterator;
+
+    string_sequence ();
+
+    void
+    swap (string_sequence&);
+
+  private:
+    string_sequence (string_sequence&);
+
+    string_sequence&
+    operator= (string_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    char*
+    front ();
+
+    const char*
+    front () const;
+
+    char*
+    back ();
+
+    const char*
+    back () const;
+
+    char*
+    operator[] (size_t);
+
+    const char*
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (char*);
+
+    void
+    push_back_copy (const char*);
+
+    iterator
+    insert (iterator, char*);
+
+    void
+    reserve (size_t);
+
+    char*
+    detach (iterator);
+
+    void
+    attach (iterator, char*);
+  };
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (char*);
+
+    error
+    push_back_copy (const char*);
+
+    error
+    insert (iterator, char*);
+
+    error
+    insert (iterator, char*, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+<complexType name="type">
+  <sequence>
+    <sequence minOccurs="0">
+      <element name="a" type="int"/>
+      <element name="b" type="string" maxOccurs="unbounded"/>
+    </sequence>
+    <sequence maxOccurs="unbounded">
+      <element name="c" type="int"/>
+      <element name="d" type="string"/>
+    </sequence>
+  </sequence>
+</complexType>
+  
+// type (variable-length)
+//
+class type
+{
+public:
+  type ();
+
+private:
+  type (const type&);
+  type& operator= (const type&);
+
+public:
+  // sequence (variable-length)
+  //
+  class sequence_type
+  {
+  public:
+    sequence_type ();
+
+  private:
+    sequence_type (const sequence_type&);
+    sequence_type& operator= (const sequence_type&);
+
+  public:
+    // a
+    //
+    int
+    a () const;
+
+    int&
+    a ();
+
+    void
+    a (int);
+
+    // b
+    //
+    typedef xml_schema::string_sequence b_sequence;
+    typedef b_sequence::iterator b_iterator;
+    typedef b_sequence::const_iterator b_const_iterator;
+
+    const b_sequence&
+    b () const;
+
+    b_sequence&
+    b ();
+
+  private:
+    ...
+  };
+
+  bool
+  sequence_present () const;
+
+  const sequence_type&
+  sequence () const;
+
+  sequence_type&
+  sequence ();
+
+  void
+  sequence (sequence_type*);
+
+  // sequence1 (fixed-length)
+  //
+  class sequence1_type
+  {
+  public:
+    sequence1_type ();
+    sequence1_type (const sequence1_type&);
+    sequence1_type& operator= (const sequence1_type&);
+
+    // c
+    //
+    int
+    c () const;
+
+    int&
+    c ();
+
+    void
+    c (int);
+
+    // d
+    //
+    const std::string&
+    d () const;
+
+    std::string&
+    d ();
+
+    void
+    d (const std::string&);
+
+  private:
+    ...
+  };
+
+  typedef xml_schema::fix_sequence<sequence1_type> sequence1_sequence;
+  typedef sequence1_sequence::iterator sequence1_iterator;
+  typedef sequence1_sequence::const_iterator sequence1_const_iterator;
+
+  const sequence1_sequence&
+  sequence1 () const;
+
+  sequence1_sequence&
+  sequence1 ();
+
+private:
+  ...
+};
+  
+<complexType name="type">
+  <choice>
+    <element name="a" type="int"/>
+    <element name="b" type="string"/>
+    <element name="c" type="boolean"/>
+  </choice>
+</complexType>
+  
+// type (fixed-length)
+//
+class type
+{
+public:
+  type ();
+  type (const type&);
+  type& operator= (const type&);
+
+  // choice
+  //
+  enum choice_arm_tag
+  {
+    a_tag,
+    b_tag,
+    c_tag
+  };
+
+  choice_arm_tag
+  choice_arm () const;
+
+  void
+  choice_arm (choice_arm_tag);
+
+  // a
+  //
+  int
+  a () const;
+
+  int&
+  a ();
+
+  void
+  a (int);
+
+  // b
+  //
+  const std::string&
+  b () const;
+
+  std::string&
+  b ();
+
+  void
+  b (const std::string&);
+
+  // c
+  //
+  bool
+  c () const;
+
+  bool&
+  c ();
+
+  void
+  c (bool);
+
+private:
+  ...
+};
+  
+type& x = ...
+
+switch (x.choice_arm ())
+{
+case type::a_tag:
+  {
+    cout << "a: " << x.a () << endl;
+    break;
+  }
+case type::b_tag:
+  {
+    cout << "b: " << x.b () << endl;
+    break;
+  }
+case type::c_tag:
+  {
+    cout << "c: " << x.c () << endl;
+    break;
+  }
+}
+
+// Modifiers automatically set the corresponding arm.
+//
+x.a (10);
+
+// For accessors we need to select the arm explicitly.
+//
+x.choice_arm (type::b_tag);
+x.b () = "b";
+  
+<complexType name="type">
+  <choice maxOccurs="unbounded">
+    <sequence>
+      <element name="a" type="int"/>
+      <element name="b" type="string"/>
+    </sequence>
+    <element name="c" type="boolean"/>
+  </choice>
+</complexType>
+  
+// type (variable-length)
+//
+class type
+{
+public:
+  type ();
+
+private:
+  type (const type&);
+  type& operator= (const type&);
+
+public:
+  // choice (fixed-length)
+  //
+  class choice_type
+  {
+  public:
+    choice_type ();
+    choice_type (const choice_type&);
+    choice_type& operator= (const choice_type&);
+
+    enum choice_arm_tag
+    {
+      sequence_tag,
+      c_tag
+    };
+
+    choice_arm_tag
+    choice_arm () const;
+
+    void
+    choice_arm (choice_arm_tag);
+
+    // sequence (fixed-length)
+    //
+    class sequence_type
+    {
+    public:
+      sequence_type ();
+      sequence_type (const sequence_type&);
+      sequence_type& operator= (const sequence_type&);
+
+      // a
+      //
+      int
+      a () const;
+
+      int&
+      a ();
+
+      void
+      a (int);
+
+      // b
+      //
+      const std::string&
+      b () const;
+
+      std::string&
+      b ();
+
+      void
+      b (const std::string&);
+
+    private:
+      ...
+    };
+
+    const sequence_type&
+    sequence () const;
+
+    sequence_type&
+    sequence ();
+
+    void
+    sequence (const sequence_type&);
+
+    // c
+    //
+    bool
+    c () const;
+
+    bool&
+    c ();
+
+    void
+    c (bool);
+
+  private:
+    ...
+  };
+
+  typedef xml_schema::fix_sequence<choice_type> choice_sequence;
+  typedef choice_sequence::iterator choice_iterator;
+  typedef choice_sequence::const_iterator choice_const_iterator;
+
+  const choice_sequence&
+  choice () const;
+
+  choice_sequence&
+  choice ();
+
+private:
+  ...
+};
+  
+#include <memory>
+#include <iostream>
+
+#include "people.hxx"
+#include "people-pimpl.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  // Parse.
+  //
+  people_paggr people_p;
+  xml_schema::document_pimpl doc_p (people_p.root_parser (),
+                                    people_p.root_name ());
+  people_p.pre ();
+  doc_p.parse ("people.xml");
+  auto_ptr<people> ppl (people_p.post ());
+
+  // Iterate over individual person records.
+  //
+  people::person_sequence& ps = ppl->person ();
+
+  for (people::person_iterator i = ps.begin (); i != ps.end (); ++i)
+  {
+    person& 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 () << " ";
+
+    cout << p.last_name () << endl;
+
+    // Print gender, age, and id which are all required.
+    //
+    cout << "gender: " << p.gender ().string () << 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 <memory>
+#include <iostream>
+
+#include "people.hxx"
+#include "people-pimpl.hxx"
+#include "people-simpl.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  // Parse.
+  //
+  people_paggr people_p;
+  xml_schema::document_pimpl doc_p (people_p.root_parser (),
+                                    people_p.root_name ());
+  people_p.pre ();
+  doc_p.parse ("people.xml");
+  auto_ptr<people> ppl (people_p.post ());
+
+  // Iterate over individual person records and increment
+  // the age.
+  //
+  people::person_sequence& ps = ppl->person ();
+
+  for (people::person_iterator i = ps.begin (); i != ps.end (); ++i)
+  {
+    i->age ()++; // Alternative way: i->age (i->age () + 1)
+  }
+
+  // Add middle-name to the first record and remove it from
+  // the second.
+  //
+  person& john = ps[0];
+  person& jane = ps[1];
+
+  john.middle_name ("Mary");
+  jane.middle_name_present (false);
+
+  // Add another John record.
+  //
+  ps.push_back (john);
+
+  // Serialize the modified object model to XML.
+  //
+  people_saggr people_s;
+  xml_schema::document_simpl doc_s (people_s.root_serializer (),
+                                    people_s.root_name ());
+  people_s.pre (*ppl);
+  doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+  people_s.post ();
+}
+  
+<?xml version="1.0"?>
+<people>
+
+  <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"
+#include "people-simpl.hxx"
+
+using namespace std;
+
+int
+main ()
+{
+  people ppl;
+  people::person_sequence& ps = ppl.person ();
+
+  // John
+  //
+  {
+    person p;
+    p.first_name ("John");
+    p.last_name ("Doe");
+    p.gender (gender::male);
+    p.age (32);
+    p.id (1);
+
+    ps.push_back (p);
+  }
+
+  // Jane
+  //
+  {
+    person p;
+    p.first_name ("Jane");
+    p.middle_name ("Mary");
+    p.last_name ("Doe");
+    p.gender (gender::female);
+    p.age (28);
+    p.id (2);
+
+    ps.push_back (p);
+  }
+
+  // Serialize the object model to XML.
+  //
+  people_saggr people_s;
+  xml_schema::document_simpl doc_s (people_s.root_serializer (),
+                                    people_s.root_name ());
+  people_s.pre (ppl);
+  doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+  people_s.post ();
+}
+  
+<?xml version="1.0" ?>
+<people>
+
+  <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>
+  
+$ xsde cxx-hybrid --custom-data person people.xsd
+  
+// person (variable-length)
+//
+class person
+{
+public:
+
+  ...
+
+  // Custom data.
+  //
+  typedef xml_schema::data_sequence custom_data_sequence;
+  typedef custom_data_sequence::iterator custom_data_iterator;
+  typedef custom_data_sequence::const_iterator custom_data_const_iterator;
+
+  const custom_data_sequence&
+  custom_data () const;
+
+  custom_data_sequence&
+  custom_data ();
+};
+  
+namespace xml_schema
+{
+  class data_sequence
+  {
+  public:
+    typedef void*         value_type;
+    typedef void**        pointer;
+    typedef const void**  const_pointer;
+    typedef void*         reference;
+    typedef const void*   const_reference;
+
+    typedef size_t        size_type;
+    typedef ptrdiff_t     difference_type;
+
+    typedef void** iterator;
+    typedef const void* const* const_iterator;
+
+    typedef void (*destroy_func) (void* data, size_t pos);
+    typedef void* (*clone_func) (void* data, size_t pos);
+
+  public:
+    data_sequence ();
+
+    void
+    destructor (destroy_func);
+
+    void
+    clone (clone_func);
+
+    void
+    swap (data_sequence&);
+
+  private:
+    data_sequence (const data_sequence&);
+
+    data_sequence&
+    operator= (data_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    void*
+    front ();
+
+    const void*
+    front () const;
+
+    void*
+    back ();
+
+    const void*
+    back () const;
+
+    void*
+    operator[] (size_t);
+
+    const void*
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (void*);
+
+    iterator
+    insert (iterator, void*);
+
+    void
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class data_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (void*);
+
+    error
+    insert (iterator, void*);
+
+    error
+    insert (iterator, void*, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+class data
+{
+  ...
+};
+
+void
+destroy_data (void* p, size_t)
+{
+  delete static_cast<data*> (p);
+}
+
+person& = ...;
+person::custom_data_sequence& cd = p.custom_data ();
+
+cd.destructor (&destroy_data);
+
+// Store.
+//
+data* d = new data;
+cd.push_back (d);
+
+// Retrieve.
+//
+for (person::custom_data_iterator i = cd.begin (); i != cd.end (); ++i)
+{
+  data* d = static_cast<data*> (*i);
+}
+  
+--custom-type foo
+--custom-type foo=///foo.hxx
+--custom-type foo=v///foo.hxx
+--custom-type foo=f/int
+--custom-type foo=//foo_base/my/foo.hxx
+--custom-type foo=v/wrapper<foo_base>/foo_base
+  
+$ xsde cxx-hybrid --custom-type person=//person_base/person.hxx \
+people.xsd
+  
+// person_base (fixed-length)
+//
+class person_base
+{
+  ...
+};
+
+#include "person.hxx"
+
+// people (variable-length)
+//
+class people
+{
+  ...
+
+  // person
+  //
+  typedef xml_schema::fix_sequence<person> person_sequence;
+  typedef person_sequence::iterator person_iterator;
+  typedef person_sequence::const_iterator person_const_iterator;
+
+  const person_sequence&
+  person () const;
+
+  person_sequence&
+  person ();
+
+private:
+  ...
+};
+  
+class person: public person_base
+{
+public:
+  person ()
+    : verified_ (false)
+  {
+  }
+
+  bool
+  verified () const
+  {
+    return verified_;
+  }
+
+  void
+  verified (bool v)
+  {
+    verified_ = v;
+  }
+
+private:
+  bool verified_;
+};
+  
+people::person_sequence& ps = ...;
+
+for (people::person_iterator i = ps.begin (); i != ps.end (); ++i)
+{
+  if (!i->verified ())
+  {
+    // Verify the record.
+
+    ...
+
+    i->verified (true);
+  }
+}
+  
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="name" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="person" type="person"/>
+
+  <xs:complexType name="superman">
+    <xs:complexContent>
+      <xs:extension base="person">
+        <xs:attribute name="can-fly" type="xs:boolean"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  <xs:complexType name="batman">
+    <xs:complexContent>
+      <xs:extension base="superman">
+        <xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  <xs:complexType name="supermen">
+    <xs:sequence>
+      <xs:element ref="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="supermen" type="supermen"/>
+
+</xs:schema>
+  
+<supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <person>
+    <name>John Doe</name>
+  </person>
+
+  <superman can-fly="false">
+    <name>James "007" Bond</name>
+  </superman>
+
+  <superman can-fly="true" wing-span="10" xsi:type="batman">
+    <name>Bruce Wayne</name>
+  </superman>
+
+</supermen>
+  
+// Parse.
+//
+supermen_paggr supermen_p;
+
+// The last argument to the document's constructor indicates that we
+// are parsing polymorphic XML documents.
+//
+xml_schema::document_pimpl doc_p (
+  supermen_p.root_parser (),
+  supermen_p.root_name (),
+  true);
+
+supermen_p.pre ();
+doc_p.parse ("supermen.xml");
+auto_ptr<supermen> sm (supermen_p.post ());
+
+// Print what we've got.
+//
+for (supermen::person_iterator i = sm->person ().begin ();
+     i != sm->person ().end ();
+     ++i)
+{
+  person& p = *i;
+
+  if (batman* b = dynamic_cast<batman*> (&p))
+  {
+    cerr << b->name () << ", batman, wing span " <<
+      b->wing_span () << endl;
+  }
+  else if (superman* s = dynamic_cast<superman*> (&p))
+  {
+    cerr << s->name () << ", ";
+
+    if (s->can_fly ())
+      cerr << "flying ";
+
+    cerr << "superman" << endl;
+  }
+  else
+  {
+    cerr << p.name () << ", ordinary person" << endl;
+  }
+}
+
+// Add another superman entry.
+//
+auto_ptr<superman> s (new superman);
+s->name ("Clark Kent");
+s->can_fly (true);
+sm->person ().push_back (s.release ());
+
+// Serialize.
+//
+supermen_saggr supermen_s;
+
+// The last argument to the document's constructor indicates that we
+// are serializing polymorphic XML documents.
+//
+xml_schema::document_simpl doc_s (
+  supermen_s.root_serializer (),
+  supermen_s.root_name (),
+  true);
+
+doc_s.add_no_namespace_schema ("supermen.xsd");
+
+supermen_s.pre (*sm);
+doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+supermen_s.post ();
+  
+virtual const std::string&
+_dynamic_type () const;
+
+static const std::string&
+_static_type ();
+  
+virtual const char*
+_dynamic_type () const;
+
+static const char*
+_static_type ();
+  
+for (supermen::person_iterator i = sm->person ().begin ();
+     i != sm->person ().end ();
+     ++i)
+{
+  person& p = *i;
+  const string& dt = p._dynamic_type ();
+
+  if (dt == batman::_static_type ())
+  {
+    batman& b = static_cast<batman&> (p)
+    cerr << b.name () << ", batman, wing span " <<
+      b.wing_span () << endl;
+  }
+  else if (dt == superman::_static_type ())
+  {
+    superman& s = static_cast<superman&> (p)
+    cerr << s.name () << ", ";
+
+    if (s.can_fly ())
+      cerr << "flying ";
+
+    cerr << "superman" << endl;
+  }
+  else
+  {
+    cerr << p.name () << ", ordinary person" << endl;
+  }
+}
+  
+<complexType name="measure">
+  <simpleContent>
+    <extension base="int">
+      <attribute name="unit" type="string" use="required"/>
+    </extension>
+  </simpleContent>
+</complexType>
+  
+// measure (fixed-length)
+//
+class measure: public xml_schema::int_base
+{
+public:
+  measure ();
+  measure (const measure&);
+  measure& operator= (const measure&);
+
+  // unit
+  //
+  const std::string&
+  unit () const;
+
+  std::string&
+  unit ();
+
+  void
+  unit (const std::string&);
+
+private:
+  ...
+};
+  
+namespace xml_schema
+{
+  class int_base
+  {
+  public:
+    int_base ();
+
+    int_base&
+    operator= (int);
+
+  public:
+    int
+    base_value () const;
+
+    int&
+    base_value ();
+
+    void
+    base_value (int);
+
+    operator const int& () const;
+    operator int& ();
+  };
+}
+  
+namespace xml_schema
+{
+  class string_base
+  {
+  public:
+    string_base ();
+
+    string_base&
+    operator= (char* x)
+
+  public:
+    const char*
+    base_value () const;
+
+    char*
+    base_value ();
+
+    void
+    base_value (char* x);
+
+    char*
+    base_value_detach ();
+
+    operator const char* () const;
+    operator char* ();
+  };
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (const std::string& name);
+    qname (const std::string& prefix, const std::string& name);
+
+    void
+    swap (qname&);
+
+    const std::string&
+    prefix () const;
+
+    std::string&
+    prefix ();
+
+    void
+    prefix (const std::string&);
+
+    const std::string&
+    name () const;
+
+    std::string&
+    name ();
+
+    void
+    name (const std::string&);
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    void
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    void
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    error
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    error
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    class bounds {}; // Out of bounds exception.
+
+  public:
+    buffer ();
+
+    explicit
+    buffer (size_t size);
+    buffer (size_t size, size_t capacity);
+    buffer (const void* data, size_t size);
+    buffer (const void* data, size_t size, size_t capacity);
+
+    enum ownership_value { assume_ownership };
+
+    // This constructor assumes ownership of the memory passed.
+    //
+    buffer (void* data, size_t size, size_t capacity, ownership_value);
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    void
+    assign (void* data, size_t size);
+
+    void
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+
+    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 ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_bounds,
+      error_no_memory
+    };
+
+    buffer ();
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    error
+    assign (void* data, size_t size);
+
+    error
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+    void
+    swap (buffer&);
+
+  public:
+    size_t
+    capacity () const;
+
+    error
+    capacity (size_t);
+
+    error
+    capacity (size_t, bool& moved);
+
+  public:
+    size_t
+    size () const;
+
+    error
+    size (size_t);
+
+    error
+    size (size_t, bool& moved);
+
+  public:
+    const char*
+    data () const;
+
+    char*
+    data ();
+
+    const char*
+    begin () const;
+
+    char*
+    begin ();
+
+    const char*
+    end () const;
+
+    char*
+    end ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  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&);
+}
+  
+namespace xml_schema
+{
+  class date: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date ();
+
+    date (int year, unsigned short month, unsigned short day);
+
+    date (int year, unsigned short month, unsigned short day,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class date_time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date_time ();
+
+    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);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class duration
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    duration ();
+
+    duration (bool negative,
+              unsigned int years, unsigned int months, unsigned int days,
+              unsigned int hours, unsigned int minutes, double seconds);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gday: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gday ();
+
+    explicit
+    gday (unsigned short day);
+
+    gday (unsigned short day, short zone_hours, short zone_minutes);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gday&, const gday&);
+
+  bool
+  operator!= (const gday&, const gday&);
+}
+  
+namespace xml_schema
+{
+  class gmonth: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth ();
+
+    explicit
+    gmonth (unsigned short month);
+
+    gmonth (unsigned short month,
+            short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth&, const gmonth&);
+
+  bool
+  operator!= (const gmonth&, const gmonth&);
+}
+  
+namespace xml_schema
+{
+  class gmonth_day: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth_day ();
+
+    gmonth_day (unsigned short month, unsigned short day);
+
+    gmonth_day (unsigned short month, unsigned short day,
+                short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gyear: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear ();
+
+    explicit
+    gyear (int year);
+
+    gyear (int year, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+  };
+
+  bool
+  operator== (const gyear&, const gyear&);
+
+  bool
+  operator!= (const gyear&, const gyear&);
+}
+  
+namespace xml_schema
+{
+  class gyear_month: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear_month ();
+
+    gyear_month (int year, unsigned short month);
+
+    gyear_month (int year, unsigned short month,
+                 short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    time ();
+
+    time (unsigned short hours, unsigned short minutes, double seconds);
+
+    time (unsigned short hours, unsigned short minutes, double seconds,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class any_type
+  {
+  public:
+    // Custom data.
+    //
+    typedef xml_schema::data_sequence custom_data_sequence;
+    typedef custom_data_sequence::iterator custom_data_iterator;
+    typedef custom_data_sequence::const_iterator custom_data_const_iterator;
+
+    void
+    allocate_custom_data ();
+
+    const custom_data_sequence&
+    custom_data () const;
+
+    custom_data_sequence&
+    custom_data ();
+  };
+}
+  
+namespace xml_schema
+{
+  class any_type
+  {
+  public:
+    // Custom data.
+    //
+    typedef xml_schema::data_sequence custom_data_sequence;
+    typedef custom_data_sequence::iterator custom_data_iterator;
+    typedef custom_data_sequence::const_iterator custom_data_const_iterator;
+
+    bool
+    allocate_custom_data ();
+
+    const custom_data_sequence&
+    custom_data () const;
+
+    custom_data_sequence&
+    custom_data ();
+  };
+}
+  
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello">
+    <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"/>
+
+</xs:schema>
+  
+class hello_paggr
+{
+public:
+  hello_paggr ();
+
+  void
+  pre ();
+
+  hello*
+  post ();
+
+  hello_pimpl&
+  root_parser ();
+
+  static const char*
+  root_name ();
+
+  static const char*
+  root_namespace ();
+};
+  
+hello_paggr hello_p;
+xml_schema::document_pimpl doc_p (hello_p.root_parser (),
+                                  hello_p.root_name ());
+hello_p.pre ();
+doc_p.parse ("hello.xml");
+hello* h = hello_p.post ();
+  
+class hello_saggr
+{
+public:
+  hello_saggr ();
+
+  void
+  pre (const hello&);
+
+  void
+  post ();
+
+  hello_simpl&
+  root_serializer ();
+
+  static const char*
+  root_name ();
+
+  static const char*
+  root_namespace ();
+};
+  
+hello_saggr hello_s;
+xml_schema::document_simpl doc_s (hello_s.root_serializer (),
+                                  hello_s.root_name ());
+hello_s.pre (*h);
+doc_s.serialize (std::cout, xml_schema::document_simpl::pretty_print);
+hello_s.post ();
+  
+--custom-parser foo
+--custom-parser foo=foo_base_pimpl
+--custom-parser foo=foo_base_pimpl/foo/foo-custom.hxx
+--custom-parser foo=/foo/foo-custom.hxx
+  
+$ xsde cxx-hybrid --generate-parser --generate-serializer \
+--custom-parser people=people_base_pimpl/people-custom-pimpl.hxx \
+--custom-serializer people=people_base_simpl/people-custom-simpl.hxx \
+--generate-aggregate people.xsd
+  
+class people_pimpl: public people_base_pimpl
+{
+public:
+  void
+  age_filter (unsigned short min, unsigned short max)
+  {
+    min_age_ = min;
+    max_age_ = max;
+  }
+
+  virtual void
+  person (const ::person& p)
+  {
+    // Check if the age constraints are met.
+    //
+    unsigned short age = p.age ();
+
+    if (age >= min_age_ && age <= max_age_)
+      people_base_pimpl::person (p);
+  }
+
+private:
+  unsigned short min_age_;
+  unsigned short max_age_;
+};
+  
+virtual void
+person (const ::person* p)
+{
+  unsigned short age = p->age ();
+
+  if (age >= min_age_ && age <= max_age_)
+    people_base_pimpl::person (p);
+  else
+    delete p;
+}
+  
+class people_simpl: public people_base_simpl
+{
+public:
+  void
+  gender_filter (gender g)
+  {
+    gender_ = g;
+  }
+
+  virtual bool
+  person_next ()
+  {
+    // See if we have any more person records with the gender we
+    // are interested in.
+    //
+    people::person_const_iterator& i = people_base_simpl_state_.person_;
+    people::person_const_iterator& e = people_base_simpl_state_.person_end_;
+
+    for (; i != e; ++i)
+    {
+      if (i->gender () == gender_)
+        break;
+    }
+
+    return i != e;
+  }
+
+private:
+  gender gender_;
+};
+  
+#include <memory>
+#include <iostream>
+
+#include "people.hxx"
+
+#include "people-pimpl.hxx"
+#include "people-simpl.hxx"
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  // Parse.
+  //
+  people_paggr people_p;
+  people_pimpl& root_p = people_p.root_parser ();
+
+  // Initialize the filter.
+  //
+  root_p.age_filter (1, 30);
+
+  xml_schema::document_pimpl doc_p (root_p, people_p.root_name ());
+
+  people_p.pre ();
+  doc_p.parse (argv[1]);
+  auto_ptr<people> ppl (people_p.post ());
+
+  // Print what we've got.
+  //
+  people::person_sequence& ps = ppl->person ();
+
+  for (people::person_iterator i = ps.begin (); i != ps.end (); ++i)
+  {
+    cerr << "first:  " << i->first_name () << endl
+         << "last:   " << i->last_name () << endl
+         << "gender: " << i->gender ().string () << endl
+         << "age:    " << i->age () << endl
+         << endl;
+  }
+
+  // Serialize.
+  //
+  people_saggr people_s;
+  people_simpl& root_s = people_s.root_serializer ();
+
+  // Initialize the filter.
+  //
+  root_s.gender_filter (gender::female);
+
+  xml_schema::document_simpl doc_s (root_s, people_s.root_name ());
+
+  people_s.pre (*ppl);
+  doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+  people_s.post ();
+}
+  
+<?xml version="1.0"?>
+<people>
+
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+
+  <person>
+    <first-name>Joe</first-name>
+    <last-name>Dirt</last-name>
+    <gender>male</gender>
+    <age>25</age>
+  </person>
+
+</people>
+  
+first:  Jane
+last:   Doe
+gender: female
+age:    28
+
+first:  Joe
+last:   Dirt
+gender: male
+age:    25
+
+<people>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+  
+void
+operator<< (ostream&, const type&);
+
+void
+operator>> (istream&, type&);
+  
+bool
+operator<< (ostream&, const type&);
+
+bool
+operator>> (istream&, type&);
+  
+try
+{
+  const type& x = ... // Object model.
+
+  // Save to a CDR stream.
+  //
+  ACE_OutputCDR ace_ocdr;
+  xml_schema::ocdrstream ocdr (ace_ocdr);
+
+  ocdr << x;
+
+  // Load from a CDR stream.
+  //
+  ACE_InputCDR ace_icdr (buf, size);
+  xml_schema::icdrstream icdr (ace_icdr);
+
+  type copy;
+  icdr >> copy;
+}
+catch (const xml_schema::cdr_exception&)
+{
+  cerr << "CDR operation failed" << endl;
+}
+  
+const type& x = ... // Object model.
+
+// Save to a CDR stream.
+//
+ACE_OutputCDR ace_ocdr;
+xml_schema::ocdrstream ocdr (ace_ocdr);
+
+if (!(ocdr << x))
+{
+  cerr << "CDR operation failed" << endl;
+}
+
+// Load from a CDR stream.
+//
+ACE_InputCDR ace_icdr (buf, size);
+xml_schema::icdrstream icdr (ace_icdr);
+
+type copy;
+
+if (!(icdr >> copy))
+{
+  cerr << "CDR operation failed" << endl;
+}
+  
+try
+{
+  const type& x = ... // Object model.
+
+  // Save to a XDR stream.
+  //
+  XDR xdr;
+  xdrrec_create (&xdr, ...);
+  xml_schema::oxdrstream oxdr (xdr);
+
+  oxdr << x;
+
+  // Load from a XDR stream.
+  //
+  xdrrec_create (&xdr, ...);
+  xml_schema::ixdrstream ixdr (xdr);
+
+  type copy;
+  ixdr >> copy;
+}
+catch (const xml_schema::xdr_exception&)
+{
+  cerr << "XDR operation failed" << endl;
+}
+  
+const type& x = ... // Object model.
+
+// Save to a XDR stream.
+//
+XDR xdr;
+xdrrec_create (&xdr, ...);
+xml_schema::oxdrstream oxdr (xdr);
+
+if (!(oxdr << x))
+{
+  cerr << "XDR operation failed" << endl;
+}
+
+// Load from a XDR stream.
+//
+xdrrec_create (&xdr, ...);
+xml_schema::ixdrstream ixdr (xdr);
+
+type copy;
+
+if (!(ixdr >> copy))
+{
+  cerr << "XDR operation failed" << endl;
+}
+  
+<?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">
+    <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"/>
+
+</xs:schema>
+      
+$ xsde cxx-parser hello.xsd
+  
+class hello_pskel
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  greeting (const std::string&);
+
+  virtual void
+  name (const std::string&);
+
+  virtual void
+  post_hello ();
+
+  // Parser construction API.
+  //
+  void
+  greeting_parser (xml_schema::string_pskel&);
+
+  void
+  name_parser (xml_schema::string_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* greeting */,
+           xml_schema::string_pskel& /* name */);
+
+private:
+  ...
+};
+  
+#include <iostream>
+#include "hello-pskel.hxx"
+
+class hello_pimpl: public hello_pskel
+{
+public:
+  virtual void
+  greeting (const std::string& g)
+  {
+    greeting_ = g;
+  }
+
+  virtual void
+  name (const std::string& n)
+  {
+    std::cout << greeting_ << ", " << n << "!" << std::endl;
+  }
+
+private:
+  std::string greeting_;
+};
+  
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Construct the parser.
+    //
+    xml_schema::string_pimpl string_p;
+    hello_pimpl hello_p;
+
+    hello_p.greeting_parser (string_p);
+    hello_p.name_parser (string_p);
+
+    // Parse the XML instance.
+    //
+    xml_schema::document_pimpl doc_p (hello_p, "hello");
+
+    hello_p.pre ();
+    doc_p.parse (argv[1]);
+    hello_p.post_hello ();
+  }
+  catch (const xml_schema::parser_exception& e)
+  {
+    cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+         << ": " << e.text () << endl;
+    return 1;
+  }
+}
+  
+$ c++ -I.../libxsde -c driver.cxx hello-pskel.cxx
+$ c++ -o driver driver.o hello-pskel.o .../libxsde/xsde/libxsde.a
+$ ./driver hello.xml
+Hello, sun!
+Hello, moon!
+Hello, world!
+  
+$ ./driver hello-pskel.hxx
+hello-pskel.hxx:1:0: not well-formed (invalid token)
+  
+$ ./driver hello.xsd
+hello.xsd:2:57: unexpected element encountered
+  
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="people">
+    <xs:sequence>
+      <xs:element name="person" type="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people"/>
+
+</xs:schema>
+  
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+  
+class gender_pskel: public xml_schema::string_pskel
+{
+public:
+  gender_pskel (xml_schema::string_pskel* base_impl);
+
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post_gender ();
+};
+  
+class gender_pimpl: public gender_pskel
+{
+public:
+  gender_pimpl ()
+    : gender_pskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  post_gender ()
+  {
+    std::string s = post_string ();
+    cout << "gender: " << s << endl;
+  }
+
+private:
+  xml_schema::string_pimpl base_impl_;
+};
+  
+namespace xml_schema
+{
+  class string_pskel: public parser_simple_content
+  {
+  public:
+    virtual std::string
+    post_string () = 0;
+  };
+
+  class string_pimpl: public string_pskel
+  {
+  public:
+    virtual void
+    _pre ();
+
+    virtual void
+    _characters (const xml_schema::ro_string&);
+
+    virtual std::string
+    post_string ();
+
+  protected:
+    std::string str_;
+  };
+}
+  
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post_name ();
+  
+class person_pskel: public xml_schema::parser_complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  first_name (const std::string&);
+
+  virtual void
+  last_name (const std::string&);
+
+  virtual void
+  gender ();
+
+  virtual void
+  age (short);
+
+  virtual void
+  post_person ();
+
+  // Parser construction API.
+  //
+  void
+  first_name_parser (xml_schema::string_pskel&);
+
+  void
+  last_name_parser (xml_schema::string_pskel&);
+
+  void
+  gender_parser (gender_pskel&);
+
+  void
+  age_parser (xml_schema::short_pskel&);
+
+  void
+  parsers (xml_schema::string_pskel& /* first-name */,
+           xml_schema::string_pskel& /* last-name */,
+           gender_pskel&             /* gender */,
+           xml_schema::short_pskel&  /* age */);
+};
+  
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& n)
+  {
+    cout << "first: " << f << endl;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    cout << "last: " << l << endl;
+  }
+
+  virtual void
+  age (short a)
+  {
+    cout << "age: " << a << endl;
+  }
+};
+  
+class people_pskel: public xml_schema::parser_complex_content
+{
+public:
+  // Parser callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  person ();
+
+  virtual void
+  post_people ();
+
+  // Parser construction API.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  parsers (person_pskel& /* person */);
+};
+  
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    cout << endl;
+  }
+};
+  
+xml_schema::short_pimpl short_p;
+xml_schema::string_pimpl string_p;
+
+gender_pimpl gender_p;
+person_pimpl person_p;
+people_pimpl people_p;
+  
+person_p.first_name_parser (string_p);
+person_p.last_name_parser (string_p);
+person_p.gender_parser (gender_p);
+person_p.age_parser (short_p);
+
+people_p.person_parser (person_p);
+  
+person_p.parsers (string_p, string_p, gender_p, short_p);
+people_p.parsers (person_p);
+  
+xml_schema::document_pimpl doc_p (people_p, "people");
+
+people_p.pre ();
+doc_p.parse ("people.xml");
+people_p.post_people ();
+  
+namespace xml_schema
+{
+  class document_pimpl
+  {
+  public:
+    document_pimpl (xml_schema::parser_base&,
+                    const std::string& root_element_name);
+
+    document_pimpl (xml_schema::parser_base&,
+                    const std::string& root_element_namespace,
+                    const std::string& root_element_name);
+
+    void
+    parse (const std::string& file);
+
+    void
+    parse (std::istream&);
+
+    void
+    parse (const void* data, size_t size, bool last);
+  };
+}
+  
+<?xml version="1.0"?>
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+  
+#include <string>
+#include <vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string& first,
+          const std::string& last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&
+  last () const
+  {
+    return last_;
+  }
+
+  ::gender
+  gender () const
+  {
+    return gender_;
+  }
+
+  short
+  age () const
+  {
+    return age_;
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+typedef std::vector<person> people;
+  
+include "people.hxx";
+gender ::gender ::gender;
+  
+$ xsde cxx-parser --type-map people.map people.xsd
+  
+#include "people.hxx"
+
+class gender_pskel: public xml_schema::string_pskel
+{
+  virtual ::gender
+  post_gender () = 0;
+
+  ...
+};
+
+class person_pskel: public xml_schema::parser_complex_content
+{
+  virtual void
+  gender (::gender);
+
+  ...
+};
+  
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+  
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer long long;
+
+  negativeInteger long long;
+  nonPositiveInteger long long;
+
+  positiveInteger "unsigned long" "unsigned long";
+  nonNegativeInteger "unsigned long" "unsigned long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  NMTOKENS xml_schema::string_sequence*;
+  IDREFS xml_schema::string_sequence*;
+
+  base64Binary xml_schema::buffer*;
+  hexBinary xml_schema::buffer*;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  include <string>;
+
+  anySimpleType std::string;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  QName xml_schema::qname;
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  anySimpleType char*;
+
+  string char*;
+  normalizedString char*;
+  token char*;
+  Name char*;
+  NMTOKEN char*;
+  NCName char*;
+  ID char*;
+  IDREF char*;
+  language char*;
+  anyURI char*;
+
+  QName xml_schema::qname*;
+}
+  
+namespace .*
+{
+  .* void void;
+}
+  
+include "people.hxx";
+
+gender ::gender ::gender;
+person ::person;
+people ::people;
+  
+$ xsde cxx-parser --type-map people.map people.xsd
+  
+#include "people-pskel.hxx"
+
+class gender_pimpl: public gender_pskel
+{
+public:
+  gender_pimpl ()
+    : gender_pskel (&base_impl_)
+  {
+  }
+
+  virtual ::gender
+  post_gender ()
+  {
+    return post_string () == "male" ? male : female;
+  }
+
+private:
+  xml_schema::string_pimpl base_impl_;
+};
+
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (const std::string& f)
+  {
+    first_ = f;
+  }
+
+  virtual void
+  last_name (const std::string& l)
+  {
+    last_ = l;
+  }
+
+  virtual void
+  gender (::gender g)
+  {
+    gender_ = g;
+  }
+
+  virtual void
+  age (short a)
+  {
+    age_ = a;
+  }
+
+  virtual ::person
+  post_person ()
+  {
+    return ::person (first_, last_, gender_, age_);
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person (const ::person& p)
+  {
+    people_.push_back (p);
+  }
+
+  virtual ::people
+  post_people ()
+  {
+    ::people r;
+    r.swap (people_);
+    return r;
+  }
+
+private:
+  ::people people_;
+};
+  
+#include <iostream>
+
+using namespace std;
+
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::short_pimpl short_p;
+  xml_schema::string_pimpl string_p;
+
+  gender_pimpl gender_p;
+  person_pimpl person_p;
+  people_pimpl people_p;
+
+  person_p.parsers (string_p, string_p, gender_p, short_p);
+  people_p.parsers (person_p);
+
+  // Parse the document to obtain the object model.
+  //
+  xml_schema::document_pimpl doc_p (people_p, "people");
+
+  people_p.pre ();
+  doc_p.parse (argv[1]);
+  people ppl = people_p.post_people ();
+
+  // Print the object model.
+  //
+  for (people::iterator i (ppl.begin ()); i != ppl.end (); ++i)
+  {
+    cout << "first:  " << i->first () << endl
+         << "last:   " << i->last () << endl
+         << "gender: " << (i->gender () == male ? "male" : "female") << endl
+         << "age:    " << i->age () << endl
+         << endl;
+  }
+}
+  
+$ c++ -I.../libxsde -c driver.cxx people-pskel.cxx
+$ c++ -o driver driver.o people-pskel.o .../libxsde/xsde/libxsde.a
+$ ./driver people.xml
+first:  John
+last:   Doe
+gender: male
+age:    32
+
+first:  Jane
+last:   Doe
+gender: female
+age:    28
+  
+xml_schema::iso8859_1::unrep_char ('?');
+  
+class person_pskel
+{
+public:
+  virtual void
+  first_name (char*);
+
+  virtual void
+  last_name (char*);
+
+  ...
+};
+  
+  void
+  parse (const std::string& file);
+
+  void
+  parse (std::istream&);
+  
+  void
+  parse (const void* data, size_t size, bool last);
+  
+<xs:complexType name="person">
+  <xs:sequence>
+    <xs:element name="first-name" type="xs:string"/>
+    <xs:element name="last-name" type="xs:string"/>
+    <xs:element name="age" type="xs:short"/>
+  </xs:sequence>
+</xs:complexType>
+
+<xs:complexType name="emplyee">
+  <complexContent>
+    <extension base="person">
+      <xs:sequence>
+        <xs:element name="position" type="xs:string"/>
+        <xs:element name="salary" type="xs:unsignedLong"/>
+      </xs:sequence>
+    </extension>
+  </complexContent>
+</xs:complexType>
+  
+class person_pskel: public virtual parser_complex_content
+{
+  ...
+};
+
+class employee_pskel: public virtual person_pskel
+{
+  ...
+};
+  
+class person_pimpl: public virtual person_pskel
+{
+  ...
+};
+
+class employee_pimpl: public employee_pskel,
+                      public person_pimpl
+{
+  ...
+};
+  
+class person_pskel: public parser_complex_content
+{
+  ...
+};
+
+class employee_pskel: public person_pskel
+{
+public:
+  employee_pskel (person_pskel* base_impl)
+
+  ...
+};
+  
+class person_pimpl: public person_pskel
+{
+  ...
+};
+
+class employee_pimpl: public employee_pskel
+{
+public:
+  employee_pimpl ()
+    : employee_pskel (&base_impl_)
+  {
+  }
+
+  ...
+
+private:
+  person_pimpl base_impl_;
+};
+  
+class employee_pimpl: public employee_pskel
+{
+public:
+  employee_pimpl ()
+    : employee_pskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  age (short a)
+  {
+    ...
+  }
+
+  ...
+
+private:
+  person_pimpl base_impl_;
+};
+  
+class person_pimpl: public person_pskel
+{
+  ...
+protected:
+  virtual person*
+  create ()
+  {
+    return new person ();
+  }
+};
+
+class employee_pimpl: public employee_pskel,
+                      public person_pimpl
+{
+public:
+  employee_pimpl ()
+    : employee_pskel (static_cast<person_pimpl*> (this))
+  {
+  }
+
+  // Resolve ambiguities.
+  //
+  using emplyee_pskel::parsers;
+
+  ...
+
+protected:
+  virtual employee*
+  create ()
+  {
+    return new employee ();
+  }
+};
+  
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="name" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="person" type="person"/>
+
+  <xs:complexType name="superman">
+    <xs:complexContent>
+      <xs:extension base="person">
+        <xs:attribute name="can-fly" type="xs:boolean"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  <xs:complexType name="batman">
+    <xs:complexContent>
+      <xs:extension base="superman">
+        <xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="batman"
+              type="batman"
+              substitutionGroup="superman"/>
+
+  <xs:complexType name="supermen">
+    <xs:sequence>
+      <xs:element ref="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="supermen" type="supermen"/>
+
+</xs:schema>
+  
+<supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <person>
+    <name>John Doe</name>
+  </person>
+
+  <superman can-fly="false">
+    <name>James "007" Bond</name>
+  </superman>
+
+  <superman can-fly="true" wing-span="10" xsi:type="batman">
+    <name>Bruce Wayne</name>
+  </superman>
+
+</supermen>
+  
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse person" << endl;
+  }
+
+  virtual void
+  name (const std::string& v)
+  {
+    cout << "name: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    cout << "finished parsing person" << endl;
+  }
+};
+
+class superman_pimpl: public superman_pskel
+{
+public:
+  superman_pimpl ()
+    : superman_pskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse superman" << endl;
+  }
+
+  virtual void
+  can_fly (bool v)
+  {
+    cout << "can-fly: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    cout << "finished parsing superman" << endl
+  }
+
+private:
+  person_pimpl base_impl_;
+};
+
+class batman_pimpl: public batman_pskel
+{
+public:
+  batman_pimpl ()
+    : batman_pskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  pre ()
+  {
+    cout << "starting to parse batman" << endl;
+  }
+
+  virtual void
+  wing_span (unsigned int v)
+  {
+    cout << "wing-span: " << v << endl;
+  }
+
+  virtual void
+  post_person ()
+  {
+    post_superman ();
+  }
+
+  virtual void
+  post_superman ()
+  {
+    post_batman ();
+  }
+
+  virtual void
+  post_batman ()
+  {
+    cout << "finished parsing batman" << endl;
+  }
+
+private:
+  superman_pimpl base_impl_;
+};
+  
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::string_pimpl string_p;
+  xml_schema::boolean_pimpl boolean_p;
+  xml_schema::unsigned_int_pimpl unsigned_int_p;
+
+  person_pimpl person_p;
+  superman_pimpl superman_p;
+  batman_pimpl batman_p;
+
+  xml_schema::parser_map_impl person_map (5); // 5 hashtable buckets
+  supermen_pimpl supermen_p;
+
+  person_p.parsers (string_p);
+  superman_p.parsers (string_p, boolean_p);
+  batman_p.parsers (string_p, boolean_p, unsigned_int_p);
+
+  // Here we are specifying several parsers that can be used to
+  // parse the person element.
+  //
+  person_map.insert (person_p);
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_map);
+
+  // Parse the XML document. The last argument to the document's
+  // constructor indicates that we are parsing polymorphic XML
+  // documents.
+  //
+  xml_schema::document_pimpl doc_p (supermen_p, "supermen", true);
+
+  supermen_p.pre ();
+  doc_p.parse (argv[1]);
+  supermen_p.post_supermen ();
+}
+  
+class supermen_pskel: public xml_schema::parser_complex_content
+{
+public:
+
+  ...
+
+  // Parser construction API.
+  //
+  void
+  parsers (person_pskel&);
+
+  // Individual element parsers.
+  //
+  void
+  person_parser (person_pskel&);
+
+  void
+  person_parser (xml_schema::parser_map&);
+
+  ...
+};
+  
+int
+main (int argc, char* argv[])
+{
+  ...
+
+  // Here we are specifying several parsers that can be used to
+  // parse the person element.
+  //
+  person_map.insert (superman_p);
+  person_map.insert (batman_p);
+
+  supermen_p.person_parser (person_p);
+  supermen_p.person_parser (person_map);
+
+  ...
+}
+  
+namespace xml_schema
+{
+  class parser_map
+  {
+  public:
+    virtual parser_base*
+    find (const char* type) const = 0;
+
+    virtual void
+    reset () const = 0;
+  };
+
+  class parser_map_impl: public parser_map
+  {
+  public:
+    parser_map_impl (size_t buckets);
+
+    void
+    insert (parser_base&);
+
+    virtual parser_base*
+    find (const char* type) const;
+
+    virtual void
+    reset () const;
+
+  private:
+    parser_map_impl (const parser_map_impl&);
+
+    parser_map_impl&
+    operator= (const parser_map_impl&);
+
+    ...
+  };
+}
+  
+#include <map>
+#include <string>
+
+class parser_map: public xml_schema::parser_map
+{
+public:
+ void
+ insert (xml_schema::parser_base& p)
+ {
+   map_[p._dynamic_type ()] = &p;
+ }
+
+ virtual xml_schema::parser_base*
+ find (const char* type) const
+ {
+   map::const_iterator i = map_.find (type);
+   return i != map_.end () ? i->second : 0;
+ }
+
+ virtual void
+ reset () const
+ {
+   for (map::const_iterator i (map_.begin ()), e (map_.end ());
+        i != e; ++i)
+   {
+     xml_schema::parser_base* p = i->second;
+     p->_reset ();
+   }
+ }
+
+private:
+  typedef std::map<std::string, xml_schema::parser_base*> map;
+  map map_;
+};
+  
+namespace xml_schema
+{
+  class parser_map_impl: public parser_map
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    error
+    _error () const;
+
+    ...
+  };
+}
+  
+int
+main ()
+{
+  // Check that the load in substitution and inheritance hashmaps
+  // is not too high.
+  //
+#ifndef NDEBUG
+  float load = xml_schema::parser_smap_elements ();
+  load /= xml_schema::parser_smap_buckets ();
+
+  if (load > 0.8)
+  {
+    cerr << "substitution hashmap load is " << load << endl;
+    cerr << "time to increase XSDE_PARSER_SMAP_BUCKETS" << endl;
+  }
+
+  load = xml_schema::parser_imap_elements ();
+  load /= xml_schema::parser_imap_buckets ();
+
+  if (load > 0.8)
+  {
+    cerr << "inheritance hashmap load is " << load << endl;
+    cerr << "time to increase XSDE_PARSER_IMAP_BUCKETS" << endl;
+  }
+#endif
+
+  ...
+}
+  
+extern "C" void*
+xsde_alloc (size_t);
+
+extern "C" void*
+xsde_realloc (void*, size_t);
+
+extern "C" void
+xsde_free (void*);
+  
+namespace xml_schema
+{
+  void*
+  alloc (size_t);
+
+  void
+  free (void*);
+
+  struct alloc_guard
+  {
+    alloc_guard (void*);
+    ~alloc_guard ();
+
+    void*
+    get () const;
+
+    void
+    release ();
+
+  private:
+    ...
+  };
+}
+  
+void* v = xml_schema::alloc (sizeof (type));
+
+if (v == 0)
+{
+  // Handle out of memory condition.
+}
+
+type* x = new (v) type (1, 2);
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+xml_schema::alloc_guard g (xml_schema::alloc (sizeof (type)));
+type* x = new (g.get ()) type (1, 2);
+g.release ();
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+#include <stdio.h>
+
+#include "people-pskel.hxx"
+
+class gender_pimpl: public gender_pskel
+{
+public:
+  gender_pimpl ()
+    : gender_pskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  post_gender ()
+  {
+    char* s = post_string ();
+    printf ("gender: %s\n", s);
+    delete[] s;
+  }
+
+private:
+  xml_schema::string_pimpl base_impl_;
+};
+
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  first_name (char* n)
+  {
+    printf ("first: %s\n", n);
+    delete[] n;
+  }
+
+  virtual void
+  last_name (char* n)
+  {
+    printf ("last: %s\n", n);
+    delete[] n;
+  }
+
+  virtual void
+  age (short a)
+  {
+    printf ("age: %hd\n", a);
+  }
+};
+
+class people_pimpl: public people_pskel
+{
+public:
+  virtual void
+  person ()
+  {
+    // Add an extra newline after each person record.
+    //
+    printf ("\n");
+  }
+};
+
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::short_pimpl short_p;
+  xml_schema::string_pimpl string_p;
+
+  gender_pimpl gender_p;
+  person_pimpl person_p;
+  people_pimpl people_p;
+
+  person_p.parsers (string_p, string_p, gender_p, short_p);
+  people_p.parsers (person_p);
+
+  // Open the file.
+  //
+  FILE* f = fopen (argv[1], "rb");
+
+  if (f == 0)
+  {
+    fprintf (stderr, "%s: unable to open\n", argv[1]);
+    return 1;
+  }
+
+  // Parse.
+  //
+  typedef xml_schema::parser_error error;
+  error e;
+  bool io_error = false;
+
+  do
+  {
+    xml_schema::document_pimpl doc_p (people_p, "people");
+    if (e = doc_p._error ())
+      break;
+
+    people_p.pre ();
+    if (e = people_p._error ())
+      break;
+
+    char buf[4096];
+    do
+    {
+      size_t s = fread (buf, 1, sizeof (buf), f);
+
+      if (s != sizeof (buf) && ferror (f))
+      {
+        io_error = true;
+        break;
+      }
+
+      doc_p.parse (buf, s, feof (f) != 0);
+      e = doc_p._error ();
+
+    } while (!e && !feof (f));
+
+    if (io_error || e)
+      break;
+
+    people_p.post_people ();
+    e = people_p._error ();
+
+  } while (false);
+
+  fclose (f);
+
+  // Handle errors.
+  //
+
+  if (io_error)
+  {
+    fprintf (stderr, "%s: read failure\n", argv[1]);
+    return 1;
+  }
+
+  if (e)
+  {
+    switch (e.type ())
+    {
+    case error::sys:
+      {
+        fprintf (stderr, "%s: %s\n", argv[1], e.sys_text ());
+        break;
+      }
+    case error::xml:
+      {
+        fprintf (stderr, "%s:%lu:%lu: %s\n",
+                 argv[1], e.line (), e.column (), e.xml_text ());
+        break;
+      }
+    case error::schema:
+      {
+        fprintf (stderr, "%s:%lu:%lu: %s\n",
+                 argv[1], e.line (), e.column (), e.schema_text ());
+        break;
+      }
+    case error::app:
+      {
+        fprintf (stderr, "%s:%lu:%lu: application error %d\n",
+                 argv[1], e.line (), e.column (), e.app_code ());
+        break;
+      }
+    default:
+      break;
+    }
+    return 1;
+  }
+  return 0;
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (const std::string& name);
+    qname (const std::string& prefix, const std::string& name);
+
+    void
+    swap (qname&);
+
+    const std::string&
+    prefix () const;
+
+    std::string&
+    prefix ();
+
+    void
+    prefix (const std::string&);
+
+    const std::string&
+    name () const;
+
+    std::string&
+    name ();
+
+    void
+    name (const std::string&);
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    void
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    void
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    error
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    error
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    typedef std::string         value_type;
+    typedef std::string*        pointer;
+    typedef const std::string*  const_pointer;
+    typedef std::string&        reference;
+    typedef const std::string&  const_reference;
+
+    typedef size_t              size_type;
+    typedef ptrdiff_t           difference_type;
+
+    typedef std::string*        iterator;
+    typedef const std::string*  const_iterator;
+
+  public:
+    string_sequence ();
+
+    void
+    swap (string_sequence&);
+
+  private:
+    string_sequence (string_sequence&);
+
+    string_sequence&
+    operator= (string_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    std::string&
+    front ();
+
+    const std::string&
+    front () const;
+
+    std::string&
+    back ();
+
+    const std::string&
+    back () const;
+
+    std::string&
+    operator[] (size_t);
+
+    const std::string&
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (const std::string&);
+
+    iterator
+    insert (iterator, const std::string&);
+
+    void
+    reserve (size_t);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (const std::string&);
+
+    error
+    insert (iterator, const std::string&);
+
+    error
+    insert (iterator, const std::string&, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    typedef char*         value_type;
+    typedef char**        pointer;
+    typedef const char**  const_pointer;
+    typedef char*         reference;
+    typedef const char*   const_reference;
+
+    typedef size_t        size_type;
+    typedef ptrdiff_t     difference_type;
+
+    typedef char** iterator;
+    typedef const char* const* const_iterator;
+
+    string_sequence ();
+
+    void
+    swap (string_sequence&);
+
+  private:
+    string_sequence (string_sequence&);
+
+    string_sequence&
+    operator= (string_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    char*
+    front ();
+
+    const char*
+    front () const;
+
+    char*
+    back ();
+
+    const char*
+    back () const;
+
+    char*
+    operator[] (size_t);
+
+    const char*
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (char*);
+
+    void
+    push_back_copy (const char*);
+
+    iterator
+    insert (iterator, char*);
+
+    void
+    reserve (size_t);
+
+    // Detach a string from the sequence at a given position.
+    // The string pointer at this position in the sequence is
+    // set to 0.
+    //
+    char*
+    detach (iterator);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (char*);
+
+    error
+    push_back_copy (const char*);
+
+    error
+    insert (iterator, char*);
+
+    error
+    insert (iterator, char*, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    class bounds {}; // Out of bounds exception.
+
+  public:
+    buffer ();
+
+    explicit
+    buffer (size_t size);
+    buffer (size_t size, size_t capacity);
+    buffer (const void* data, size_t size);
+    buffer (const void* data, size_t size, size_t capacity);
+
+    enum ownership_value { assume_ownership };
+
+    // This constructor assumes ownership of the memory passed.
+    //
+    buffer (void* data, size_t size, size_t capacity, ownership_value);
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    void
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+    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 ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_bounds,
+      error_no_memory
+    };
+
+    buffer ();
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    error
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+    void
+    swap (buffer&);
+
+  public:
+    size_t
+    capacity () const;
+
+    error
+    capacity (size_t);
+
+    error
+    capacity (size_t, bool& moved);
+
+  public:
+    size_t
+    size () const;
+
+    error
+    size (size_t);
+
+    error
+    size (size_t, bool& moved);
+
+  public:
+    const char*
+    data () const;
+
+    char*
+    data ();
+
+    const char*
+    begin () const;
+
+    char*
+    begin ();
+
+    const char*
+    end () const;
+
+    char*
+    end ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  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&);
+}
+  
+namespace xml_schema
+{
+  class date: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date ();
+
+    date (int year, unsigned short month, unsigned short day);
+
+    date (int year, unsigned short month, unsigned short day,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class date_time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date_time ();
+
+    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);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class duration
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    duration ();
+
+    duration (bool negative,
+              unsigned int years, unsigned int months, unsigned int days,
+              unsigned int hours, unsigned int minutes, double seconds);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gday: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gday ();
+
+    explicit
+    gday (unsigned short day);
+
+    gday (unsigned short day, short zone_hours, short zone_minutes);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gday&, const gday&);
+
+  bool
+  operator!= (const gday&, const gday&);
+}
+  
+namespace xml_schema
+{
+  class gmonth: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth ();
+
+    explicit
+    gmonth (unsigned short month);
+
+    gmonth (unsigned short month,
+            short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth&, const gmonth&);
+
+  bool
+  operator!= (const gmonth&, const gmonth&);
+}
+  
+namespace xml_schema
+{
+  class gmonth_day: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth_day ();
+
+    gmonth_day (unsigned short month, unsigned short day);
+
+    gmonth_day (unsigned short month, unsigned short day,
+                short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gyear: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear ();
+
+    explicit
+    gyear (int year);
+
+    gyear (int year, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+  };
+
+  bool
+  operator== (const gyear&, const gyear&);
+
+  bool
+  operator!= (const gyear&, const gyear&);
+}
+  
+namespace xml_schema
+{
+  class gyear_month: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear_month ();
+
+    gyear_month (int year, unsigned short month);
+
+    gyear_month (int year, unsigned short month,
+                 short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    time ();
+
+    time (unsigned short hours, unsigned short minutes, double seconds);
+
+    time (unsigned short hours, unsigned short minutes, double seconds,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class parser_base;
+
+  class document_pimpl
+  {
+  public:
+    document_pimpl (parser_base&,
+                    const char* root_element_name);
+
+    document_pimpl (parser_base&,
+                    const char* root_element_namespace,
+                    const char* root_element_name);
+
+    document_pimpl (parser_base&,
+                    const std::string& root_element_name);
+
+    document_pimpl (parser_base&,
+                    const std::string& root_element_namespace,
+                    const std::string& root_element_name);
+
+
+  public:
+    // Parse a local file. The file is accessed with std::ifstream
+    // in binary mode. The std::ios_base::failure exception is used
+    // to report io errors (badbit and failbit) if exceptions are
+    // enabled. Otherwise error codes are used.
+    //
+    void
+    parse (const char* file);
+
+    void
+    parse (const std::string& file);
+
+    // Parse std::istream. std::ios_base::failure exception is used
+    // to report io errors (badbit and failbit) if exceptions are
+    // enabled. Otherwise error codes are used.
+    //
+    void
+    parse (std::istream&);
+
+    // Parse a chunk of input. You can call this function multiple
+    // times with the last call having the last argument true.
+    //
+    void
+    parse (const void* data, size_t size, bool last);
+
+    // Low-level Expat-specific parsing API.
+    //
+    void
+    parse_begin (XML_Parser);
+
+    void
+    parse_end ();
+  };
+}
+  
+xxx_pimpl root_p;
+document_pimpl doc_p (root_p, "root");
+
+root_p.pre ();
+doc_p.parse_begin (xml_parser);
+
+while (more_stuff_to_parse)
+{
+   // Call XML_Parse or XML_ParseBuffer:
+   //
+   if (XML_Parse (...) != XML_STATUS_ERROR)
+     break;
+}
+
+doc_p.parse_end ();
+result_type result (root_p.post_xxx ());
+  
+namespace xml_schema
+{
+  class parser_exception: public std::exception
+  {
+  public:
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    virtual const char*
+    text () const = 0;
+
+    ...
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const parser_exception&);
+
+
+  typedef <implementation-details> parser_xml_error;
+
+  class parser_xml: public parser_exception
+  {
+  public:
+    parser_xml_error
+    code () const;
+
+    virtual const char*
+    text () const;
+
+    virtual const char*
+    what () const throw ();
+
+    ...
+  };
+
+
+  typedef <implementation-details> parser_schema_error;
+
+  class parser_schema: public parser_exception
+  {
+  public:
+    parser_schema_error
+    code () const;
+
+    virtual const char*
+    text () const;
+
+    virtual const char*
+    what () const throw ();
+
+    ...
+  };
+}
+  
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    // Parse argv[1].
+  }
+  catch (const xml_schema::parser_exception& e)
+  {
+    cout << argv[1] << ":" << e.line () << ":" << e.column ()
+         << ": error: " << e.text () << endl;
+    return 1;
+  }
+}
+  
+xml_schema::parser_error
+_error () const;
+  
+namespace xml_schema
+{
+  class sys_error
+  {
+  public:
+    enum value
+    {
+      none,
+      no_memory,
+      open_failed,
+      read_failed,
+      write_failed
+    };
+
+    sys_error (value);
+
+    operator value () const;
+
+    static const char*
+    text (value);
+
+    ...
+  };
+
+  typedef <implementation-details> parser_xml_error;
+  typedef <implementation-details> parser_schema_error;
+
+  class parser_error
+  {
+  public:
+    enum error_type
+    {
+      none,
+      sys,
+      xml,
+      schema,
+      app
+    };
+
+    error_type
+    type () const;
+
+    // Line and column are only available for xml, schema, and
+    // app errors.
+    //
+    unsigned long
+    line () const;
+
+    unsigned long
+    column () const;
+
+    // Returns true if there is an error so that you can write
+    // if (p.error ()) or if (error e = p.error ()).
+    //
+    typedef void (error::*bool_convertible) ();
+    operator bool_convertible () const;
+
+    // system
+    //
+    sys_error
+    sys_code () const;
+
+    const char*
+    sys_text () const;
+
+    // xml
+    //
+    parser_xml_error
+    xml_code () const;
+
+    const char*
+    xml_text () const;
+
+    // schema
+    //
+    parser_schema_error
+    schema_code () const;
+
+    const char*
+    schema_text () const;
+
+    // app
+    //
+    int
+    app_code () const;
+
+    ...
+  };
+}
+  
+int
+main (int argc, char* argv[])
+{
+  // Construct the parser.
+  //
+  xml_schema::short_pimpl short_p;
+  xml_schema::string_pimpl string_p;
+
+  gender_pimpl gender_p;
+  person_pimpl person_p;
+  people_pimpl people_p;
+
+  person_p.parsers (string_p, string_p, gender_p, short_p);
+  people_p.parsers (person_p);
+
+  // Parse.
+  //
+  using xml_schema::parser_error;
+  parser_error e;
+
+  do
+  {
+    xml_schema::document_pimpl doc_p (people_p, "people");
+    if (e = doc_p._error ())
+      break;
+
+    people_p.pre ();
+    if (e = people_p._error ())
+      break;
+
+    doc_p.parse (argv[1]);
+    if (e = doc_p._error ())
+      break;
+
+    people_p.post_people ();
+    e = people_p._error ();
+
+  } while (false);
+
+  // Handle errors.
+  //
+  if (e)
+  {
+    switch (e.type ())
+    {
+    case parser_error::sys:
+      {
+        cerr << argv[1] << ": error: " << e.sys_text () << endl;
+        break;
+      }
+    case parser_error::xml:
+      {
+        cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+             << ": error: " << e.xml_text () << endl;
+        break;
+      }
+    case parser_error::schema:
+      {
+        cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+             << ": error: " << e.schema_text () << endl;
+        break;
+      }
+    case parser_error::app:
+      {
+        cerr << argv[1] << ":" << e.line () << ":" << e.column ()
+             << ": application error " << e.app_code () << endl;
+        break;
+      }
+    }
+    return 1;
+  }
+}
+  
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  age (short a)
+  {
+    if (a < 18)
+      _app_error (1);
+  }
+
+  ...
+};
+  
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    p_ = new person ();
+
+    if (p_ == 0)
+      _sys_error (xml_schema::sys_error::no_memory);
+  }
+
+  ...
+
+private:
+  person* p_;
+};
+  
+int
+main ()
+{
+  ...
+
+  std::vector<std::string> files = ...
+
+  xml_schema::document_pimpl doc_p (people_p, "people");
+
+  for (size_t i = 0; i < files.size (); ++i)
+  {
+    try
+    {
+      people_p.pre ();
+      doc_p.parse (files[i]);
+      people_p.post_people ();
+    }
+    catch (const xml_schema::parser_exception&)
+    {
+      doc_p.reset ();
+    }
+  }
+}
+  
+class person_pimpl: public person_pskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    p_ = new person ();
+  }
+
+  virtual void
+  _reset ()
+  {
+    person_pskel::_reset ();
+    delete p_;
+    p_ = 0;
+  }
+
+  ...
+
+private:
+  person* p_;
+};
+  
+<hello>
+
+  <greeting>Hello</greeting>
+
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+
+</hello>
+      
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="hello">
+    <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"/>
+
+</xs:schema>
+      
+$ xsde cxx-serializer hello.xsd
+  
+class hello_sskel
+{
+public:
+  // Serializer callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual std::string
+  greeting () = 0;
+
+  virtual bool
+  name_next () = 0;
+
+  virtual std::string
+  name () = 0;
+
+  virtual void
+  post ();
+
+  // Serializer construction API.
+  //
+  void
+  greeting_serializer (xml_schema::string_sskel&);
+
+  void
+  name_serializer (xml_schema::string_sskel&);
+
+  void
+  serializers (xml_schema::string_sskel& /* greeting */,
+               xml_schema::string_sskel& /* name */);
+
+private:
+  ...
+};
+  
+#include <string>
+#include <vector>
+#include "hello-sskel.hxx"
+
+struct hello_simpl: hello_sskel
+{
+  hello_simpl ()
+  {
+    names_.push_back ("sun");
+    names_.push_back ("moon");
+    names_.push_back ("world");
+  }
+
+  virtual void
+  pre ()
+  {
+    i_ = names_.begin ();
+  }
+
+  virtual std::string
+  greeting ()
+  {
+    return "Hello";
+  }
+
+  virtual bool
+  name_next ()
+  {
+    return i_ != names_.end ();
+  }
+
+  virtual std::string
+  name ()
+  {
+    return *i_++;
+  }
+
+private:
+  typedef std::vector<std::string> names;
+
+  names names_;
+  names::iterator i_;
+};
+  
+#include <iostream>
+
+using namespace std;
+
+int
+main ()
+{
+  try
+  {
+    // Construct the serializer.
+    //
+    xml_schema::string_simpl string_s;
+    hello_simpl hello_s;
+
+    hello_s.greeting_serializer (string_s);
+    hello_s.name_serializer (string_s);
+
+    // Create the XML document.
+    //
+    xml_schema::document_simpl doc_s (hello_s, "hello");
+
+    hello_s.pre ();
+    doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+    hello_s.post ();
+  }
+  catch (const xml_schema::serializer_exception& e)
+  {
+    cerr << "error: " << e.text () << endl;
+    return 1;
+  }
+}
+  
+$ c++ -I.../libxsde -c driver.cxx hello-sskel.cxx
+$ c++ -o driver driver.o hello-sskel.o .../libxsde/xsde/libxsde.a
+$ ./driver
+<hello>
+  <greeting>Hello</greeting>
+  <name>sun</name>
+  <name>moon</name>
+  <name>world</name>
+</hello>
+  
+struct hello_simpl: hello_sskel
+{
+  hello_simpl ()
+  {
+    /*
+    names_.push_back ("sun");
+    names_.push_back ("moon");
+    names_.push_back ("world");
+    */
+  }
+  ...
+};
+  
+$ ./driver
+error: expected element not encountered
+  
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:simpleType name="gender">
+    <xs:restriction base="xs:string">
+      <xs:enumeration value="male"/>
+      <xs:enumeration value="female"/>
+    </xs:restriction>
+  </xs:simpleType>
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="last-name" type="xs:string"/>
+      <xs:element name="gender" type="gender"/>
+      <xs:element name="age" type="xs:short"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="people">
+    <xs:sequence>
+      <xs:element name="person" type="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="people" type="people"/>
+
+</xs:schema>
+  
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+  
+class gender_sskel: public xml_schema::string_sskel
+{
+public:
+  gender_sskel (xml_schema::string_sskel* base_impl)
+
+  // Serializer callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual void
+  post ();
+};
+  
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+class gender_simpl: public gender_sskel
+{
+public:
+  gender_simpl ()
+    : gender_sskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  pre ()
+  {
+    string g;
+    cerr << "gender (male/female): ";
+    getline (cin, g);
+    base_impl_.pre (g);
+  }
+
+private:
+  xml_schema::string_simpl base_impl_;
+};
+  
+namespace xml_schema
+{
+  class string_sskel: public serializer_simple_content
+  {
+  public:
+    virtual void
+    pre (const std::string&) = 0;
+  };
+
+  class string_simpl: public string_sskel
+  {
+  public:
+    virtual void
+    pre (const std::string&);
+
+    virtual void
+    _serialize_content ();
+
+  protected:
+    std::string value_;
+  };
+}
+  
+  virtual void
+  pre ();
+
+  virtual void
+  _pre ();
+
+  virtual void
+  _post ();
+
+  virtual void
+  post ();
+  
+class person_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  // Serializer callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual std::string
+  first_name () = 0;
+
+  virtual std::string
+  last_name () = 0;
+
+  virtual void
+  gender ();
+
+  virtual short
+  age () = 0;
+
+  virtual void
+  post ();
+
+  // Serializer construction API.
+  //
+  void
+  first_name_serializer (xml_schema::string_sskel&);
+
+  void
+  last_name_serializer (xml_schema::string_sskel&);
+
+  void
+  gender_serializer (gender_sskel&);
+
+  void
+  age_serializer (xml_schema::short_sskel&);
+
+  void
+  serializers (xml_schema::string_sskel& /* first-name */,
+               xml_schema::string_sskel& /* last-name */,
+               gender_sskel&             /* gender */,
+               xml_schema::short_sskel&  /* age */);
+};
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual string
+  first_name ()
+  {
+    string fn;
+    cerr << "first name: ";
+    getline (cin, fn);
+    return fn;
+  }
+
+  virtual std::string
+  last_name ()
+  {
+    string ln;
+    cerr << "last name: ";
+    getline (cin, ln);
+    return ln;
+  }
+
+  virtual short
+  age ()
+  {
+    short a;
+    cerr << "age: ";
+    cin >> a;
+    return a;
+  }
+};
+  
+class people_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  // Serializer callbacks. Override them in your implementation.
+  //
+  virtual void
+  pre ();
+
+  virtual bool
+  person_next () = 0;
+
+  virtual void
+  person ();
+
+  virtual void
+  post ();
+
+  // Serializer construction API.
+  //
+  void
+  person_serializer (person_sskel&);
+
+  void
+  serializers (person_sskel& /* person */);
+};
+  
+class people_simpl: public people_sskel
+{
+public:
+  virtual bool
+  person_next ()
+  {
+    string s;
+    cerr << "serialize another person record (y/n): ";
+    cin >> ws; // Skip leading whitespaces.
+    getline (cin, s);
+    return s == "y";
+  }
+};
+  
+xml_schema::short_simpl short_s;
+xml_schema::string_simpl string_s;
+
+gender_simpl gender_s;
+person_simpl person_s;
+people_simpl people_s;
+  
+person_s.first_name_serializer (string_s);
+person_s.last_name_serializer (string_s);
+person_s.gender_serializer (gender_s);
+person_s.age_serializer (short_s);
+
+people_s.person_serializer (person_s);
+  
+person_s.serializers (string_s, string_s, gender_s, short_s);
+people_s.serializers (person_s);
+  
+xml_schema::document_simpl doc_s (people_s, "people");
+
+std::ostringstream os;
+
+people_s.pre ();
+doc_s.serialize (os, xml_schema::document_simpl::pretty_print);
+people_s.post ();
+
+cout << os.str ();
+  
+namespace xml_schema
+{
+  class document_simpl
+  {
+  public:
+    document_simpl (xml_schema::serializer_base&,
+                    const std::string& root_element_name);
+
+    document_simpl (xml_schema::serializer_base&,
+                    const std::string& root_element_namespace,
+                    const std::string& root_element_name);
+
+    typedef unsigned short flags;
+    static const flags pretty_print;
+
+    void
+    serialize (std::ostream&, flags = 0);
+  };
+}
+  
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+</people>
+  
+#include <string>
+#include <vector>
+
+enum gender
+{
+  male,
+  female
+};
+
+class person
+{
+public:
+  person (const std::string& first,
+          const std::string& last,
+          ::gender gender,
+          short age)
+    : first_ (first), last_ (last),
+      gender_ (gender), age_ (age)
+  {
+  }
+
+  const std::string&
+  first () const
+  {
+    return first_;
+  }
+
+  const std::string&
+  last () const
+  {
+    return last_;
+  }
+
+  ::gender
+  gender () const
+  {
+    return gender_;
+  }
+
+  short
+  age () const
+  {
+    return age_;
+  }
+
+private:
+  std::string first_;
+  std::string last_;
+  ::gender gender_;
+  short age_;
+};
+
+typedef std::vector<person> people;
+  
+include "people.hxx";
+gender ::gender ::gender;
+  
+$ xsde cxx-serializer --type-map people.map people.xsd
+  
+#include "people.hxx"
+
+class gender_sskel: public xml_schema::string_sskel
+{
+  virtual void
+  pre (::gender) = 0;
+
+  ...
+};
+
+class person_sskel: public xml_schema::serializer_complex_content
+{
+  virtual ::gender
+  gender () = 0;
+
+  ...
+};
+  
+namespace <schema-namespace> [<cxx-namespace>]
+{
+  (include <file-name>;)*
+  ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
+}
+  
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer long long;
+
+  negativeInteger long long;
+  nonPositiveInteger long long;
+
+  positiveInteger "unsigned long" "unsigned long";
+  nonNegativeInteger "unsigned long" "unsigned long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  NMTOKENS "const xml_schema::string_sequence*";
+  IDREFS "const xml_schema::string_sequence*";
+
+  base64Binary "const xml_schema::buffer*";
+  hexBinary "const xml_schema::buffer*";
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  include <string>;
+
+  anySimpleType std::string;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  QName xml_schema::qname;
+}
+  
+namespace http://www.w3.org/2001/XMLSchema
+{
+  anySimpleType "const char*";
+
+  string "const char*";
+  normalizedString "const char*";
+  token "const char*";
+  Name "const char*";
+  NMTOKEN "const char*";
+  NCName "const char*";
+  ID "const char*";
+  IDREF "const char*";
+  language "const char*";
+  anyURI "const char*";
+
+  QName "const xml_schema::qname*";
+}
+  
+namespace .*
+{
+  .* void void;
+}
+  
+include "people.hxx";
+
+gender ::gender ::gender;
+person "const ::person&";
+people "const ::people&";
+  
+$ xsde cxx-serializer --type-map people.map people.xsd
+  
+#include "people-sskel.hxx"
+
+const char* gender_strings[] = {"male", "female"};
+
+class gender_simpl: public gender_sskel
+{
+public:
+  gender_simpl ()
+    : gender_sskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  pre (gender g)
+  {
+    base_impl_.pre (gender_strings[g]);
+  }
+
+private:
+  xml_schema::string_simpl base_impl_;
+};
+
+class person_simpl: public person_sskel
+{
+public:
+  virtual void
+  pre (const person& p)
+  {
+    p_ = &p;
+  }
+
+  virtual std::string
+  first_name ()
+  {
+    return p_->first ();
+  }
+
+  virtual std::string
+  last_name ()
+  {
+    return p_->last ();
+  }
+
+  virtual ::gender
+  gender ()
+  {
+    return p_->gender ();
+  }
+
+  virtual short
+  age ()
+  {
+    return p_->age ();
+  }
+
+private:
+  const person* p_;
+};
+
+class people_simpl: public people_sskel
+{
+public:
+  virtual void
+  pre (const people& p)
+  {
+    p_ = &p;
+    i_ = p_->begin ();
+  }
+
+  virtual bool
+  person_next ()
+  {
+    return i_ != p_->end ();
+  }
+
+  virtual const ::person&
+  person ()
+  {
+    return *i_++;
+  }
+
+private:
+  const people* p_;
+  people::const_iterator i_;
+};
+  
+#include <iostream>
+
+using namespace std;
+
+int
+main ()
+{
+  // Create a sample object model.
+  //
+  people ppl;
+
+  ppl.push_back (person ("John", "Doe", male, 32));
+  ppl.push_back (person ("Jane", "Doe", female, 28));
+
+  // Construct the serializer.
+  //
+  xml_schema::short_simpl short_s;
+  xml_schema::string_simpl string_s;
+
+  gender_simpl gender_s;
+  person_simpl person_s;
+  people_simpl people_s;
+
+  person_s.serializers (string_s, string_s, gender_s, short_s);
+  people_s.serializers (person_s);
+
+  // Create the XML document.
+  //
+  xml_schema::document_simpl doc_s (people_s, "people");
+
+  people_s.pre (ppl);
+  doc_s.serialize (cout, xml_schema::document_simpl::pretty_print);
+  people_s.post ();
+}
+  
+$ c++ -I.../libxsde -c driver.cxx people-sskel.cxx
+$ c++ -o driver driver.o people-sskel.o .../libxsde/xsde/libxsde.a
+$ ./driver
+<people>
+  <person>
+    <first-name>John</first-name>
+    <last-name>Doe</last-name>
+    <gender>male</gender>
+    <age>32</age>
+  </person>
+  <person>
+    <first-name>Jane</first-name>
+    <last-name>Doe</last-name>
+    <gender>female</gender>
+    <age>28</age>
+  </person>
+</people>
+  
+virtual bool
+<name>_next ();
+  
+<xs:complexType name="coordinates">
+  <xs:sequence maxOccurs="unbounded">
+    <xs:element name="lat" type="xs:float"/>
+    <xs:element name="lon" type="xs:float"/>
+  </xs:sequence>
+</xs:complexType>
+  
+class coordinates_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  virtual bool
+  sequence_next ();
+
+  virtual float
+  lan () = 0;
+
+  virtual float
+  lon () = 0;
+
+  virtual void
+  post ();
+
+  ...
+};
+  
+virtual bool
+<name>_present ();
+  
+<xs:complexType name="name">
+  <xs:sequence minOccurs="0">
+    <xs:element name="first" type="xs:string"/>
+    <xs:element name="initial" type="xs:string" minOccurs="0"/>
+    <xs:element name="last" type="xs:string"/>
+  </xs:sequence>
+  <xs:attribute name="lang" type="xs:language"/>
+</xs:complexType>
+  
+class name_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  virtual bool
+  lang_present ();
+
+  virtual std::string
+  lang () = 0;
+
+  virtual bool
+  sequence_present ();
+
+  virtual std::string
+  first () = 0;
+
+  virtual bool
+  initial_present ();
+
+  virtual std::string
+  initial () = 0;
+
+  virtual std::string
+  last () = 0;
+
+  virtual void
+  post ();
+
+  ...
+};
+  
+virtual bool
+<name>_next ();
+  
+<xs:complexType name="names">
+  <xs:sequence maxOccurs="unbounded">
+    <xs:element name="first" type="xs:string"/>
+    <xs:element name="last" type="xs:string"/>
+    <xs:element name="pseudonym" type="xs:string" maxOccurs="3"/>
+  </xs:sequence>
+</xs:complexType>
+  
+class names_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  virtual bool
+  sequence_next () = 0;
+
+  virtual std::string
+  first () = 0;
+
+  virtual std::string
+  last () = 0;
+
+  virtual bool
+  pseudonym_next () = 0;
+
+  virtual std::string
+  pseudonym () = 0;
+
+  virtual void
+  post ();
+};
+  
+<xs:complexType name="name">
+  <xs:choice>
+    <xs:element name="full-name" type="xs:string"/>
+    <xs:sequence>
+      <xs:element name="first-name" type="xs:string"/>
+      <xs:element name="last-name" type="xs:string"/>
+    </xs:sequence>
+  </xs:choice>
+</xs:complexType>
+  
+class name_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  enum choice_arm_tag
+  {
+    full_name_tag,
+    sequence_tag
+  };
+
+  virtual choice_arm_tag
+  choice_arm () = 0;
+
+  virtual std::string
+  full_name () = 0;
+
+  virtual std::string
+  first_name () = 0;
+
+  virtual std::string
+  last_name () = 0;
+
+  virtual void
+  post ();
+};
+  
+<xs:complexType name="name">
+  <xs:sequence>
+    <xs:element name="first" type="xs:string"/>
+    <xs:element name="last" type="xs:string"/>
+    <xs:any namespace="##other" processContents="skip" minOccurs="0"/>
+  </xs:sequence>
+</xs:complexType>
+  
+class name_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  virtual std::string
+  first () = 0;
+
+  virtual std::string
+  last () = 0;
+
+  virtual bool
+  any_present ();
+
+  virtual void
+  any (std::string& ns, std::string& name);
+
+  virtual void
+  serialize_any ();
+
+  virtual void
+  post ();
+};
+  
+namespace xml_schema
+{
+  class serializer_base
+  {
+  public:
+    void
+    _start_element (const char* name);
+
+    void
+    _start_element (const char* ns, const char* name);
+
+    void
+    _end_element ();
+
+    void
+    _start_attribute (const char* name);
+
+    void
+    _start_attribute (const char* ns, const char* name);
+
+    void
+    _end_attribute ();
+
+    void
+    _attribute (const char* name, const char* value);
+
+    void
+    _attribute (const char* ns, const char* name, const char* value);
+
+    void
+    _characters (const char*);
+
+    void
+    _characters (const char*, size_t);
+
+    void
+    _declare_namespace (const char* ns, const char* prefix);
+
+    void
+    _declare_default_namespace (const char* ns);
+
+    void
+    _clear_default_namespace ();
+  };
+}
+  
+class name_simpl: public name_sskel
+{
+public:
+  virtual std::string
+  first ()
+  {
+    return "John";
+  }
+
+  virtual ::std::string
+  last ()
+  {
+    return "Doe";
+  }
+
+  virtual bool
+  any_present ()
+  {
+    return true;
+  }
+
+  virtual void
+  any (std::string& ns, std::string& name)
+  {
+    ns = "http://www.example.com/extension";
+    name = "pseudonyms";
+  }
+
+  virtual void
+  serialize_any ()
+  {
+    _attribute ("id", "jd");
+
+    _start_element ("pseudonym");
+    _characters ("Johnny Doer");
+    _end_element ();
+
+    _start_element ("pseudonym");
+    _characters ("Johnty Doo");
+    _end_element ();
+  }
+};
+  
+<xs:complexType name="name">
+  <xs:sequence>
+    <xs:element name="first" type="xs:string"/>
+    <xs:element name="last" type="xs:string"/>
+  </xs:sequence>
+  <xs:anyAttribute namespace="##any" processContents="skip"/>
+</xs:complexType>
+  
+class name_sskel: public xml_schema::serializer_complex_content
+{
+public:
+  virtual void
+  pre ();
+
+  virtual bool
+  any_attribute_next ();
+
+  virtual void
+  any_attribute (std::string& ns, std::string& name);
+
+  virtual void
+  serialize_any_attribute ();
+
+  virtual std::string
+  first () = 0;
+
+  virtual std::string
+  last () = 0;
+
+  virtual void
+  post ();
+};
+  
+class name_simpl: public name_sskel
+{
+public:
+  virtual void
+  pre ()
+  {
+    id_written_ = false;
+  }
+
+  virtual bool
+  any_attribute_next ()
+  {
+    return !id_written_;
+  }
+
+  virtual void
+  any_attribute (std::string& ns, std::string& name)
+  {
+    ns = "";
+    name = "id";
+  }
+
+  virtual void
+  serialize_any_attribute ()
+  {
+    _characters ("jd");
+    id_written_ = true;
+  }
+
+  virtual std::string
+  first ()
+  {
+    return "John";
+  }
+
+  virtual ::std::string
+  last ()
+  {
+    return "Doe";
+  }
+
+private:
+  bool id_written_;
+};
+  
+class person_sskel
+{
+public:
+  virtual const char*
+  first_name ();
+
+  virtual const char*
+  last_name ();
+
+  ...
+};
+  
+void
+serialize (std::ostream&, flags);
+  
+<xs:complexType name="person">
+  <xs:sequence>
+    <xs:element name="first-name" type="xs:string"/>
+    <xs:element name="last-name" type="xs:string"/>
+    <xs:element name="age" type="xs:short"/>
+  </xs:sequence>
+</xs:complexType>
+
+<xs:complexType name="emplyee">
+  <complexContent>
+    <extension base="person">
+      <xs:sequence>
+        <xs:element name="position" type="xs:string"/>
+        <xs:element name="salary" type="xs:unsignedLong"/>
+      </xs:sequence>
+    </extension>
+  </complexContent>
+</xs:complexType>
+  
+class person_sskel: public virtual serializer_complex_content
+{
+  ...
+};
+
+class employee_sskel: public virtual person_sskel
+{
+  ...
+};
+  
+class person_simpl: public virtual person_sskel
+{
+  ...
+};
+
+class employee_simpl: public employee_sskel,
+                      public person_simpl
+{
+  ...
+};
+  
+class person_sskel: public serializer_complex_content
+{
+  ...
+};
+
+class employee_sskel: public person_sskel
+{
+public:
+  employee_sskel (person_sskel* base_impl)
+
+  ...
+};
+  
+class person_simpl: public person_sskel
+{
+  ...
+};
+
+class employee_simpl: public employee_sskel
+{
+public:
+  employee_simpl ()
+    : employee_sskel (&base_impl_)
+  {
+  }
+
+  ...
+
+private:
+  person_simpl base_impl_;
+};
+  
+class employee_simpl: public employee_sskel
+{
+public:
+  employee_simpl ()
+    : employee_sskel (&base_impl_)
+  {
+  }
+
+  virtual short
+  age ()
+  {
+    ...
+  }
+
+  ...
+
+private:
+  person_simpl base_impl_;
+};
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual void
+  pre (person* p)
+  {
+    person_ = p;
+  }
+
+  ...
+
+protected:
+  person* person_;
+};
+
+class employee_simpl: public employee_sskel,
+                      public person_simpl
+{
+public:
+  employee_simpl ()
+    : employee_sskel (static_cast<person_simpl*> (this))
+  {
+  }
+
+  // Resolve ambiguities.
+  //
+  using emplyee_sskel::serializers;
+
+  virtual void
+  pre (employee* e)
+  {
+    person_simpl::pre (e);
+  }
+
+  virtual std::string
+  position ()
+  {
+    return static_cast<employee*> (person_)->position ();
+  }
+
+  virtual unsigned int
+  salary ()
+  {
+    return static_cast<employee*> (person_)->salary ();
+  }
+};
+  
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+  <xs:complexType name="person">
+    <xs:sequence>
+      <xs:element name="name" type="xs:string"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <!-- substitution group root -->
+  <xs:element name="person" type="person"/>
+
+  <xs:complexType name="superman">
+    <xs:complexContent>
+      <xs:extension base="person">
+        <xs:attribute name="can-fly" type="xs:boolean"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:element name="superman"
+              type="superman"
+              substitutionGroup="person"/>
+
+  <xs:complexType name="batman">
+    <xs:complexContent>
+      <xs:extension base="superman">
+        <xs:attribute name="wing-span" type="xs:unsignedInt"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+
+  <xs:complexType name="supermen">
+    <xs:sequence>
+      <xs:element ref="person" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:element name="supermen" type="supermen"/>
+
+</xs:schema>
+  
+<supermen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+  <person>
+    <name>John Doe</name>
+  </person>
+
+  <superman can-fly="false">
+    <name>James "007" Bond</name>
+  </superman>
+
+  <person can-fly="true" wing-span="10" xsi:type="batman">
+    <name>Bruce Wayne</name>
+  </person>
+
+</supermen>
+  
+#include <string>
+#include <vector>
+
+enum type_id
+{
+  person_type,
+  superman_type,
+  batman_type
+};
+
+class person
+{
+public:
+  virtual
+  ~person () {}
+
+  person (const std::string& name)
+      : name_ (name)
+  {
+  }
+
+  const std::string&
+  name () const
+  {
+    return name_;
+  }
+
+  void
+  name (const std::string& n)
+  {
+    name_ = n;
+  }
+
+  virtual type_id
+  type () const
+  {
+    return person_type;
+  }
+
+private:
+  std::string name_;
+};
+
+class superman: public person
+{
+public:
+  superman (const std::string& name, bool can_fly)
+      : person (name), can_fly_ (can_fly)
+  {
+  }
+
+  bool
+  can_fly () const
+  {
+    return can_fly_;
+  }
+
+  void
+  can_fly (bool cf)
+  {
+    can_fly_ = cf;
+  }
+
+  virtual type_id
+  type () const
+  {
+    return superman_type;
+  }
+
+private:
+  bool can_fly_;
+};
+
+class batman: public superman
+{
+public:
+  batman (const std::string& name, unsigned int wing_span)
+      : superman (name, true), wing_span_ (wing_span)
+  {
+  }
+
+  unsigned int
+  wing_span () const
+  {
+    return wing_span_;
+  }
+
+  void
+  wing_span (unsigned int ws)
+  {
+    wing_span_ = ws;
+  }
+
+  virtual type_id
+  type () const
+  {
+    return batman_type;
+  }
+
+private:
+  unsigned int wing_span_;
+};
+
+// Poor man's polymorphic sequence which also assumes ownership
+// of the elements.
+//
+class supermen: public std::vector<person*>
+{
+public:
+  ~supermen ()
+  {
+    for (iterator i = begin (); i != end (); ++i)
+      delete *i;
+  }
+};
+  
+person   "const ::person&";
+superman "const ::person&";
+batman   "const ::person&";
+supermen "const ::supermen&";
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual void
+  pre (const person& p)
+  {
+    person_ = &p;
+  }
+
+  virtual std::string
+  name ()
+  {
+    return person_->name ();
+  }
+
+  // Derived serializer implementations need access to this
+  // member variable.
+  //
+public:
+  const person* person_;
+};
+
+class superman_simpl: public superman_sskel
+{
+public:
+  superman_simpl ()
+    : superman_sskel (&base_impl_)
+  {
+  }
+
+  virtual bool
+  can_fly ()
+  {
+    return superman_ ().can_fly ();
+  }
+
+  const superman&
+  superman_ ()
+  {
+    return *static_cast<const superman*> (base_impl_.person_);
+  }
+
+private:
+  person_simpl base_impl_;
+};
+
+class batman_simpl: public batman_sskel
+{
+public:
+  batman_simpl ()
+    : batman_sskel (&base_impl_)
+  {
+  }
+
+  virtual unsigned int
+  wing_span ()
+  {
+    return batman_ ().wing_span ();
+  }
+
+  const batman&
+  batman_ ()
+  {
+    return static_cast<const batman&> (base_impl_.superman_ ());
+  }
+
+private:
+  superman_simpl base_impl_;
+};
+
+class supermen_simpl: public supermen_sskel
+{
+public:
+  virtual void
+  pre (const supermen& s)
+  {
+    supermen_ = &s;
+    i_ = s.begin ();
+  }
+
+  virtual bool
+  person_next ()
+  {
+    return i_ != supermen_->end ();
+  }
+
+  virtual const ::person&
+  person ()
+  {
+    const ::person& p = **i_++;
+    xml_schema::serializer_context& ctx = _context ();
+
+    switch (p.type ())
+    {
+    case person_type:
+      {
+        ctx.type_id (person_sskel::_static_type ());
+        break;
+      }
+    case superman_type:
+      {
+        ctx.type_id (superman_sskel::_static_type ());
+        break;
+      }
+    case batman_type:
+      {
+        ctx.type_id (batman_sskel::_static_type ());
+        break;
+      }
+    }
+
+    return p;
+  }
+
+private:
+  const supermen* supermen_;
+  supermen::const_iterator i_;
+};
+  
+int
+main ()
+{
+  // Create a sample supermen catalog. To keep things simple
+  // the following code is not exception-safe.
+  //
+  supermen sm;
+
+  sm.push_back (new person ("John Doe"));
+  sm.push_back (new superman ("James 007 Bond", false));
+  sm.push_back (new batman ("Bruce Wayne", 10));
+
+  // Construct the serializer.
+  //
+  xml_schema::string_simpl string_s;
+  xml_schema::boolean_simpl boolean_s;
+  xml_schema::unsigned_int_simpl unsigned_int_s;
+
+  person_simpl person_s;
+  superman_simpl superman_s;
+  batman_simpl batman_s;
+
+  xml_schema::serializer_map_impl person_map (5); // 5 hashtable buckets
+  supermen_simpl supermen_s;
+
+  person_s.serializers (string_s);
+  superman_s.serializers (string_s, boolean_s);
+  batman_s.serializers (string_s, boolean_s, unsigned_int_s);
+
+  // Here we are specifying several serializers that can be
+  // used to serialize the person element.
+  //
+  person_map.insert (person_s);
+  person_map.insert (superman_s);
+  person_map.insert (batman_s);
+
+  supermen_s.person_serializer (person_map);
+
+  // Create the XML instance document. The last argument to the
+  // document's constructor indicates that we are serializing
+  // polymorphic XML documents.
+  //
+  xml_schema::document_simpl doc_s (supermen_s, "supermen", true);
+
+  supermen_s.pre (sm);
+  doc_s.serialize (std::cout, xml_schema::document_simpl::pretty_print);
+  supermen_s.post ();
+}
+  
+class supermen_sskel: public xml_schema::serializer_complex_content
+{
+public:
+
+  ...
+
+  // Serializer construction API.
+  //
+  void
+  serializers (person_sskel&);
+
+  // Individual element serializers.
+  //
+  void
+  person_serializer (person_sskel&);
+
+  void
+  person_serializer (xml_schema::serializer_map&);
+
+  ...
+};
+  
+int
+main ()
+{
+  ...
+
+  // Here we are specifying several serializers that can be
+  // used to serialize the person element.
+  //
+  person_map.insert (superman_s);
+  person_map.insert (batman_s);
+
+  supermen_s.person_serializer (person_s);
+  supermen_s.person_serializer (person_map);
+
+  ...
+}
+  
+namespace xml_schema
+{
+  class serializer_map
+  {
+  public:
+    virtual serializer_base*
+    find (const void* type_id) const = 0;
+
+    virtual void
+    reset () const = 0;
+  };
+
+  class serializer_map_impl: public serializer_map
+  {
+  public:
+    serializer_map_impl (size_t buckets);
+
+    // Note that the type_id string is not copied so it should
+    // be valid for the lifetime of the map.
+    //
+    void
+    insert (const char* type_id, serializer_base&);
+
+    // This version of insert is a shortcut that uses the string
+    // returned by the serializer's _dynamic_type() function.
+    //
+    void
+    insert (serializer_base&);
+
+    virtual serializer_base*
+    find (const void* type_id) const;
+
+    virtual void
+    reset () const;
+
+  private:
+    serializer_map_impl (const serializer_map_impl&);
+
+    serializer_map_impl&
+    operator= (const serializer_map_impl&);
+
+    ...
+  };
+}
+  
+namespace xml_schema
+{
+  class serializer_map_impl: public serializer_map
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    error
+    _error () const;
+
+    ...
+  };
+}
+  
+#include <map>
+
+class person_serializer_map: public xml_schema::serializer_map
+{
+public:
+ void
+ insert (person_sskel& p)
+ {
+   const char* dt = p._dynamic_type ();
+   type_id ti;
+
+   if (strcmp (dt, person_sskel::_static_type ()) == 0)
+     ti = person_type;
+   else if (strcmp (dt, superman_sskel::_static_type ()) == 0)
+     ti = superman_type;
+   else if (strcmp (dt, batman_sskel::_static_type ()) == 0)
+     ti = batman_type;
+   else
+     return;
+
+   map_[ti] = &p;
+ }
+
+ virtual xml_schema::serializer_base*
+ find (const char* x) const
+ {
+   const person* p = static_cast<const person*> (x);
+   map::const_iterator i = map_.find (p->type ());
+   return i != map_.end () ? i->second : 0;
+ }
+
+ virtual void
+ reset () const
+ {
+   for (map::const_iterator i (map_.begin ()), e (map_.end ());
+        i != e; ++i)
+   {
+     person_sskel* s = i->second;
+     s->_reset ();
+   }
+ }
+
+private:
+  typedef std::map<type_id, person_sskel*> map;
+  map map_;
+};
+  
+  virtual const ::person&
+  person ()
+  {
+    const ::person& p = **i_++;
+    _context ().type_id (&p);
+    return p;
+  }
+  
+int
+main ()
+{
+  // Check that the load in substitution and inheritance hashmaps
+  // is not too high.
+  //
+#ifndef NDEBUG
+  float load = xml_schema::serializer_smap_elements ();
+  load /= xml_schema::serializer_smap_buckets ();
+
+  if (load > 0.8)
+  {
+    cerr << "substitution hashmap load is " << load << endl;
+    cerr << "time to increase XSDE_SERIALIZER_SMAP_BUCKETS" << endl;
+  }
+
+  load = xml_schema::serializer_smap_bucket_elements ();
+  load /= xml_schema::serializer_smap_bucket_buckets ();
+
+  if (load > 0.8)
+  {
+    cerr << "substitution inner hashmap load is " << load << endl;
+    cerr << "time to increase XSDE_SERIALIZER_SMAP_BUCKET_BUCKETS" << endl;
+  }
+
+  load = xml_schema::serializer_imap_elements ();
+  load /= xml_schema::serializer_imap_buckets ();
+
+  if (load > 0.8)
+  {
+    cerr << "inheritance hashmap load is " << load << endl;
+    cerr << "time to increase XSDE_SERIALIZER_IMAP_BUCKETS" << endl;
+  }
+#endif
+
+  ...
+}
+  
+extern "C" void*
+xsde_alloc (size_t);
+
+extern "C" void*
+xsde_realloc (void*, size_t);
+
+extern "C" void
+xsde_free (void*);
+  
+namespace xml_schema
+{
+  void*
+  alloc (size_t);
+
+  void
+  free (void*);
+
+  struct alloc_guard
+  {
+    alloc_guard (void*);
+    ~alloc_guard ();
+
+    void*
+    get () const;
+
+    void
+    release ();
+
+  private:
+    ...
+  };
+}
+  
+void* v = xml_schema::alloc (sizeof (type));
+
+if (v == 0)
+{
+  // Handle out of memory condition.
+}
+
+type* x = new (v) type (1, 2);
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+xml_schema::alloc_guard g (xml_schema::alloc (sizeof (type)));
+type* x = new (g.get ()) type (1, 2);
+g.release ();
+
+...
+
+if (x)
+{
+  x->~type ();
+  xml_schema::free (x);
+}
+  
+#include <stddef.h> // size_t
+
+enum gender
+{
+  male,
+  female
+};
+
+struct person
+{
+  const char* first_name_;
+  const char* last_name_;
+  gender gender_;
+  unsigned short age_;
+};
+
+struct people
+{
+  person* people_;
+  size_t size_;
+};
+  
+#include <stdio.h>
+#include "people-sskel.hxx"
+
+const char* gender_strings[] = {"male", "female"};
+
+class gender_simpl: public gender_sskel
+{
+public:
+  gender_simpl ()
+    : gender_sskel (&base_impl_)
+  {
+  }
+
+  virtual void
+  pre (gender g)
+  {
+    base_impl_.pre (gender_strings[g]);
+  }
+
+private:
+  public xml_schema::string_simpl base_impl_;
+};
+
+class person_simpl: public person_sskel
+{
+public:
+  virtual void
+  pre (const person& p)
+  {
+    person_ = &p;
+  }
+
+  virtual const char*
+  first_name ()
+  {
+    return person_->first_name_;
+  }
+
+  virtual const char*
+  last_name ()
+  {
+    return person_->last_name_;
+  }
+
+  virtual ::gender
+  gender ()
+  {
+    return person_->gender_;
+  }
+
+  virtual unsigned short
+  age ()
+  {
+    return person_->age_;
+  }
+
+private:
+  const person* person_;
+};
+
+class people_simpl: public people_sskel
+{
+public:
+  virtual void
+  pre (const people& p)
+  {
+    i_ = 0;
+    people_ = &p;
+  }
+
+  virtual bool
+  person_next ()
+  {
+    return i_ < people_->size_;
+  }
+
+  virtual const ::person&
+  person ()
+  {
+    return people_->people_[i_++];
+  }
+
+private:
+  size_t i_;
+  const people* people_;
+};
+
+class writer: public xml_schema::writer
+{
+public:
+  virtual bool
+  write (const char* s, size_t n)
+  {
+    return fwrite (s, n, 1, stdout) == 1;
+  }
+
+  virtual bool
+  flush ()
+  {
+    return fflush (stdout) == 0;
+  }
+};
+
+int
+main ()
+{
+  // Create a sample person list.
+  //
+  people p;
+
+  p.size_ = 2;
+  p.people_ = new person[p.size_];
+
+  if (p.people_ == 0)
+  {
+    fprintf (stderr, "error: no memory\n");
+    return 1;
+  }
+
+  p.people_[0].first_name_ = "John";
+  p.people_[0].last_name_ = "Doe";
+  p.people_[0].gender_ = male;
+  p.people_[0].age_ = 32;
+
+  p.people_[1].first_name_ = "Jane";
+  p.people_[1].last_name_ = "Doe";
+  p.people_[1].gender_ = female;
+  p.people_[1].age_ = 28;
+
+  // Construct the serializer.
+  //
+  xml_schema::unsigned_short_simpl unsigned_short_s;
+  xml_schema::string_simpl string_s;
+
+  gender_simpl gender_s;
+  person_simpl person_s;
+  people_simpl people_s;
+
+  person_s.serializers (string_s, string_s, gender_s, unsigned_short_s);
+  people_s.serializers (person_s);
+
+  // Serialize.
+  //
+  typedef xml_schema::serializer_error error;
+
+  error e;
+  writer w;
+
+  do
+  {
+    xml_schema::document_simpl doc_s (people_s, "people");
+
+    if (e = doc_s._error ())
+      break;
+
+    people_s.pre (p);
+
+    if (e = people_s._error ())
+      break;
+
+    doc_s.serialize (w, xml_schema::document_simpl::pretty_print);
+
+    if (e = doc_s._error ())
+      break;
+
+    people_s.post ();
+
+    e = people_s._error ();
+
+  } while (false);
+
+  delete[] p.people_;
+
+  // Handle errors.
+  //
+  if (e)
+  {
+    switch (e.type ())
+    {
+    case error::sys:
+      {
+        fprintf (stderr, "error: %s\n", e.sys_text ());
+        break;
+      }
+    case error::xml:
+      {
+        fprintf (stderr, "error: %s\n", e.xml_text ());
+        break;
+      }
+    case error::schema:
+      {
+        fprintf (stderr, "error: %s\n", e.schema_text ());
+        break;
+      }
+    case error::app:
+      {
+        fprintf (stderr, "application error: %d\n", e.app_code ());
+        break;
+      }
+    default:
+      break;
+    }
+
+    return 1;
+  }
+
+  return 0;
+}
+  
+namespace xml_schema
+{
+  class float_simpl: public float_sskel
+  {
+    enum notation
+    {
+      notation_auto,
+      notation_fixed,
+      notation_scientific
+    };
+
+    float_simpl (notation = notation_auto,
+                 unsigned int precision = FLT_DIG);
+
+    virtual void
+    pre (float);
+
+    ...
+  };
+
+  class double_simpl: public double_sskel
+  {
+    enum notation
+    {
+      notation_auto,
+      notation_fixed,
+      notation_scientific
+    };
+
+    double_simpl (notation = notation_auto,
+                  unsigned int precision = DBL_DIG);
+
+    virtual void
+    pre (double);
+
+    ...
+  };
+
+  class decimal_simpl: public decimal_sskel
+  {
+    decimal_simpl (unsigned int precision = DBL_DIG);
+
+    virtual void
+    pre (double);
+
+    ...
+  };
+}
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual const char*
+  first_name ()
+  {
+    char* r = new char[5];
+    strcpy (r, "John");
+    return r;
+  }
+
+  virtual const char*
+  last_name ()
+  {
+    char* r = new char[4];
+    strcpy (r, "Doe");
+    return r;
+  }
+
+  ...
+};
+
+int
+main ()
+{
+  // Construct the serializer.
+  //
+  xml_schema::unsigned_short_simpl unsigned_short_s;
+  xml_schema::string_simpl string_s (true); // Release the string passed.
+
+  gender_simpl gender_s;
+  person_simpl person_s;
+  people_simpl people_s;
+
+  person_s.serializers (string_s, string_s, gender_s, unsigned_short_s);
+
+  ...
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (const std::string& name);
+    qname (const std::string& prefix, const std::string& name);
+
+    void
+    swap (qname&);
+
+    const std::string&
+    prefix () const;
+
+    std::string&
+    prefix ();
+
+    void
+    prefix (const std::string&);
+
+    const std::string&
+    name () const;
+
+    std::string&
+    name ();
+
+    void
+    name (const std::string&);
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    void
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    void
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+
+namespace xml_schema
+{
+  class qname
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    qname ();
+
+    explicit
+    qname (char* name);
+    qname (char* prefix, char* name);
+
+    void
+    swap (qname&);
+
+  private:
+    qname (const qname&);
+
+    qname&
+    operator= (const qname&);
+
+  public:
+    char*
+    prefix ();
+
+    const char*
+    prefix () const;
+
+    void
+    prefix (char*);
+
+    error
+    prefix_copy (const char*);
+
+    char*
+    prefix_detach ();
+
+  public:
+    char*
+    name ();
+
+    const char*
+    name () const;
+
+    void
+    name (char*);
+
+    error
+    name_copy (const char*);
+
+    char*
+    name_detach ();
+  };
+
+  bool
+  operator== (const qname&, const qname&);
+
+  bool
+  operator!= (const qname&, const qname&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    typedef std::string         value_type;
+    typedef std::string*        pointer;
+    typedef const std::string*  const_pointer;
+    typedef std::string&        reference;
+    typedef const std::string&  const_reference;
+
+    typedef size_t              size_type;
+    typedef ptrdiff_t           difference_type;
+
+    typedef std::string*        iterator;
+    typedef const std::string*  const_iterator;
+
+  public:
+    string_sequence ();
+
+    void
+    swap (string_sequence&);
+
+  private:
+    string_sequence (string_sequence&);
+
+    string_sequence&
+    operator= (string_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    std::string&
+    front ();
+
+    const std::string&
+    front () const;
+
+    std::string&
+    back ();
+
+    const std::string&
+    back () const;
+
+    std::string&
+    operator[] (size_t);
+
+    const std::string&
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (const std::string&);
+
+    iterator
+    insert (iterator, const std::string&);
+
+    void
+    reserve (size_t);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (const std::string&);
+
+    error
+    insert (iterator, const std::string&);
+
+    error
+    insert (iterator, const std::string&, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    typedef char*         value_type;
+    typedef char**        pointer;
+    typedef const char**  const_pointer;
+    typedef char*         reference;
+    typedef const char*   const_reference;
+
+    typedef size_t        size_type;
+    typedef ptrdiff_t     difference_type;
+
+    typedef char** iterator;
+    typedef const char* const* const_iterator;
+
+    string_sequence ();
+
+    void
+    swap (string_sequence&);
+
+  private:
+    string_sequence (string_sequence&);
+
+    string_sequence&
+    operator= (string_sequence&);
+
+  public:
+    iterator
+    begin ();
+
+    const_iterator
+    begin () const;
+
+    iterator
+    end ();
+
+    const_iterator
+    end () const;
+
+    char*
+    front ();
+
+    const char*
+    front () const;
+
+    char*
+    back ();
+
+    const char*
+    back () const;
+
+    char*
+    operator[] (size_t);
+
+    const char*
+    operator[] (size_t) const;
+
+  public:
+    bool
+    empty () const;
+
+    size_t
+    size () const;
+
+    size_t
+    capacity () const;
+
+    size_t
+    max_size () const;
+
+  public:
+    void
+    clear ();
+
+    void
+    pop_back ();
+
+    iterator
+    erase (iterator);
+
+    void
+    push_back (char*);
+
+    void
+    push_back_copy (const char*);
+
+    iterator
+    insert (iterator, char*);
+
+    void
+    reserve (size_t);
+
+    // Detach a string from the sequence at a given position.
+    // The string pointer at this position in the sequence is
+    // set to 0.
+    //
+    char*
+    detach (iterator);
+  };
+
+  bool
+  operator== (const string_sequence&, const string_sequence&);
+
+  bool
+  operator!= (const string_sequence&, const string_sequence&);
+}
+  
+namespace xml_schema
+{
+  class string_sequence
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_no_memory
+    };
+
+    ...
+
+  public:
+    error
+    push_back (char*);
+
+    error
+    push_back_copy (const char*);
+
+    error
+    insert (iterator, char*);
+
+    error
+    insert (iterator, char*, iterator& result);
+
+    error
+    reserve (size_t);
+  };
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    class bounds {}; // Out of bounds exception.
+
+  public:
+    buffer ();
+
+    explicit
+    buffer (size_t size);
+    buffer (size_t size, size_t capacity);
+    buffer (const void* data, size_t size);
+    buffer (const void* data, size_t size, size_t capacity);
+
+    enum ownership_value { assume_ownership };
+
+    // This constructor assumes ownership of the memory passed.
+    //
+    buffer (void* data, size_t size, size_t capacity, ownership_value);
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    void
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+    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 ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  class buffer
+  {
+  public:
+    enum error
+    {
+      error_none,
+      error_bounds,
+      error_no_memory
+    };
+
+    buffer ();
+
+  private:
+    buffer (const buffer&);
+
+    buffer&
+    operator= (const buffer&);
+
+  public:
+    error
+    attach (void* data, size_t size, size_t capacity);
+
+    void*
+    detach ();
+
+    void
+    swap (buffer&);
+
+  public:
+    size_t
+    capacity () const;
+
+    error
+    capacity (size_t);
+
+    error
+    capacity (size_t, bool& moved);
+
+  public:
+    size_t
+    size () const;
+
+    error
+    size (size_t);
+
+    error
+    size (size_t, bool& moved);
+
+  public:
+    const char*
+    data () const;
+
+    char*
+    data ();
+
+    const char*
+    begin () const;
+
+    char*
+    begin ();
+
+    const char*
+    end () const;
+
+    char*
+    end ();
+  };
+
+  bool
+  operator== (const buffer&, const buffer&);
+
+  bool
+  operator!= (const buffer&, const buffer&);
+}
+  
+namespace xml_schema
+{
+  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&);
+}
+  
+namespace xml_schema
+{
+  class date: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date ();
+
+    date (int year, unsigned short month, unsigned short day);
+
+    date (int year, unsigned short month, unsigned short day,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class date_time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    date_time ();
+
+    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);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class duration
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    duration ();
+
+    duration (bool negative,
+              unsigned int years, unsigned int months, unsigned int days,
+              unsigned int hours, unsigned int minutes, double seconds);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gday: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gday ();
+
+    explicit
+    gday (unsigned short day);
+
+    gday (unsigned short day, short zone_hours, short zone_minutes);
+
+    unsigned short
+    day () const;
+
+    void
+    day (unsigned short);
+  };
+
+  bool
+  operator== (const gday&, const gday&);
+
+  bool
+  operator!= (const gday&, const gday&);
+}
+  
+namespace xml_schema
+{
+  class gmonth: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth ();
+
+    explicit
+    gmonth (unsigned short month);
+
+    gmonth (unsigned short month,
+            short zone_hours, short zone_minutes);
+
+    unsigned short
+    month () const;
+
+    void
+    month (unsigned short);
+  };
+
+  bool
+  operator== (const gmonth&, const gmonth&);
+
+  bool
+  operator!= (const gmonth&, const gmonth&);
+}
+  
+namespace xml_schema
+{
+  class gmonth_day: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gmonth_day ();
+
+    gmonth_day (unsigned short month, unsigned short day);
+
+    gmonth_day (unsigned short month, unsigned short day,
+                short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class gyear: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear ();
+
+    explicit
+    gyear (int year);
+
+    gyear (int year, short zone_hours, short zone_minutes);
+
+    int
+    year () const;
+
+    void
+    year (int);
+  };
+
+  bool
+  operator== (const gyear&, const gyear&);
+
+  bool
+  operator!= (const gyear&, const gyear&);
+}
+  
+namespace xml_schema
+{
+  class gyear_month: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    gyear_month ();
+
+    gyear_month (int year, unsigned short month);
+
+    gyear_month (int year, unsigned short month,
+                 short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class time: public time_zone
+  {
+  public:
+    // The default constructor creates an uninitialized object.
+    // Use modifiers to initialize it.
+    //
+    time ();
+
+    time (unsigned short hours, unsigned short minutes, double seconds);
+
+    time (unsigned short hours, unsigned short minutes, double seconds,
+          short zone_hours, short zone_minutes);
+
+    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&);
+}
+  
+namespace xml_schema
+{
+  class serializer_base;
+
+  class writer
+  {
+  public:
+    // The first write function is called to write a '\0'-terminated
+    // string. Its default implementation calls the second versions:
+    // write (s, strlen (s)). These functions use exceptions to
+    // indicate a write failure.
+    //
+    virtual void
+    write (const char* s);
+
+    virtual void
+    write (const char* s, size_t n) = 0;
+
+    virtual void
+    flush () = 0;
+  };
+
+  class document_simpl
+  {
+  public:
+    document_simpl (serializer_base&,
+                    const char* root_element_name);
+
+    document_simpl (serializer_base&,
+                    const char* root_element_namespace,
+                    const char* root_element_name);
+
+    document_simpl (serializer_base&,
+                    const std::string& root_element_name);
+
+    document_simpl (serializer_base&,
+                    const std::string& root_element_namespace,
+                    const std::string& root_element_name);
+
+  public:
+    void
+    add_prefix (const char* prefix, const char* namespace_);
+
+    void
+    add_default_prefix (const char* namespace_);
+
+    void
+    add_schema (const char* namespace_, const char* location);
+
+    void
+    add_no_namespace_schema (const char* location);
+
+    void
+    add_prefix (const std::string& prefix,
+                const std::string& namespace_);
+
+    void
+    add_default_prefix (const std::string& namespace_);
+
+    void
+    add_schema (const std::string& namespace_,
+                const std::string& location);
+
+    void
+    add_no_namespace_schema (const std::string& location);
+
+  public:
+    // Serialization flags.
+    //
+    typedef unsigned short flags;
+
+    static const flags pretty_print;
+
+  public:
+    // Serialize to std::ostream. The std::ios_base::failure
+    // exception is used to report io errors (badbit and failbit)
+    // if C++ exceptions are enabled. Otherwise error codes are
+    // used.
+    //
+    void
+    serialize (std::ostream&, flags = 0);
+
+  public:
+    // Serialize by calling writer::write() and writer::flush() to
+    // output XML.
+    //
+    void
+    serialize (writer&, flags = 0);
+
+    // Serialize by calling the write and flush functions. If the
+    // unbounded write function is not provided, the bounded version
+    // is called: write_bound_func (s, strlen (s)). user_data is
+    // passed as a first argument to these functions. These functions
+    // use exceptions to indicate a write failure.
+    //
+    typedef void (*write_func) (void*, const char*);
+    typedef void (*write_bound_func) (void*, const char*, size_t);
+    typedef void (*flush_func) (void*);
+
+    void
+    serialize (write_bound_func,
+               flush_func,
+               void* user_data,
+               flags = 0);
+
+    void
+    serialize (write_func,
+               write_bound_func,
+               flush_func,
+               void* user_data,
+               flags = 0);
+  public:
+    // Low-level, genx-specific serialization. With this method
+    // it is your responsibility to call genxStartDoc*() and
+    // genxEndDocument().
+    //
+    void
+    serialize (genxWriter);
+  };
+}
+  
+namespace xml_schema
+{
+  class serializer_base;
+
+  class writer
+  {
+  public:
+    // The first write function is called to write a '\0'-terminated
+    // string. Its default implementation calls the second versions:
+    // write (s, strlen (s)). These functions return true if the
+    // operation was successful and false otherwise.
+    //
+    // indicate a write failure.
+    //
+    virtual bool
+    write (const char* s);
+
+    virtual bool
+    write (const char* s, size_t n) = 0;
+
+    virtual bool
+    flush () = 0;
+  };
+
+  class document_simpl
+  {
+    ...
+
+    // Serialize by calling the write and flush functions. If the
+    // unbounded write function is not provided, the bounded version
+    // is called: write_bound_func (s, strlen (s)). user_data is
+    // passed as a first argument to these functions. These functions
+    // return true if the operation was successful and false otherwise.
+    //
+    typedef bool (*write_func) (void*, const char*);
+    typedef bool (*write_bound_func) (void*, const char*, size_t);
+    typedef bool (*flush_func) (void*);
+
+    ...
+
+  public:
+    const serializer_error&
+    _error () const;
+  };
+}
+  
+xml_schema::document_simpl doc_s (
+  root_s,
+  "http://www.example.com/example",
+  "root");
+
+doc_s.add_prefix ("ex", "http://www.example.com/example");
+  
+<ex:root xmlns:ex="http://www.example.com/example" ...>
+  ...
+</ex:root>
+  
+xml_schema::document_simpl doc_s (
+  root_s,
+  "http://www.example.com/example",
+  "root");
+
+doc_s.add_prefix ("ex", "http://www.example.com/example");
+doc_s.add_schema ("http://www.example.com/example", "example.xsd");
+  
+<ex:root
+  xmlns:ex="http://www.example.com/example"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://www.example.com/example example.xsd" ...>
+  ...
+</ex:root>
+  
+namespace xml_schema
+{
+  class serializer_exception: public std::exception
+  {
+  public:
+    virtual const char*
+    text () const = 0;
+
+    ...
+  };
+
+  std::ostream&
+  operator<< (std::ostream&, const serializer_exception&);
+
+
+  typedef <implementation-details> serializer_xml_error;
+
+  class serializer_xml: public serializer_exception
+  {
+  public:
+    serializer_xml_error
+    code () const;
+
+    virtual const char*
+    text () const;
+
+    virtual const char*
+    what () const throw ();
+
+    ...
+  };
+
+
+  typedef <implementation-details> serializer_schema_error;
+
+  class serializer_schema: public serializer_exception
+  {
+  public:
+    serializer_schema_error
+    code () const;
+
+    virtual const char*
+    text () const;
+
+    virtual const char*
+    what () const throw ();
+
+    ...
+  };
+}
+  
+int
+main ()
+{
+  try
+  {
+    // Serialize.
+  }
+  catch (const xml_schema::serializer_exception& e)
+  {
+    cout << "error: " << e.text () << endl;
+    return 1;
+  }
+}
+  
+xml_schema::serializer_error
+_error () const;
+  
+namespace xml_schema
+{
+  class sys_error
+  {
+  public:
+    enum value
+    {
+      none,
+      no_memory,
+      open_failed,
+      read_failed,
+      write_failed
+    };
+
+    sys_error (value);
+
+    operator value () const;
+
+    static const char*
+    text (value);
+
+    ...
+  };
+
+  typedef <implementation-details> serializer_xml_error;
+  typedef <implementation-details> serializer_schema_error;
+
+  class serializer_error
+  {
+  public:
+    enum error_type
+    {
+      none,
+      sys,
+      xml,
+      schema,
+      app
+    };
+
+    error_type
+    type () const;
+
+    // Returns true if there is an error so that you can write
+    // if (s.error ()) or if (error e = s.error ()).
+    //
+    typedef void (error::*bool_convertible) ();
+    operator bool_convertible () const;
+
+    // system
+    //
+    sys_error
+    sys_code () const;
+
+    const char*
+    sys_text () const;
+
+    // xml
+    //
+    serializer_xml_error
+    xml_code () const;
+
+    const char*
+    xml_text () const;
+
+    // schema
+    //
+    serializer_schema_error
+    schema_code () const;
+
+    const char*
+    schema_text () const;
+
+    // app
+    //
+    int
+    app_code () const;
+
+    ...
+  };
+}
+  
+int
+main ()
+{
+  // Construct the serializer.
+  //
+  xml_schema::short_simpl short_s;
+  xml_schema::string_simpl string_s;
+
+  gender_simpl gender_s;
+  person_simpl person_s;
+  people_simpl people_s;
+
+  person_s.serializers (string_s, string_s, gender_s, short_s);
+  people_s.serializers (person_s);
+
+  // Serialize.
+  //
+  using xml_schema::serializer_error;
+  serializer_error e;
+
+  do
+  {
+    xml_schema::document_simpl doc_s (people_s, "people");
+    if (e = doc_s._error ())
+      break;
+
+    people_s.pre ();
+    if (e = people_s._error ())
+      break;
+
+    doc_s.serialize (cout);
+    if (e = doc_s._error ())
+      break;
+
+    people_s.post ();
+    e = people_s._error ();
+
+  } while (false);
+
+  // Handle errors.
+  //
+  if (e)
+  {
+    switch (e.type ())
+    {
+    case serializer_error::sys:
+      {
+        cerr << "system error: " << e.sys_text () << endl;
+        break;
+      }
+    case serializer_error::xml:
+      {
+        cerr << "xml error: " << e.xml_text () << endl;
+        break;
+      }
+    case serializer_error::schema:
+      {
+        cerr << "schema error: " << e.schema_text () << endl;
+        break;
+      }
+    case serializer_error::app:
+      {
+        cerr << "application error: " << e.app_code () << endl;
+        break;
+      }
+    }
+    return 1;
+  }
+}
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual short
+  age ()
+  {
+    short a = ...;
+
+    if (a < 18)
+      _app_error (1);
+
+    return a;
+  }
+};
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual const char*
+  first_name ()
+  {
+    char* r = new char[5];
+
+    if (r == 0)
+    {
+      _sys_error (xml_schema::sys_error::no_memory);
+      return 0;
+    }
+
+    strcpy (r, "John");
+    return r;
+  }
+};
+  
+int
+main ()
+{
+  ...
+
+  xml_schema::document_simpl doc_s (people_s, "people");
+
+  for (size_t i = 0; i < 4; ++i)
+  {
+    try
+    {
+      people_s.pre ();
+      doc_s.serialize (cout);
+      people_s.post ();
+    }
+    catch (const xml_schema::serializer_exception&)
+    {
+      doc_s.reset ();
+    }
+  }
+}
+  
+class person_simpl: public person_sskel
+{
+public:
+  virtual void
+  pre (person* p)
+  {
+    p_ = p;
+  }
+
+  virtual void
+  post ()
+  {
+    delete p_;
+    p_ = 0;
+  }
+
+  virtual void
+  _reset ()
+  {
+    person_sskel::_reset ();
+    delete p_;
+    p_ = 0;
+  }
+
+  ...
+
+private:
+  person* p_;
+};
+

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` or `long long` + Section 3.5, "64-bit Integer Type"
`unsignedLong`	`unsigned_long`	`unsigned long` or + `unsigned long long` + Section 3.5, "64-bit Integer Type"
arbitrary-length integral types
`integer`	`integer`	`long`
`nonPositiveInteger`	`non_positive_integer`	`long`
`nonNegativeInteger`	`non_negative_integer`	`unsigned long`
`positiveInteger`	`positive_integer`	`unsigned long`
`negativeInteger`	`negative_integer`	`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`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`normalizedString`	`normalized_string`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`token`	`token`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`Name`	`name`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`NMTOKEN`	`nmtoken`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`NMTOKENS`	`nmtokens`	Section 5.2, "Mapping for `NMTOKENS` and `IDREFS`"
`NCName`	`ncname`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`language`	`language`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
qualified name
`QName`	`qname`	Section 5.1, "Mapping for `QName`"
ID/IDREF types
`ID`	`id`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`IDREF`	`idref`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
`IDREFS`	`idrefs`	Section 5.2, "Mapping for `NMTOKENS` and `IDREFS`"
URI types
`anyURI`	`uri`	`std::string` or `char*` + Section 3.1, "Standard Template Library"
binary types
`base64Binary`	`base64_binary`	Section 5.3, "Mapping for `base64Binary` and `hexBinary`"
`hexBinary`	`hex_binary`	Section 5.3, "Mapping for `base64Binary` and `hexBinary`"
date/time types
`date`	`date`	Section 5.5, "Mapping for `date`"
`dateTime`	`date_time`	Section 5.6, "Mapping for `dateTime`"
`duration`	`duration`	Section 5.7, "Mapping for `duration`"
`gDay`	`gday`	Section 5.8, "Mapping for `gDay`"
`gMonth`	`gmonth`	Section 5.9, "Mapping for `gMonth`"
`gMonthDay`	`gmonth_day`	Section 5.10, "Mapping for `gMonthDay`"
`gYear`	`gyear`	Section 5.11, "Mapping for `gYear`"
`gYearMonth`	`gyear_month`	Section 5.12, "Mapping for `gYearMonth`"
`time`	`time`	Section 5.13, "Mapping for `time`"
anyType and anySimpleType
`anyType`	`any_type`	Section 5.14, "Mapping for `anyType`"
`anySimpleType`	`any_simple_type`	`std::string` or `char*` + Section 3.1, "Standard Template Library"

XML Schema type	Parser implementation in the `xml_schema` namespace	Parser return type
anyType and anySimpleType types
`anyType`	`any_type_pimpl`	`void`
`anySimpleType`	`any_simple_type_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
fixed-length integral types
`byte`	`byte_pimpl`	`signed char`
`unsignedByte`	`unsigned_byte_pimpl`	`unsigned char`
`short`	`short_pimpl`	`short`
`unsignedShort`	`unsigned_short_pimpl`	`unsigned short`
`int`	`int_pimpl`	`int`
`unsignedInt`	`unsigned_int_pimpl`	`unsigned int`
`long`	`long_pimpl`	`long long` or `long` + Section 5.5, "64-bit Integer Type"
`unsignedLong`	`unsigned_long_pimpl`	`unsigned long long` or + `unsigned long` + Section 5.5, "64-bit Integer Type"
arbitrary-length integral types
`integer`	`integer_pimpl`	`long`
`nonPositiveInteger`	`non_positive_integer_pimpl`	`long`
`nonNegativeInteger`	`non_negative_integer_pimpl`	`unsigned long`
`positiveInteger`	`positive_integer_pimpl`	`unsigned long`
`negativeInteger`	`negative_integer_pimpl`	`long`
boolean types
`boolean`	`boolean_pimpl`	`bool`
fixed-precision floating-point types
`float`	`float_pimpl`	`float`
`double`	`double_pimpl`	`double`
arbitrary-precision floating-point types
`decimal`	`decimal_pimpl`	`double`
string-based types
`string`	`string_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`normalizedString`	`normalized_string_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`token`	`token_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`Name`	`name_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`NMTOKEN`	`nmtoken_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`NCName`	`ncname_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`language`	`language_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
qualified name
`QName`	`qname_pimpl`	`xml_schema::qname` or `xml_schema::qname*` + Section 6.1, "`QName` Parser"
ID/IDREF types
`ID`	`id_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
`IDREF`	`idref_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
list types
`NMTOKENS`	`nmtokens_pimpl`	`xml_schema::string_sequence*` Section + 6.2, "`NMTOKENS` and `IDREFS` Parsers"
`IDREFS`	`idrefs_pimpl`	`xml_schema::string_sequence*` Section + 6.2, "`NMTOKENS` and `IDREFS` Parsers"
URI types
`anyURI`	`uri_pimpl`	`std::string` or `char*` + Section 5.1, "Standard Template Library"
binary types
`base64Binary`	`base64_binary_pimpl`	`xml_schema::buffer*` + Section 6.3, "`base64Binary` and + `hexBinary` Parsers"
`hexBinary`	`hex_binary_pimpl`	`xml_schema::buffer*` + Section 6.3, "`base64Binary` and + `hexBinary` Parsers"
date/time types
`date`	`date_pimpl`	`xml_schema::date` Section 6.5, + "`date` Parser"
`dateTime`	`date_time_pimpl`	`xml_schema::date_time` Section 6.6, + "`dateTime` Parser"
`duration`	`duration_pimpl`	`xml_schema::duration` Section 6.7, + "`duration` Parser"
`gDay`	`gday_pimpl`	`xml_schema::gday` Section 6.8, + "`gDay` Parser"
`gMonth`	`gmonth_pimpl`	`xml_schema::gmonth` Section 6.9, + "`gMonth` Parser"
`gMonthDay`	`gmonth_day_pimpl`	`xml_schema::gmonth_day` Section 6.10, + "`gMonthDay` Parser"
`gYear`	`gyear_pimpl`	`xml_schema::gyear` Section 6.11, + "`gYear` Parser"
`gYearMonth`	`gyear_month_pimpl`	`xml_schema::gyear_month` Section + 6.12, "`gYearMonth` Parser"
`time`	`time_pimpl`	`xml_schema::time` Section 6.13, + "`time` Parser"

XML Schema type	Serializer implementation in the `xml_schema` namespace	Serializer argument type
anyType and anySimpleType types
`anyType`	`any_type_simpl`	`void`
`anySimpleType`	`any_simple_type_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
fixed-length integral types
`byte`	`byte_simpl`	`signed char`
`unsignedByte`	`unsigned_byte_simpl`	`unsigned char`
`short`	`short_simpl`	`short`
`unsignedShort`	`unsigned_short_simpl`	`unsigned short`
`int`	`int_simpl`	`int`
`unsignedInt`	`unsigned_int_simpl`	`unsigned int`
`long`	`long_simpl`	`long long` or `long` + Section 6.5, "64-bit Integer Type"
`unsignedLong`	`unsigned_long_simpl`	`unsigned long long` or + `unsigned long` + Section 6.5, "64-bit Integer Type"
arbitrary-length integral types
`integer`	`integer_simpl`	`long`
`nonPositiveInteger`	`non_positive_integer_simpl`	`long`
`nonNegativeInteger`	`non_negative_integer_simpl`	`unsigned long`
`positiveInteger`	`positive_integer_simpl`	`unsigned long`
`negativeInteger`	`negative_integer_simpl`	`long`
boolean types
`boolean`	`boolean_simpl`	`bool`
fixed-precision floating-point types
`float`	`float_simpl`	`float` + Section 7.1, "Floating-Point Type Serializers"
`double`	`double_simpl`	`double` + Section 7.1, "Floating-Point Type Serializers"
arbitrary-precision floating-point types
`decimal`	`decimal_simpl`	`double` + Section 7.1, "Floating-Point Type Serializers"
string-based types
`string`	`string_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`normalizedString`	`normalized_string_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`token`	`token_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`Name`	`name_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`NMTOKEN`	`nmtoken_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`NCName`	`ncname_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`language`	`language_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
qualified name
`QName`	`qname_simpl`	`const xml_schema::qname&` or + `const xml_schema::qname*` + Section 7.3, "`QName` Serializer"
ID/IDREF types
`ID`	`id_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
`IDREF`	`idref_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
list types
`NMTOKENS`	`nmtokens_simpl`	`const xml_schema::string_sequence*` Section + 7.4, "`NMTOKENS` and `IDREFS` Serializers"
`IDREFS`	`idrefs_simpl`	`const xml_schema::string_sequence*` Section + 7.4, "`NMTOKENS` and `IDREFS` Serializers"
URI types
`anyURI`	`uri_simpl`	`const std::string&` or `const char*` + Section 7.2, "String-Based Type Serializers"
binary types
`base64Binary`	`base64_binary_simpl`	`const xml_schema::buffer*` + Section 7.5, "`base64Binary` and + `hexBinary` Serializers"
`hexBinary`	`hex_binary_simpl`	`const xml_schema::buffer*` + Section 7.5, "`base64Binary` and + `hexBinary` Serializers"
date/time types
`date`	`date_simpl`	`const xml_schema::date&` + Section 7.7, "`date` Serializer"
`dateTime`	`date_time_simpl`	`const xml_schema::date_time&` + Section 7.8, "`dateTime` Serializer"
`duration`	`duration_simpl`	`const xml_schema::duration&` + Section 7.9, "`duration` Serializer"
`gDay`	`gday_simpl`	`const xml_schema::gday&` + Section 7.10, "`gDay` Serializer"
`gMonth`	`gmonth_simpl`	`const xml_schema::gmonth&` + Section 7.11, "`gMonth` Serializer"
`gMonthDay`	`gmonth_day_simpl`	`const xml_schema::gmonth_day&` + Section 7.12, "`gMonthDay` Serializer"
`gYear`	`gyear_simpl`	`const xml_schema::gyear&` + Section 7.13, "`gYear` Serializer"
`gYearMonth`	`gyear_month_simpl`	`const xml_schema::gyear_month&` + Section 7.14, "`gYearMonth` Serializer"
`time`	`time_simpl`	`const xml_schema::time&` + Section 7.15, "`time` Serializer"

Construct	Notes
Structure
element
attribute
any
anyAttribute
all
sequence
choice
complex type, empty content
complex type, mixed content
complex type, simple content extension
complex type, simple content restriction
complex type, complex content extension
complex type, complex content restriction
list
Facets
length	String-based types.
minLength	String-based types.
maxLength	String-based types.
pattern	String-based types.
whiteSpace	String-based types.
enumeration	String-based types.
minExclusive	Integer and floating-point types.
minInclusive	Integer and floating-point types.
maxExclusive	Integer and floating-point types.
maxInclusive	Integer and floating-point types.
Datatypes
byte
unsignedByte
short
unsignedShort
int
unsignedInt
long
unsignedLong
integer
nonPositiveInteger
nonNegativeInteger
positiveInteger
negativeInteger
boolean
float
double
decimal
string
normalizedString
token
Name
NMTOKEN
NCName
language
anyURI
ID	Identity constraint is not enforced.
IDREF	Identity constraint is not enforced.
NMTOKENS
IDREFS	Identity constraint is not enforced.
QName
base64Binary
hexBinary
date
dateTime
duration
gDay
gMonth
gMonthDay
gYear
gYearMonth
time

Embedded C++/Hybrid Mapping

Getting Started Guide

Table of Contents

Embedded C++/Parser Mapping

Getting Started Guide

Table of Contents

Embedded C++/Serializer Mapping

Getting Started Guide

Table of Contents