elements.hxx

Go to the documentation of this file.

// file      : xsd/cxx/tree/elements.hxx
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
#ifndef XSD_CXX_TREE_ELEMENTS_HXX
#define XSD_CXX_TREE_ELEMENTS_HXX
 
#include <xsd/cxx/config.hxx> // XSD_AUTO_PTR, XSD_CXX11
 
#include <map>
#include <string>
#include <memory>  // std::auto_ptr/unique_ptr
#include <cstddef> // std::size_t
#include <istream>
#include <sstream>
#include <cassert>
 
#ifdef XSD_CXX11
#  include <utility> // std::move
#endif
 
#include <xercesc/dom/DOMNode.hpp>
#include <xercesc/dom/DOMAttr.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMNamedNodeMap.hpp>
 
#include <xercesc/util/XercesVersion.hpp>
 
#include <xsd/cxx/xml/elements.hxx> // xml::properties
#include <xsd/cxx/xml/dom/auto-ptr.hxx> // dom::auto_ptr/unique_ptr
#include <xsd/cxx/xml/dom/wildcard-source.hxx> // dom::create_document()
 
#include <xsd/cxx/tree/facet.hxx>
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/istream-fwd.hxx>
#include <xsd/cxx/tree/containers-wildcard.hxx>
 
#if _XERCES_VERSION < 30000
#  error Xerces-C++ 2-series is not supported
#endif
 
namespace xsd
{
  namespace cxx
  {
    namespace tree
    {
      class flags
      {
      public:
 
        static const unsigned long keep_dom = 0x00000100UL;
 
        static const unsigned long own_dom = 0x00000200UL;
 
        static const unsigned long dont_validate = 0x00000400UL;
 
        static const unsigned long extract_content = 0x00000800UL;
 
        static const unsigned long dont_initialize = 0x00000001UL;
 
        static const unsigned long no_xml_declaration = 0x00010000UL;
 
        static const unsigned long dont_pretty_print = 0x00020000UL;
 
        //@cond
 
        // The following flags are for internal use.
        //
        static const unsigned long base = 0x01000000UL;
 
        //@endcond
 
        // Notes on flag blocks:
        //
        // 0x000000FF - common (applicable to both parsing and serialization)
        // 0x0000FF00 - parsing (values aligned with XML parsing)
        // 0x00FF0000 - serialization (values aligned with XML serialization)
        // 0xFF000000 - internal
 
 
      public:
        flags (unsigned long x = 0)
            : x_ (x)
        {
        }
 
        operator unsigned long () const
        {
          return x_;
        }
 
        friend flags
        operator| (const flags& a, const flags& b)
        {
          return flags (a.x_ | b.x_);
        }
 
        friend flags
        operator| (const flags& a, unsigned long b)
        {
          return flags (a.x_ | b);
        }
 
        friend flags
        operator| (unsigned long a, const flags& b)
        {
          return flags (a | b.x_);
        }
 
      private:
        unsigned long x_;
      };
 
      // Parsing properties. Refer to xsd/cxx/xml/elements.hxx for XML-
      // related properties.
      //
      template <typename C>
      class properties: public xml::properties<C>
      {
      };
 
      struct content_order
      {
        content_order (std::size_t id, std::size_t index = 0)
            : id (id), index (index)
        {
        }
 
        std::size_t id;
 
        std::size_t index;
      };
 
      //@cond
 
      bool
      operator== (const content_order&, const content_order&);
 
      bool
      operator!= (const content_order&, const content_order&);
 
      bool
      operator< (const content_order&, const content_order&);
 
      // DOM user data keys.
      //
      template <int dummy>
      struct user_data_keys_template
      {
        // Back pointers to tree nodes.
        //
        static const XMLCh node[21];
      };
 
      typedef user_data_keys_template<0> user_data_keys;
 
      //
      //
      struct identity
      {
        virtual
        ~identity ()
        {
        }
 
        identity ()
        {
        }
 
        virtual bool
        before (const identity&) const = 0;
 
        virtual void
        throw_duplicate_id () const = 0;
 
      private:
        identity (const identity&);
 
        identity&
        operator= (const identity&);
      };
 
      //@endcond
 
 
      // anyType. VC++ has a name injection bug that makes it impossible
      // to have a member with the same name as a base type. To address
      // that we will have to choose some unique name for the definition
      // and typedef it to 'type'.
      //
      class _type;
 
      typedef _type type;
 
      typedef _type container;
 
      class _type
      {
      public:
        virtual
        ~_type ()
        {
          // Everything should have been unregistered by now.
          //
          assert (map_.get () == 0 || map_->size () == 0);
        }
 
      public:
 
        _type ();
 
        template <typename C>
        explicit
        _type (const C* s);
 
      public:
        _type (const type& x, flags f = 0, container* c = 0);
 
        virtual type*
        _clone (flags f = 0, container* c = 0) const
        {
          return new type (*this, f, c);
        }
 
      public:
        template <typename S>
        _type (istream<S>& s, flags f = 0, container* c = 0);
 
        _type (const xercesc::DOMElement& e,
               flags f = flags::extract_content,
               container* c = 0);
 
        _type (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        template <typename C>
        _type (const std::basic_string<C>& s,
               const xercesc::DOMElement* e,
               flags f = 0,
               container* c = 0);
 
      public:
        type&
        operator= (const type& x)
        {
          if (this != &x)
          {
            if (x.content_.get () == 0)
              content_.reset ();
            else
              content_ = x.content_->clone ();
 
            // Drop DOM association.
            //
            dom_info_.reset ();
          }
 
          return *this;
        }
 
        // anyType content API.
        //
      public:
        //@cond
        typedef element_optional dom_content_optional;
        //@endcond
 
        const dom_content_optional&
        dom_content () const;
 
        dom_content_optional&
        dom_content ();
 
        void
        dom_content (const xercesc::DOMElement& e);
 
        void
        dom_content (xercesc::DOMElement* e);
 
        void
        dom_content (const dom_content_optional& d);
 
        const xercesc::DOMDocument&
        dom_content_document () const;
 
        xercesc::DOMDocument&
        dom_content_document ();
 
        bool
        null_content () const;
 
        //
        //
      public:
        friend bool
        operator== (const type& x, const type& y)
        {
          return x.content_.get () != 0 &&
            x.content_->compare (y.content_.get ());
        }
 
        friend bool
        operator!= (const type& x, const type& y) {return !(x == y);}
 
        // Container API.
        //
      public:
        const container*
        _container () const
        {
          return container_;
        }
 
        container*
        _container ()
        {
          return container_;
        }
 
        virtual void
        _container (container* c)
        {
          container* dr (0);
 
          if (c != 0)
          {
            dr = c->_root ();
 
            if (dr == 0)
              dr = c;
          }
 
          XSD_AUTO_PTR<map>& m (dr ? dr->map_ : map_);
 
          if (container_ == 0)
          {
            if (c != 0 && map_.get () != 0)
            {
              // Transfer our IDs to the new root.
              //
              if (m.get () != 0)
              {
                m->insert (map_->begin (), map_->end ());
                map_.reset ();
              }
              else
              {
#ifdef XSD_CXX11
                m = std::move (map_);
#else
                m = map_;
#endif
              }
            }
          }
          else
          {
            container* sr (_root ());
 
            if (sr->map_.get () != 0)
            {
              // Transfer IDs that belong to this subtree.
              //
              for (map::iterator i (sr->map_->begin ()), e (sr->map_->end ());
                   i != e;)
              {
                type* x (i->second);
                for (; x != this && x != sr; x = x->_container ()) ;
 
                if (x != sr)
                {
                  // Part of our subtree.
                  //
                  if (m.get () == 0)
                    m.reset (new map);
 
                  m->insert (*i);
                  sr->map_->erase (i++);
                }
                else
                  ++i;
              }
            }
          }
 
          container_ = c;
        }
 
        const container*
        _root () const
        {
          const container* r (container_);
 
          for (const container* c (r); c != 0; c = c->container_)
            r = c;
 
          return r;
        }
 
        container*
        _root ()
        {
          container* r (container_);
 
          for (container* c (r); c != 0; c = c->container_)
            r = c;
 
          return r;
        }
 
        // DOM association.
        //
      public:
        const xercesc::DOMNode*
        _node () const
        {
          return dom_info_.get () ? dom_info_->node() : 0;
        }
 
        xercesc::DOMNode*
        _node ()
        {
          return dom_info_.get () ? dom_info_->node () : 0;
        }
 
        class bad_dom_node_type: public std::exception //@@ Inherit exception<C>.
        {
        public:
          virtual const char*
          what () const throw ()
          {
            return "DOM node is not an attribute node or element node";
          }
        };
 
        void
        _node (xercesc::DOMNode* n)
        {
          switch (n->getNodeType ())
          {
          case xercesc::DOMNode::ELEMENT_NODE:
            {
              if (container_ != 0)
              {
                assert (_root ()->_node () != 0);
                assert (_root ()->_node ()->getOwnerDocument () ==
                        n->getOwnerDocument ());
              }
 
              dom_info_ =
                dom_info_factory::create (
                  *static_cast<xercesc::DOMElement*> (n),
                  *this,
                  container_ == 0);
 
              break;
            }
          case xercesc::DOMNode::ATTRIBUTE_NODE:
            {
              assert (container_ != 0);
              assert (_root ()->_node () != 0);
              assert (_root ()->_node ()->getOwnerDocument () ==
                      n->getOwnerDocument ());
 
              dom_info_ =
                dom_info_factory::create (
                  *static_cast<xercesc::DOMAttr*> (n),
                  *this);
 
              break;
            }
          default:
            {
              throw bad_dom_node_type ();
            }
          }
        }
 
      public:
        //@cond
 
        void
        _register_id (const identity& i, type* t)
        {
          // We should be the root.
          //
          assert (container_ == 0);
 
          if (map_.get () == 0)
            map_.reset (new map);
 
          if (!map_->insert (
                std::pair<const identity*, type*> (&i, t)).second)
          {
            i.throw_duplicate_id ();
          }
        }
 
        //@@ Does not inherit from exception<C>.
        //
        struct not_registered: std::exception
        {
          virtual const char*
          what () const throw ()
          {
            return "attempt to unregister non-existent id";
          }
        };
 
        void
        _unregister_id (const identity& id)
        {
          // We should be the root.
          //
          assert (container_ == 0);
 
          if (map_.get () == 0 || map_->erase (&id) == 0)
            throw not_registered ();
        }
 
        type*
        _lookup_id (const identity& id) const
        {
          if (map_.get ())
          {
            map::const_iterator it (map_->find (&id));
 
            if (it != map_->end ())
              return it->second;
          }
 
          return 0;
        }
 
        //@endcond
 
      private:
        //@cond
 
        struct dom_info
        {
          virtual
          ~dom_info () {}
 
          dom_info () {}
 
          virtual XSD_AUTO_PTR<dom_info>
          clone (type& tree_node, container*) const = 0;
 
          virtual xercesc::DOMNode*
          node () = 0;
 
        private:
          dom_info (const dom_info&);
          dom_info& operator= (const dom_info&);
        };
 
        struct dom_element_info: public dom_info
        {
          dom_element_info (xercesc::DOMElement& e, type& n, bool root)
              : e_ (e)
          {
            e_.setUserData (user_data_keys::node, &n, 0);
 
            if (root)
            {
              // The caller should have associated a dom::auto/unique_ptr
              // object that owns this document with the document node
              // using the xml_schema::dom::tree_node_key key.
              //
              XSD_DOM_AUTO_PTR<xercesc::DOMDocument>* pd (
                reinterpret_cast<XSD_DOM_AUTO_PTR<xercesc::DOMDocument>*> (
                  e.getOwnerDocument ()->getUserData (user_data_keys::node)));
 
              assert (pd != 0);
              assert (pd->get () == e.getOwnerDocument ());
 
              // Transfer ownership.
#ifdef XSD_CXX11
              doc_ = std::move (*pd);
#else
              doc_ = *pd;
#endif
            }
          }
 
          virtual XSD_AUTO_PTR<dom_info>
          clone (type& tree_node, container* c) const
          {
            // Check if we are a document root.
            //
            if (c == 0)
            {
              // We preserver DOM associations only in complete
              // copies from root.
              //
              return XSD_AUTO_PTR<dom_info> (
                doc_.get () == 0
                ? 0
                : new dom_element_info (*doc_, tree_node));
            }
 
            // Check if our container does not have DOM association (e.g.,
            // because it wasn't a complete copy of the tree).
            //
            using xercesc::DOMNode;
 
            DOMNode* cn (c->_node ());
 
            if (cn == 0)
              return XSD_AUTO_PTR<dom_info> ();
 
            // Now we are going to find the corresponding element in
            // the new tree.
            //
            {
              using xercesc::DOMElement;
 
              DOMNode& pn (*e_.getParentNode ());
              assert (pn.getNodeType () == DOMNode::ELEMENT_NODE);
 
              DOMNode* sn (pn.getFirstChild ()); // Source.
              DOMNode* dn (cn->getFirstChild ()); // Destination.
 
              // We should have at least one child.
              //
              assert (sn != 0);
 
              // Move in parallel until we get to the needed node.
              //
              for (; sn != 0 && !e_.isSameNode (sn);)
              {
                sn = sn->getNextSibling ();
                dn = dn->getNextSibling ();
              }
 
              // e_ should be on the list.
              //
              assert (sn != 0);
 
              assert (dn->getNodeType () == DOMNode::ELEMENT_NODE);
 
              return XSD_AUTO_PTR<dom_info> (
                new dom_element_info (static_cast<DOMElement&> (*dn),
                                      tree_node,
                                      false));
            }
          }
 
          virtual xercesc::DOMNode*
          node ()
          {
            return &e_;
          }
 
        private:
          dom_element_info (const xercesc::DOMDocument& d, type& n)
              : doc_ (static_cast<xercesc::DOMDocument*> (
                        d.cloneNode (true))),
                e_ (*doc_->getDocumentElement ())
          {
            e_.setUserData (user_data_keys::node, &n, 0);
          }
 
        private:
          XSD_DOM_AUTO_PTR<xercesc::DOMDocument> doc_;
          xercesc::DOMElement& e_;
        };
 
 
        struct dom_attribute_info: public dom_info
        {
          dom_attribute_info (xercesc::DOMAttr& a, type& n)
              : a_ (a)
          {
            a_.setUserData (user_data_keys::node, &n, 0);
          }
 
          virtual XSD_AUTO_PTR<dom_info>
          clone (type& tree_node, container* c) const
          {
            // Check if we are a document root.
            //
            if (c == 0)
            {
              // We preserver DOM associations only in complete
              // copies from root.
              //
              return XSD_AUTO_PTR<dom_info> ();
            }
 
            // Check if our container does not have DOM association (e.g.,
            // because it wasn't a complete copy of the tree).
            //
            using xercesc::DOMNode;
 
            DOMNode* cn (c->_node ());
 
            if (cn == 0)
              return XSD_AUTO_PTR<dom_info> ();
 
            // We are going to find the corresponding attribute in
            // the new tree.
            //
            using xercesc::DOMAttr;
            using xercesc::DOMElement;
            using xercesc::DOMNamedNodeMap;
 
            DOMElement& p (*a_.getOwnerElement ());
            DOMNamedNodeMap& nl (*p.getAttributes ());
 
            XMLSize_t size (nl.getLength ()), i (0);
 
            // We should have at least one child.
            //
            assert (size != 0);
 
            for ( ;i < size && !a_.isSameNode (nl.item (i)); ++i)/*noop*/;
 
            // a_ should be in the list.
            //
            assert (i < size);
 
            DOMNode& n (*cn->getAttributes ()->item (i));
            assert (n.getNodeType () == DOMNode::ATTRIBUTE_NODE);
 
            return XSD_AUTO_PTR<dom_info> (
              new dom_attribute_info (static_cast<DOMAttr&> (n), tree_node));
          }
 
          virtual xercesc::DOMNode*
          node ()
          {
            return &a_;
          }
 
        private:
          xercesc::DOMAttr& a_;
        };
 
        // For Sun C++ 5.6.
        //
        struct dom_info_factory;
        friend struct _type::dom_info_factory;
 
        struct dom_info_factory
        {
          static XSD_AUTO_PTR<dom_info>
          create (const xercesc::DOMElement& e, type& n, bool root)
          {
            return XSD_AUTO_PTR<dom_info> (
              new dom_element_info (
                const_cast<xercesc::DOMElement&> (e), n, root));
          }
 
          static XSD_AUTO_PTR<dom_info>
          create (const xercesc::DOMAttr& a, type& n)
          {
            return XSD_AUTO_PTR<dom_info> (
              new dom_attribute_info (
                const_cast<xercesc::DOMAttr&> (a), n));
          }
        };
 
        //@endcond
 
        XSD_AUTO_PTR<dom_info> dom_info_;
 
 
        // ID/IDREF map.
        //
      private:
 
        //@cond
 
        struct identity_comparator
        {
          bool operator () (const identity* x, const identity* y) const
          {
            return x->before (*y);
          }
        };
 
        //@endcond
 
        typedef
        std::map<const identity*, type*, identity_comparator>
        map;
 
        XSD_AUTO_PTR<map> map_;
 
        // anyType and anySimpleType content.
        //
      protected:
 
        //@cond
 
        struct content_type
        {
          virtual
          ~content_type () {}
 
          content_type () {}
 
          virtual XSD_AUTO_PTR<content_type>
          clone () const = 0;
 
          virtual bool
          compare (const content_type*) const = 0;
 
        private:
          content_type (const content_type&);
          content_type& operator= (const content_type&);
        };
 
        struct dom_content_type: content_type
        {
          dom_content_type ()
              : doc (xml::dom::create_document<char> ()), dom (*doc) {}
 
          explicit
          dom_content_type (const xercesc::DOMElement& e)
              : doc (xml::dom::create_document<char> ()), dom (e, *doc) {}
 
          explicit
          dom_content_type (xercesc::DOMElement* e)
              : doc (xml::dom::create_document<char> ()), dom (e, *doc) {}
 
          explicit
          dom_content_type (const dom_content_optional& d)
              : doc (xml::dom::create_document<char> ()), dom (d, *doc) {}
 
          virtual XSD_AUTO_PTR<content_type>
          clone () const
          {
            return XSD_AUTO_PTR<content_type> (new dom_content_type (dom));
          }
 
          virtual bool
          compare (const content_type* c) const
          {
            if (const dom_content_type* dc =
                dynamic_cast<const dom_content_type*> (c))
              return dom == dc->dom;
 
            return false;
          }
 
        public:
          XSD_DOM_AUTO_PTR<xercesc::DOMDocument> doc;
          dom_content_optional dom;
        };
 
        mutable XSD_AUTO_PTR<content_type> content_;
 
        //@endcond
 
      private:
        container* container_;
      };
 
      template <typename C, typename B>
      class simple_type: public B
      {
      public:
 
        simple_type ();
 
        simple_type (const C* s);
 
        simple_type (const std::basic_string<C>& s);
 
      public:
        simple_type (const simple_type& x, flags f = 0, container* c = 0);
 
#ifdef XSD_CXX11
        simple_type&
        operator= (const simple_type&) = default;
#endif
 
        virtual simple_type*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        simple_type (istream<S>& s,
                     flags f = flags::extract_content,
                     container* c = 0);
 
        simple_type (const xercesc::DOMElement& e,
                     flags f = flags::extract_content,
                     container* c = 0);
 
        simple_type (const xercesc::DOMAttr& a,
                     flags f = flags::extract_content,
                     container* c = 0);
 
        simple_type (const std::basic_string<C>& s,
                     const xercesc::DOMElement* e,
                     flags f = flags::extract_content,
                     container* c = 0);
 
        // anySimpleType content API.
        //
      public:
        const std::basic_string<C>&
        text_content () const;
 
        std::basic_string<C>&
        text_content ();
 
        void
        text_content (const std::basic_string<C>& t);
 
      protected:
        //@cond
 
        typedef typename B::content_type content_type;
 
        struct text_content_type: content_type
        {
          text_content_type () {}
 
          explicit
          text_content_type (const std::basic_string<C>& t): text (t) {}
 
          explicit
          text_content_type (const C* t): text (t) {}
 
          virtual XSD_AUTO_PTR<content_type>
          clone () const
          {
            return XSD_AUTO_PTR<content_type> (new text_content_type (text));
          }
 
          virtual bool
          compare (const content_type* c) const
          {
            if (const text_content_type* tc =
                dynamic_cast<const text_content_type*> (c))
              return text == tc->text;
 
            return false;
          }
 
        public:
          // It would have been more elegant to store text content as DOMText.
          // However, that would require Xerces-C++ initialization. Also
          // having a separate DOMDocument for each text node seems like
          // an overkill.
          //
          std::basic_string<C> text;
        };
 
        //@endcond
      };
 
 
      template <typename C, typename T>
      class element_type
      {
      public:
        virtual
        ~element_type ()
        {
        }
 
        virtual element_type*
        _clone (flags f = 0) const = 0;
 
        virtual const std::basic_string<C>&
        _name () const = 0;
 
        virtual const std::basic_string<C>&
        _namespace () const = 0;
 
        virtual T*
        _value () = 0;
 
        virtual const T*
        _value () const = 0;
      };
 
 
      //@cond
 
      // Extra schema type id to disambiguate certain cases where
      // different XML Schema types (e.g., double and decimal) are
      // mapped to the same fundamental C++ type (e.g., double).
      //
      struct schema_type
      {
        enum value
        {
          other,
          double_,
          decimal
        };
      };
 
      //@endcond
 
 
      //@cond
      template <typename T,
                typename C,
                schema_type::value ST = schema_type::other>
      struct traits
      {
        typedef T type;
 
        static XSD_AUTO_PTR<T>
        create (const xercesc::DOMElement& e, flags f, container* c)
        {
          return XSD_AUTO_PTR<T> (new T (e, f, c));
        }
 
        static XSD_AUTO_PTR<T>
        create (const xercesc::DOMAttr& a, flags f, container* c)
        {
          return XSD_AUTO_PTR<T> (new T (a, f, c));
        }
 
        static XSD_AUTO_PTR<T>
        create (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f,
                container* c)
        {
          return XSD_AUTO_PTR<T> (new T (s, e, f, c));
        }
 
        // For now for istream we only go through traits for non-
        // fundamental types.
        //
        template <typename S>
        static XSD_AUTO_PTR<T>
        create (istream<S>& s, flags f, container* c)
        {
          return XSD_AUTO_PTR<T> (new T (s, f, c));
        }
      };
 
      template <typename B,
                typename C,
                schema_type::value ST>
      struct traits<simple_type<C, B>, C, ST>
      {
        typedef simple_type<C, B> type;
 
        static XSD_AUTO_PTR<type>
        create (const xercesc::DOMElement& e, flags f, container* c)
        {
          return XSD_AUTO_PTR<type> (
            new type (e, f | flags::extract_content, c));
        }
 
        static XSD_AUTO_PTR<type>
        create (const xercesc::DOMAttr& a, flags f, container* c)
        {
          return XSD_AUTO_PTR<type> (
            new type (a, f | flags::extract_content, c));
        }
 
        static XSD_AUTO_PTR<type>
        create (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f,
                container* c)
        {
          return XSD_AUTO_PTR<type> (
            new type (s, e, f | flags::extract_content, c));
        }
 
        template <typename S>
        static XSD_AUTO_PTR<type>
        create (istream<S>& s, flags f, container* c)
        {
          return XSD_AUTO_PTR<type> (
            new type (s, f | flags::extract_content, c));
        }
      };
      //@endcond
 
 
      template <typename T,
                typename C,
                typename B,
                schema_type::value ST = schema_type::other>
      class fundamental_base: public B
      {
      public:
 
        fundamental_base ()
            : facet_table_ (0), x_ ()
        {
        }
 
        fundamental_base (T x)
            : facet_table_ (0), x_ (x)
        {
        }
 
      public:
        fundamental_base (const fundamental_base& x,
                          flags f = 0,
                          container* c = 0)
            : B (x, f, c), facet_table_ (0), x_ (x.x_)
        {
        }
 
#ifdef XSD_CXX11
        fundamental_base&
        operator= (const fundamental_base&) = default;
#endif
 
        virtual fundamental_base*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        fundamental_base (istream<S>& s, flags f = 0, container* c = 0);
 
        fundamental_base (const xercesc::DOMElement& e,
                          flags f = 0,
                          container* c = 0);
 
        fundamental_base (const xercesc::DOMAttr& a,
                          flags f = 0,
                          container* c = 0);
 
        fundamental_base (const std::basic_string<C>& s,
                          const xercesc::DOMElement* e,
                          flags f = 0,
                          container* c = 0);
 
      public:
        fundamental_base&
        operator= (const T& x)
        {
          if (&x_ != &x)
            x_ = x;
 
          return *this;
        }
 
      public:
        operator const T& () const
        {
          return x_;
        }
 
        operator T& ()
        {
          return x_;
        }
 
        // The following extra conversion operators causes problems on
        // some compilers (notably VC 9.0) and are disabled by default.
        //
#ifdef XSD_TREE_EXTRA_FUND_CONV
        template <typename T2>
        operator T2 () const
        {
          return x_;
        }
 
        template <typename T2>
        operator T2 ()
        {
          return x_;
        }
#endif // XSD_TREE_EXTRA_FUND_CONV
 
      public:
        const facet*
        _facet_table () const
        {
          return facet_table_;
        }
 
      protected:
        void
        _facet_table (const facet* ft)
        {
          facet_table_ = ft;
        }
 
      private:
        const facet* facet_table_;
        T x_;
      };
 
      // While thse operators are not normally necessary, they
      // help resolve ambiguities between implicit conversion and
      // construction.
      //
 
      template <typename T, typename C, typename B, schema_type::value ST>
      inline bool
      operator== (const fundamental_base<T, C, B, ST>& x,
                  const fundamental_base<T, C, B, ST>& y)
      {
        T x_ (x);
        T y_ (y);
        return x_ == y_;
      }
 
      template <typename T, typename C, typename B, schema_type::value ST>
      inline bool
      operator!= (const fundamental_base<T, C, B, ST>& x,
                  const fundamental_base<T, C, B, ST>& y)
      {
        T x_ (x);
        T y_ (y);
        return x_ != y_;
      }
 
 
      //@cond
 
      // Comparator for enum tables.
      //
      template <typename C>
      struct enum_comparator
      {
        enum_comparator (const C* const* table)
            : table_ (table)
        {
        }
 
        bool
        operator() (std::size_t i, const std::basic_string<C>& s) const
        {
          return table_[i] < s;
        }
 
        bool
        operator() (const std::basic_string<C>& s, std::size_t i) const
        {
          return s < table_[i];
        }
 
        // This overload shouldn't be necessary according to the standard
        // and removing it doesn't appear to trip any old compilers that
        // we still support. But let's keeps preprocessed-out until we
        // go C++11-only.
        //
#if 0
        bool
        operator() (std::size_t i, std::size_t j) const
        {
          return std::basic_string<C> (table_[i]) < table_[j];
        }
#endif
 
      private:
        const C* const* table_;
      };
 
      //@endcond
    }
  }
}
 
#include <xsd/cxx/tree/elements.ixx>
#include <xsd/cxx/tree/elements.txx>
 
#endif  // XSD_CXX_TREE_ELEMENTS_HXX