From 2615896faa646e5830abf2c269150e1165c66515 Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Fri, 18 Dec 2020 18:48:46 +0300
Subject: Switch to build2

---
 libxsd/xsd/cxx/tree/parsing.txx | 918 ----------------------------------------
 1 file changed, 918 deletions(-)
 delete mode 100644 libxsd/xsd/cxx/tree/parsing.txx

(limited to 'libxsd/xsd/cxx/tree/parsing.txx')

diff --git a/libxsd/xsd/cxx/tree/parsing.txx b/libxsd/xsd/cxx/tree/parsing.txx
deleted file mode 100644
index 6dd2fc1..0000000
--- a/libxsd/xsd/cxx/tree/parsing.txx
+++ /dev/null
@@ -1,918 +0,0 @@
-// file      : xsd/cxx/tree/parsing.txx
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#include <string>
-
-#include <xsd/cxx/ro-string.hxx>         // trim
-
-#include <xsd/cxx/xml/string.hxx>        // xml::{string, transcode}
-#include <xsd/cxx/xml/elements.hxx>      // xml::{prefix, uq_name}
-#include <xsd/cxx/xml/bits/literals.hxx> // xml::bits::{xml_prefix,
-                                         //             xml_namespace}
-
-#include <xsd/cxx/tree/exceptions.hxx>   // no_prefix_mapping
-#include <xsd/cxx/tree/elements.hxx>
-#include <xsd/cxx/tree/types.hxx>
-#include <xsd/cxx/tree/list.hxx>
-#include <xsd/cxx/tree/text.hxx>         // text_content
-
-namespace xsd
-{
-  namespace cxx
-  {
-    namespace tree
-    {
-      // Note that most of the types implemented here (except string,
-      // (normalizedString, and base64Binary) cannot have whitespaces
-      // in the value. As result we don't need to waste time collapsing
-      // whitespaces. All we need to do is trim the string representation
-      // which can be done without copying.
-      //
-
-      // type
-      //
-      inline _type::
-      _type (const xercesc::DOMElement& e, flags f, container* c)
-          : container_ (c)
-      {
-        if (f & flags::extract_content)
-          content_.reset (new dom_content_type (e));
-
-        if (f & flags::keep_dom)
-          dom_info_ = dom_info_factory::create (e, *this, c == 0);
-      }
-
-      inline _type::
-      _type (const xercesc::DOMAttr& a, flags f, container* c)
-          : container_ (c)
-      {
-        // anyType cannot be an attribute type so no content extraction.
-
-        if (f & flags::keep_dom)
-          dom_info_ = dom_info_factory::create (a, *this);
-      }
-
-      template <typename C>
-      inline _type::
-      _type (const std::basic_string<C>&,
-             const xercesc::DOMElement*,
-             flags,
-             container* c)
-          : container_ (c) // List elements don't have associated DOM nodes.
-      {
-        // anyType cannot be a list element type so no content extraction.
-      }
-
-      // simple_type
-      //
-      template <typename C, typename B>
-      inline simple_type<C, B>::
-      simple_type (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, (f & ~flags::extract_content), c)
-      {
-        if (f & flags::extract_content)
-          this->content_.reset (
-            new text_content_type (tree::text_content<C> (e)));
-      }
-
-      template <typename C, typename B>
-      inline simple_type<C, B>::
-      simple_type (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, (f & ~flags::extract_content), c)
-      {
-        if (f & flags::extract_content)
-          this->content_.reset (new text_content_type (
-                            xml::transcode<C> (a.getValue ())));
-      }
-
-      template <typename C, typename B>
-      inline simple_type<C, B>::
-      simple_type (const std::basic_string<C>& s,
-                   const xercesc::DOMElement* e,
-                   flags f,
-                   container* c)
-          : B (s, e, (f & ~flags::extract_content), c)
-      {
-        if (f & flags::extract_content)
-          this->content_.reset (new text_content_type (s));
-      }
-
-      // fundamental_base
-      //
-      template <typename T, typename C, typename B, schema_type::value ST>
-      fundamental_base<T, C, B, ST>::
-      fundamental_base (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c),
-            facet_table_ (0),
-            x_ (traits<T, C, ST>::create (e, f, c))
-      {
-      }
-
-      template <typename T, typename C, typename B, schema_type::value ST>
-      fundamental_base<T, C, B, ST>::
-      fundamental_base (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c),
-            facet_table_ (0),
-            x_ (traits<T, C, ST>::create (a, f, c))
-      {
-      }
-
-      template <typename T, typename C, typename B, schema_type::value ST>
-      fundamental_base<T, C, B, ST>::
-      fundamental_base (const std::basic_string<C>& s,
-                        const xercesc::DOMElement* e,
-                        flags f,
-                        container* c)
-          : B (s, e, f, c),
-            facet_table_ (0),
-            x_ (traits<T, C, ST>::create (s, e, f, c))
-      {
-      }
-
-
-      // Parsing c-tors for list.
-      //
-
-      namespace bits
-      {
-        // Find first non-space character.
-        //
-        template <typename C>
-        typename std::basic_string<C>::size_type
-        find_ns (const C* s,
-                 typename std::basic_string<C>::size_type size,
-                 typename std::basic_string<C>::size_type pos)
-        {
-          while (pos < size &&
-                 (s[pos] == C (0x20) || // space
-                  s[pos] == C (0x0D) || // carriage return
-                  s[pos] == C (0x09) || // tab
-                  s[pos] == C (0x0A)))
-            ++pos;
-
-          return pos < size ? pos : std::basic_string<C>::npos;
-        }
-
-        // Find first space character.
-        //
-        template <typename C>
-        typename std::basic_string<C>::size_type
-        find_s (const C* s,
-                typename std::basic_string<C>::size_type size,
-                typename std::basic_string<C>::size_type pos)
-        {
-          while (pos < size &&
-                 s[pos] != C (0x20) && // space
-                 s[pos] != C (0x0D) && // carriage return
-                 s[pos] != C (0x09) && // tab
-                 s[pos] != C (0x0A))
-            ++pos;
-
-          return pos < size ? pos : std::basic_string<C>::npos;
-        }
-      }
-
-      // Individual items of the list have no DOM association. Therefore
-      // we clear keep_dom from flags.
-      //
-
-      template <typename T, typename C, schema_type::value ST>
-      list<T, C, ST, false>::
-      list (const xercesc::DOMElement& e, flags f, container* c)
-          : sequence<T> (c)
-      {
-        init (tree::text_content<C> (e), &e, f & ~flags::keep_dom);
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      list<T, C, ST, false>::
-      list (const xercesc::DOMAttr& a, flags f, container* c)
-          : sequence<T> (c)
-      {
-        init (xml::transcode<C> (a.getValue ()),
-              a.getOwnerElement (),
-              f & ~flags::keep_dom);
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      list<T, C, ST, false>::
-      list (const std::basic_string<C>& s,
-            const xercesc::DOMElement* e,
-            flags f,
-            container* c)
-          : sequence<T> (c)
-      {
-        init (s, e, f & ~flags::keep_dom);
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      void list<T, C, ST, false>::
-      init (const std::basic_string<C>& s,
-            const xercesc::DOMElement* parent,
-            flags f)
-      {
-        if (s.size () == 0)
-          return;
-
-        using std::basic_string;
-        typedef typename basic_string<C>::size_type size_type;
-
-        const C* data (s.c_str ());
-        size_type size (s.size ());
-
-        // Traverse the data while logically collapsing spaces.
-        //
-        for (size_type i (bits::find_ns<C> (data, size, 0));
-             i != basic_string<C>::npos;)
-        {
-          size_type j (bits::find_s (data, size, i));
-
-          if (j != basic_string<C>::npos)
-          {
-            this->push_back (
-              traits<T, C, ST>::create (
-                basic_string<C> (data + i, j - i),
-                parent,
-                f,
-                this->container_));
-
-            i = bits::find_ns (data, size, j);
-          }
-          else
-          {
-            // Last element.
-            //
-            this->push_back (
-              traits<T, C, ST>::create (
-                basic_string<C> (data + i, size - i),
-                parent,
-                f,
-                this->container_));
-
-            break;
-          }
-        }
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      list<T, C, ST, true>::
-      list (const xercesc::DOMElement& e, flags, container* c)
-          : sequence<T> (c)
-      {
-        init (tree::text_content<C> (e), &e);
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      inline list<T, C, ST, true>::
-      list (const xercesc::DOMAttr& a, flags, container* c)
-          : sequence<T> (c)
-      {
-        init (xml::transcode<C> (a.getValue ()), a.getOwnerElement ());
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      inline list<T, C, ST, true>::
-      list (const std::basic_string<C>& s,
-            const xercesc::DOMElement* parent,
-            flags,
-            container* c)
-          : sequence<T> (c)
-      {
-        init (s, parent);
-      }
-
-      template <typename T, typename C, schema_type::value ST>
-      inline void list<T, C, ST, true>::
-      init (const std::basic_string<C>& s, const xercesc::DOMElement* parent)
-      {
-        if (s.size () == 0)
-          return;
-
-        using std::basic_string;
-        typedef typename basic_string<C>::size_type size_type;
-
-        const C* data (s.c_str ());
-        size_type size (s.size ());
-
-        // Traverse the data while logically collapsing spaces.
-        //
-        for (size_type i (bits::find_ns<C> (data, size, 0));
-             i != basic_string<C>::npos;)
-        {
-          size_type j (bits::find_s (data, size, i));
-
-          if (j != basic_string<C>::npos)
-          {
-            this->push_back (
-              traits<T, C, ST>::create (
-                basic_string<C> (data + i, j - i), parent, 0, 0));
-
-            i = bits::find_ns (data, size, j);
-          }
-          else
-          {
-            // Last element.
-            //
-            this->push_back (
-              traits<T, C, ST>::create (
-                basic_string<C> (data + i, size - i), parent, 0, 0));
-
-            break;
-          }
-        }
-      }
-
-
-      // Parsing c-tors for built-in types.
-      //
-
-
-      // string
-      //
-      template <typename C, typename B>
-      string<C, B>::
-      string (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c),
-            base_type (tree::text_content<C> (e))
-      {
-      }
-
-      template <typename C, typename B>
-      string<C, B>::
-      string (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c),
-            base_type (xml::transcode<C> (a.getValue ()))
-      {
-      }
-
-      template <typename C, typename B>
-      string<C, B>::
-      string (const std::basic_string<C>& s,
-              const xercesc::DOMElement* e,
-              flags f,
-              container* c)
-          : B (s, e, f, c), base_type (s)
-      {
-      }
-
-
-      // normalized_string
-      //
-      template <typename C, typename B>
-      normalized_string<C, B>::
-      normalized_string (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-        normalize ();
-      }
-
-      template <typename C, typename B>
-      normalized_string<C, B>::
-      normalized_string (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-        normalize ();
-      }
-
-      template <typename C, typename B>
-      normalized_string<C, B>::
-      normalized_string (const std::basic_string<C>& s,
-                         const xercesc::DOMElement* e,
-                         flags f,
-                         container* c)
-          : base_type (s, e, f, c)
-      {
-        normalize ();
-      }
-
-      template <typename C, typename B>
-      void normalized_string<C, B>::
-      normalize ()
-      {
-        typedef typename std::basic_string<C>::size_type size_type;
-
-        size_type size (this->size ());
-
-        for (size_type i (0); i < size; ++i)
-        {
-          C& c ((*this)[i]);
-
-          if (c == C (0x0D) || // carriage return
-              c == C (0x09) || // tab
-              c == C (0x0A))
-            c = C (0x20);
-        }
-      }
-
-
-      // token
-      //
-      template <typename C, typename B>
-      token<C, B>::
-      token (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-        collapse ();
-      }
-
-      template <typename C, typename B>
-      token<C, B>::
-      token (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-        collapse ();
-      }
-
-      template <typename C, typename B>
-      token<C, B>::
-      token (const std::basic_string<C>& s,
-             const xercesc::DOMElement* e,
-             flags f,
-             container* c)
-          : base_type (s, e, f, c)
-      {
-        collapse ();
-      }
-
-      template <typename C, typename B>
-      void token<C, B>::
-      collapse ()
-      {
-        // We have all whitespace normilized by our base. We just
-        // need to collapse them.
-        //
-        typedef typename std::basic_string<C>::size_type size_type;
-
-        size_type size (this->size ()), j (0);
-        bool subs (false), trim (true);
-
-        for (size_type i (0); i < size; ++i)
-        {
-          C c ((*this)[i]);
-
-          if (c == C (0x20))
-          {
-            subs = true;
-          }
-          else
-          {
-            if (subs)
-            {
-              subs = false;
-
-              if (!trim)
-                (*this)[j++] = C (0x20);
-            }
-
-            if (trim)
-              trim = false;
-
-            (*this)[j++] = c;
-          }
-        }
-
-        this->resize (j);
-      }
-
-
-      // nmtoken
-      //
-      template <typename C, typename B>
-      nmtoken<C, B>::
-      nmtoken (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      nmtoken<C, B>::
-      nmtoken (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      nmtoken<C, B>::
-      nmtoken (const std::basic_string<C>& s,
-               const xercesc::DOMElement* e,
-               flags f,
-               container* c)
-          : base_type (s, e, f, c)
-      {
-      }
-
-
-      // nmtokens
-      //
-      template <typename C, typename B, typename nmtoken>
-      nmtokens<C, B, nmtoken>::
-      nmtokens (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c), base_type (e, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename nmtoken>
-      nmtokens<C, B, nmtoken>::
-      nmtokens (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c), base_type (a, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename nmtoken>
-      nmtokens<C, B, nmtoken>::
-      nmtokens (const std::basic_string<C>& s,
-                const xercesc::DOMElement* e,
-                flags f,
-                container* c)
-          : B (s, e, f, c), base_type (s, e, f, this)
-      {
-      }
-
-
-      // name
-      //
-      template <typename C, typename B>
-      name<C, B>::
-      name (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      name<C, B>::
-      name (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      name<C, B>::
-      name (const std::basic_string<C>& s,
-            const xercesc::DOMElement* e,
-            flags f,
-            container* c)
-          : base_type (s, e, f, c)
-      {
-      }
-
-
-      // ncname
-      //
-      template <typename C, typename B>
-      ncname<C, B>::
-      ncname (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      ncname<C, B>::
-      ncname (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      ncname<C, B>::
-      ncname (const std::basic_string<C>& s,
-              const xercesc::DOMElement* e,
-              flags f,
-              container* c)
-          : base_type (s, e, f, c)
-      {
-      }
-
-
-      // language
-      //
-      template <typename C, typename B>
-      language<C, B>::
-      language (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      language<C, B>::
-      language (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      language<C, B>::
-      language (const std::basic_string<C>& s,
-                const xercesc::DOMElement* e,
-                flags f,
-                container* c)
-          : base_type (s, e, f, c)
-      {
-      }
-
-
-      // id
-      //
-      template <typename C, typename B>
-      id<C, B>::
-      id (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c), identity_ (*this)
-      {
-        register_id ();
-      }
-
-      template <typename C, typename B>
-      id<C, B>::
-      id (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c), identity_ (*this)
-      {
-        register_id ();
-      }
-
-      template <typename C, typename B>
-      id<C, B>::
-      id (const std::basic_string<C>& s,
-          const xercesc::DOMElement* e,
-          flags f,
-          container* c)
-          : base_type (s, e, f, c), identity_ (*this)
-      {
-        register_id ();
-      }
-
-
-      // idref
-      //
-      template <typename C, typename B, typename T>
-      idref<C, B, T>::
-      idref (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c), identity_ (*this)
-      {
-      }
-
-      template <typename C, typename B, typename T>
-      idref<C, B, T>::
-      idref (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f , c), identity_ (*this)
-      {
-      }
-
-      template <typename C, typename B, typename T>
-      idref<C, B, T>::
-      idref (const std::basic_string<C>& s,
-             const xercesc::DOMElement* e,
-             flags f,
-             container* c)
-          : base_type (s, e, f, c), identity_ (*this)
-      {
-      }
-
-
-      // idrefs
-      //
-      template <typename C, typename B, typename idref>
-      idrefs<C, B, idref>::
-      idrefs (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c), base_type (e, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename idref>
-      idrefs<C, B, idref>::
-      idrefs (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c), base_type (a, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename idref>
-      idrefs<C, B, idref>::
-      idrefs (const std::basic_string<C>& s,
-              const xercesc::DOMElement* e,
-              flags f,
-              container* c)
-          : B (s, e, f, c), base_type (s, e, f, this)
-      {
-      }
-
-
-      // uri
-      //
-      template <typename C, typename B>
-      uri<C, B>::
-      uri (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c),
-            base_type (trim (tree::text_content<C> (e)))
-      {
-      }
-
-      template <typename C, typename B>
-      uri<C, B>::
-      uri (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c),
-            base_type (trim (xml::transcode<C> (a.getValue ())))
-      {
-      }
-
-      template <typename C, typename B>
-      uri<C, B>::
-      uri (const std::basic_string<C>& s,
-           const xercesc::DOMElement* e,
-           flags f,
-           container* c)
-          : B (s, e, f, c), base_type (trim (s))
-      {
-      }
-
-
-      // qname
-      //
-      template <typename C, typename B, typename uri, typename ncname>
-      qname<C, B, uri, ncname>::
-      qname (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c)
-      {
-        std::basic_string<C> v (trim (tree::text_content<C> (e)));
-        ns_ = resolve (v, &e);
-        name_ = xml::uq_name (v);
-      }
-
-      template <typename C, typename B, typename uri, typename ncname>
-      qname<C, B, uri, ncname>::
-      qname (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c)
-      {
-        std::basic_string<C> v (trim (xml::transcode<C> (a.getValue ())));
-        ns_ = resolve (v, a.getOwnerElement ());
-        name_ = xml::uq_name (v);
-      }
-
-      template <typename C, typename B, typename uri, typename ncname>
-      qname<C, B, uri, ncname>::
-      qname (const std::basic_string<C>& s,
-             const xercesc::DOMElement* e,
-             flags f,
-             container* c)
-          : B (s, e, f, c)
-      {
-        std::basic_string<C> v (trim (s));
-        ns_ = resolve (v, e);
-        name_ = xml::uq_name (v);
-      }
-
-      template <typename C, typename B, typename uri, typename ncname>
-      uri qname<C, B, uri, ncname>::
-      resolve (const std::basic_string<C>& s, const xercesc::DOMElement* e)
-      {
-        std::basic_string<C> p (xml::prefix (s));
-
-        if (e)
-        {
-          // This code is copied verbatim from xml/dom/elements.hxx.
-          //
-
-          // 'xml' prefix requires special handling and Xerces folks refuse
-          // to handle this in DOM so I have to do it myself.
-          //
-          if (p == xml::bits::xml_prefix<C> ())
-            return xml::bits::xml_namespace<C> ();
-
-          const XMLCh* xns (
-            e->lookupNamespaceURI (
-              p.empty () ? 0 : xml::string (p).c_str ()));
-
-          if (xns != 0)
-            return xml::transcode<C> (xns);
-          else if (p.empty ())
-            return std::basic_string<C> ();
-        }
-
-        throw no_prefix_mapping<C> (p);
-      }
-
-
-      // base64_binary
-      //
-      // We are not doing whitespace collapsing since the decode
-      // functions can handle it like this.
-      //
-      template <typename C, typename B>
-      base64_binary<C, B>::
-      base64_binary (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c)
-      {
-        // This implementation is not optimal.
-        //
-        std::basic_string<C> str (trim (tree::text_content<C> (e)));
-        decode (xml::string (str).c_str ());
-      }
-
-      template <typename C, typename B>
-      base64_binary<C, B>::
-      base64_binary (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c)
-      {
-        std::basic_string<C> str (trim (xml::transcode<C> (a.getValue ())));
-        decode (xml::string (str).c_str ());
-      }
-
-      template <typename C, typename B>
-      base64_binary<C, B>::
-      base64_binary (const std::basic_string<C>& s,
-                     const xercesc::DOMElement* e,
-                     flags f,
-                     container* c)
-          : B (s, e, f, c)
-      {
-        std::basic_string<C> str (trim (s));
-        decode (xml::string (str).c_str ());
-      }
-
-
-      // hex_binary
-      //
-      template <typename C, typename B>
-      hex_binary<C, B>::
-      hex_binary (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c)
-      {
-        // This implementation is not optimal.
-        //
-        std::basic_string<C> str (trim (tree::text_content<C> (e)));
-        decode (xml::string (str).c_str ());
-      }
-
-      template <typename C, typename B>
-      hex_binary<C, B>::
-      hex_binary (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c)
-      {
-        std::basic_string<C> str (trim (xml::transcode<C> (a.getValue ())));
-        decode (xml::string (str).c_str ());
-      }
-
-      template <typename C, typename B>
-      hex_binary<C, B>::
-      hex_binary (const std::basic_string<C>& s,
-                  const xercesc::DOMElement* e,
-                  flags f,
-                  container* c)
-          : B (s, e, f, c)
-      {
-        std::basic_string<C> str (trim (s));
-        decode (xml::string (str).c_str ());
-      }
-
-      // entity
-      //
-      template <typename C, typename B>
-      entity<C, B>::
-      entity (const xercesc::DOMElement& e, flags f, container* c)
-          : base_type (e, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      entity<C, B>::
-      entity (const xercesc::DOMAttr& a, flags f, container* c)
-          : base_type (a, f, c)
-      {
-      }
-
-      template <typename C, typename B>
-      entity<C, B>::
-      entity (const std::basic_string<C>& s,
-              const xercesc::DOMElement* e,
-              flags f,
-              container* c)
-          : base_type (s, e, f, c)
-      {
-      }
-
-
-      // entities
-      //
-      template <typename C, typename B, typename entity>
-      entities<C, B, entity>::
-      entities (const xercesc::DOMElement& e, flags f, container* c)
-          : B (e, f, c), base_type (e, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename entity>
-      entities<C, B, entity>::
-      entities (const xercesc::DOMAttr& a, flags f, container* c)
-          : B (a, f, c), base_type (a, f, this)
-      {
-      }
-
-      template <typename C, typename B, typename entity>
-      entities<C, B, entity>::
-      entities (const std::basic_string<C>& s,
-                const xercesc::DOMElement* e,
-                flags f,
-                container* c)
-          : B (s, e, f, c), base_type (s, e, f, this)
-      {
-      }
-    }
-  }
-}
-- 
cgit v1.1