types.hxx

Go to the documentation of this file.

// file      : xsd/cxx/tree/types.hxx
// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
 
#ifndef XSD_CXX_TREE_TYPES_HXX
#define XSD_CXX_TREE_TYPES_HXX
 
#include <string>
#include <cstddef> // std::size_t
 
#include <xercesc/dom/DOMAttr.hpp>
#include <xercesc/dom/DOMElement.hpp>
 
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/list.hxx>
#include <xsd/cxx/tree/buffer.hxx>
#include <xsd/cxx/tree/istream-fwd.hxx>
 
#include <xsd/cxx/tree/date-time.hxx>
 
namespace xsd
{
  namespace cxx
  {
    namespace tree
    {
      template <typename C, typename B>
      class string: public B, public std::basic_string<C>
      {
        typedef std::basic_string<C> base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        string ()
        {
        }
 
        string (const C* s)
            : base_type (s)
        {
        }
 
        string (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        string (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        string (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        string (const std::basic_string<C>& s,
                std::size_t pos,
                std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        string (const string& x, flags f = 0, container* c = 0)
            : B (x, f, c), base_type (x)
        {
        }
 
        virtual string*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        string (istream<S>& s, flags f = 0, container* c = 0);
 
        string (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        string (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        string (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f = 0,
                container* c = 0);
 
      public:
        string&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        string&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        string&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        string&
        operator= (const string& x)
        {
          base () = x;
          return *this;
        }
 
      public:
        const std::basic_string<C>&
        base_string () const
        {
          return *this;
        }
      };
 
      template <typename C, typename B>
      inline bool
      operator== (const string<C, B>& a, const string<C, B>& b)
      {
        return static_cast<const std::basic_string<C>&> (a) == b;
      }
 
      template <typename C, typename B>
      inline bool
      operator!= (const string<C, B>& a, const string<C, B>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B>
      class normalized_string: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        normalized_string ()
        {
        }
 
        normalized_string (const C* s)
            : base_type (s)
        {
        }
 
        normalized_string (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        normalized_string (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        normalized_string (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        normalized_string (const std::basic_string<C>& s,
                           std::size_t pos,
                           std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        normalized_string (const normalized_string& x,
                           flags f = 0,
                           container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual normalized_string*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        normalized_string (istream<S>& s, flags f = 0, container* c = 0);
 
        normalized_string (const xercesc::DOMElement& e,
                           flags f = 0,
                           container* c = 0);
 
        normalized_string (const xercesc::DOMAttr& a,
                           flags f = 0,
                           container* c = 0);
 
        normalized_string (const std::basic_string<C>& s,
                           const xercesc::DOMElement* e,
                           flags f = 0,
                           container* c = 0);
 
      public:
        normalized_string&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        normalized_string&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        normalized_string&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        normalized_string&
        operator= (const normalized_string& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        void
        normalize ();
 
        //@endcond
      };
 
 
      template <typename C, typename B>
      class token: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        token ()
        {
        }
 
        token (const C* s)
            : base_type (s)
        {
        }
 
        token (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        token (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        token (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        token (const std::basic_string<C>& s,
               std::size_t pos,
               std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        token (const token& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual token*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        token (istream<S>& s, flags f = 0, container* c = 0);
 
        token (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        token (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        token (const std::basic_string<C>& s,
               const xercesc::DOMElement* e,
               flags f = 0,
               container* c = 0);
 
      public:
        token&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        token&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        token&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        token&
        operator= (const token& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        void
        collapse ();
 
        //@endcond
      };
 
 
      template <typename C, typename B>
      class nmtoken: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        nmtoken (const C* s)
            : base_type (s)
        {
        }
 
        nmtoken (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        nmtoken (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        nmtoken (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        nmtoken (const std::basic_string<C>& s,
                 std::size_t pos,
                 std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        nmtoken (const nmtoken& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual nmtoken*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        nmtoken (istream<S>& s, flags f = 0, container* c = 0);
 
        nmtoken (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        nmtoken (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        nmtoken (const std::basic_string<C>& s,
                 const xercesc::DOMElement* e,
                 flags f = 0,
                 container* c = 0);
 
      public:
        nmtoken&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        nmtoken&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        nmtoken&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        nmtoken&
        operator= (const nmtoken& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        nmtoken ()
            : base_type ()
        {
        }
 
        //@endcond
      };
 
 
      template <typename C, typename B, typename nmtoken>
      class nmtokens: public B, public list<nmtoken, C>
      {
        typedef list<nmtoken, C> base_type;
 
      public:
 
        nmtokens ()
            : base_type (this)
        {
        }
 
        nmtokens (typename base_type::size_type n, const nmtoken& x)
            : base_type (n, x, this)
        {
        }
 
        template <typename I>
        nmtokens (const I& begin, const I& end)
            : base_type (begin, end, this)
        {
        }
 
      public:
        nmtokens (const nmtokens& x, flags f, container* c = 0)
            : B (x, f, c), base_type (x, f, this)
        {
        }
 
#ifdef XSD_CXX11
        nmtokens&
        operator= (const nmtokens&) = default;
#endif
 
        virtual nmtokens*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        nmtokens (istream<S>& s, flags f = 0, container* c = 0);
 
        nmtokens (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        nmtokens (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        nmtokens (const std::basic_string<C>& s,
                  const xercesc::DOMElement* e,
                  flags f = 0,
                  container* c = 0);
      };
 
      template <typename C, typename B, typename nmtoken>
      inline bool
      operator== (const nmtokens<C, B, nmtoken>& a,
                  const nmtokens<C, B, nmtoken>& b)
      {
        return static_cast<const list<nmtoken, C>&> (a) == b;
      }
 
      template <typename C, typename B, typename nmtoken>
      inline bool
      operator!= (const nmtokens<C, B, nmtoken>& a,
                  const nmtokens<C, B, nmtoken>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B>
      class name: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        name (const C* s)
            : base_type (s)
        {
        }
 
        name (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        name (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        name (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        name (const std::basic_string<C>& s,
              std::size_t pos,
              std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        name (const name& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual name*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        name (istream<S>& s, flags f = 0, container* c = 0);
 
        name (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        name (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        name (const std::basic_string<C>& s,
              const xercesc::DOMElement* e,
              flags f = 0,
              container* c = 0);
 
      public:
        name&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        name&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        name&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        name&
        operator= (const name& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        name ()
            : base_type ()
        {
        }
 
        //@endcond
      };
 
 
      // Forward declaration for Sun CC.
      //
      template <typename C, typename B, typename uri, typename ncname>
      class qname;
 
 
      template <typename C, typename B>
      class ncname: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        ncname (const C* s)
            : base_type (s)
        {
        }
 
        ncname (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        ncname (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        ncname (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        ncname (const std::basic_string<C>& s,
                std::size_t pos,
                std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        ncname (const ncname& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual ncname*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        ncname (istream<S>& s, flags f = 0, container* c = 0);
 
        ncname (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        ncname (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        ncname (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f = 0,
                container* c = 0);
 
      public:
        ncname&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        ncname&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        ncname&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        ncname&
        operator= (const ncname& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        ncname ()
            : base_type ()
        {
        }
 
        //@endcond
 
        template <typename, typename, typename, typename>
        friend class qname;
      };
 
 
      template <typename C, typename B>
      class language: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        language (const C* s)
            : base_type (s)
        {
        }
 
        language (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        language (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        language (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        language (const std::basic_string<C>& s,
                  std::size_t pos,
                  std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        language (const language& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual language*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        language (istream<S>& s, flags f = 0, container* c = 0);
 
        language (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        language (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        language (const std::basic_string<C>& s,
                  const xercesc::DOMElement* e,
                  flags f = 0,
                  container* c = 0);
 
      public:
        language&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        language&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        language&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        language&
        operator= (const language& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        language ()
            : base_type ()
        {
        }
 
        //@endcond
      };
 
 
      //@cond
 
      template <typename C, typename ncname>
      struct identity_impl: identity
      {
        identity_impl (const ncname& id)
            : id_ (id)
        {
        }
 
        virtual bool
        before (const identity& y) const;
 
        virtual void
        throw_duplicate_id () const;
 
      private:
        const ncname& id_;
      };
 
      //@endcond
 
 
      template <typename C, typename B>
      class id: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
        ~id()
        {
          unregister_id ();
        }
 
      public:
 
        id (const C* s)
            : base_type (s), identity_ (*this)
        {
          register_id ();
        }
 
        id (const C* s, std::size_t n)
            : base_type (s, n), identity_ (*this)
        {
          register_id ();
        }
 
        id (std::size_t n, C c)
            : base_type (n, c), identity_ (*this)
        {
          register_id ();
        }
 
        id (const std::basic_string<C>& s)
            : base_type (s), identity_ (*this)
        {
          register_id ();
        }
 
        id (const std::basic_string<C>& s,
            std::size_t pos,
            std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n), identity_ (*this)
        {
          register_id ();
        }
 
      public:
        id (const id& x, flags f = 0, container* c = 0)
            : base_type (x, f, c), identity_ (*this)
        {
          register_id ();
        }
 
        virtual id*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        id (istream<S>& s, flags f = 0, container* c = 0);
 
        id (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        id (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        id (const std::basic_string<C>& s,
            const xercesc::DOMElement* e,
            flags f = 0,
            container* c = 0);
 
      public:
        id&
        operator= (C c);
 
 
        id&
        operator= (const C* s);
 
        id&
        operator= (const std::basic_string<C>& s);
 
        id&
        operator= (const id& x);
 
      public:
        //@cond
 
        virtual void
        _container (container*);
 
        using B::_container;
 
        //@endcond
 
      protected:
        //@cond
 
        id ()
            : base_type (), identity_ (*this)
        {
          register_id ();
        }
 
        //@endcond
 
      private:
        void
        register_id ();
 
        void
        unregister_id ();
 
      private:
        identity_impl<C, B> identity_;
      };
 
 
      template <typename C, typename B, typename T>
      class idref: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
        typedef T ref_type;
 
      public:
 
        idref (const C* s)
            : base_type (s), identity_ (*this)
        {
        }
 
        idref (const C* s, std::size_t n)
            : base_type (s, n), identity_ (*this)
        {
        }
 
        idref (std::size_t n, C c)
            : base_type (n, c), identity_ (*this)
        {
        }
 
        idref (const std::basic_string<C>& s)
            : base_type (s), identity_ (*this)
        {
        }
 
        idref (const std::basic_string<C>& s,
               std::size_t pos,
               std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n), identity_ (*this)
        {
        }
 
      public:
        idref (const idref& x, flags f = 0, container* c = 0)
            : base_type (x, f, c), identity_ (*this)
        {
        }
 
        virtual idref*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        idref (istream<S>& s, flags f = 0, container* c = 0);
 
        idref (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        idref (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        idref (const std::basic_string<C>& s,
               const xercesc::DOMElement* e,
               flags f = 0,
               container* c = 0);
 
      public:
        idref&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        idref&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        idref&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        idref&
        operator= (const idref& x)
        {
          base () = x;
          return *this;
        }
 
      public:
        const ref_type*
        operator-> () const
        {
          return get ();
        }
 
        ref_type*
        operator-> ()
        {
          return get ();
        }
 
        const ref_type&
        operator* () const
        {
          return *(get ());
        }
 
        ref_type&
        operator* ()
        {
          return *(get ());
        }
 
        const ref_type*
        get () const
        {
          return dynamic_cast<const ref_type*> (get_ ());
        }
 
        ref_type*
        get ()
        {
          return dynamic_cast<ref_type*> (get_ ());
        }
 
        typedef void (idref::*bool_convertible)();
 
        operator bool_convertible () const
        {
          return get_ () ? &idref::true_ : 0;
        }
 
      protected:
        //@cond
 
        idref ()
            : base_type (), identity_ (*this)
        {
        }
 
        //@endcond
 
      private:
        const _type*
        get_ () const;
 
        _type*
        get_ ();
 
        void
        true_ ();
 
      private:
        identity_impl<C, B> identity_;
      };
 
 
      template <typename C, typename B, typename idref>
      class idrefs: public B, public list<idref, C>
      {
        typedef list<idref, C> base_type;
 
      public:
 
        idrefs ()
            : base_type (this)
        {
        }
 
        idrefs (typename base_type::size_type n, const idref& x)
            : base_type (n, x, this)
        {
        }
 
        template <typename I>
        idrefs (const I& begin, const I& end)
            : base_type (begin, end, this)
        {
        }
 
      public:
        idrefs (const idrefs& x, flags f = 0, container* c = 0)
            : B (x, f, c), base_type (x, f, this)
        {
        }
 
#ifdef XSD_CXX11
        idrefs&
        operator= (const idrefs&) = default;
#endif
 
        virtual idrefs*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        idrefs (istream<S>& s, flags f = 0, container* c = 0);
 
        idrefs (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        idrefs (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        idrefs (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f = 0,
                container* c = 0);
      };
 
      template <typename C, typename B, typename idref>
      inline bool
      operator== (const idrefs<C, B, idref>& a, const idrefs<C, B, idref>& b)
      {
        return static_cast<const list<idref, C>&> (a) == b;
      }
 
      template <typename C, typename B, typename idref>
      inline bool
      operator!= (const idrefs<C, B, idref>& a, const idrefs<C, B, idref>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B>
      class uri: public B, public std::basic_string<C>
      {
        typedef std::basic_string<C> base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        uri (const C* s)
            : base_type (s)
        {
        }
 
        uri (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        uri (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        uri (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        uri (const std::basic_string<C>& s,
             std::size_t pos,
             std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        uri (const uri& x, flags f = 0, container* c = 0)
            : B (x, f, c), base_type (x)
        {
        }
 
        virtual uri*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        uri (istream<S>& s, flags f = 0, container* c = 0);
 
        uri (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        uri (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        uri (const std::basic_string<C>& s,
             const xercesc::DOMElement* e,
             flags f = 0,
             container* c = 0);
 
      public:
        uri&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        uri&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        uri&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        uri&
        operator= (const uri& x)
        {
          base () = x;
          return *this;
        }
 
      public:
        const std::basic_string<C>&
        base_string () const
        {
          return *this;
        }
 
      protected:
        //@cond
 
        uri ()
            : base_type ()
        {
        }
 
        //@endcond
 
        template <typename, typename, typename, typename>
        friend class qname;
      };
 
      template <typename C, typename B>
      inline bool
      operator== (const uri<C, B>& a, const uri<C, B>& b)
      {
        return static_cast<const std::basic_string<C>&> (a) == b;
      }
 
      template <typename C, typename B>
      inline bool
      operator!= (const uri<C, B>& a, const uri<C, B>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B, typename uri, typename ncname>
      class qname: public B
      {
      public:
 
        qname (const ncname& n)
            : ns_ (), name_ (n)
        {
        }
 
        qname (const uri& ns, const ncname& n)
            : ns_ (ns), name_ (n)
        {
        }
 
      public:
        qname (const qname& x, flags f = 0, container* c = 0)
            : B (x, f, c),
              ns_ (x.ns_),
              name_ (x.name_)
        {
          // Note that ns_ and name_ have no DOM association.
          //
        }
 
#ifdef XSD_CXX11
        qname&
        operator= (const qname&) = default;
#endif
 
        virtual qname*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        qname (istream<S>& s, flags f = 0, container* c = 0);
 
        qname (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        qname (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        qname (const std::basic_string<C>& s,
               const xercesc::DOMElement* e,
               flags f = 0,
               container* c = 0);
 
      public:
        bool
        qualified () const
        {
          return !ns_.empty ();
        }
 
        const uri&
        namespace_ () const
        {
          return ns_;
        }
 
        const ncname&
        name () const
        {
          return name_;
        }
 
      protected:
        //@cond
 
        qname ()
            : ns_ (), name_ ()
        {
        }
 
        //@endcond
 
      private:
        static uri
        resolve (const std::basic_string<C>&, const xercesc::DOMElement*);
 
      private:
        uri ns_;
        ncname name_;
      };
 
      template <typename C, typename B, typename uri, typename ncname>
      inline bool
      operator== (const qname<C, B, uri, ncname>& a,
                  const qname<C, B, uri, ncname>& b)
      {
        return a.name () == b.name () && a.namespace_ () == b.namespace_ ();
      }
 
      template <typename C, typename B, typename uri, typename ncname>
      inline bool
      operator!= (const qname<C, B, uri, ncname>& a,
                  const qname<C, B, uri, ncname>& b)
      {
        return !(a == b);
      }
 
 
      template <typename C, typename B>
      class base64_binary: public B, public buffer<C>
      {
      public:
        //@cond
        typedef typename buffer<C>::size_t size_t;
        //@endcond
 
      public:
 
        explicit
        base64_binary (size_t size = 0);
 
        base64_binary (size_t size, size_t capacity);
 
        base64_binary (const void* data, size_t size);
 
        base64_binary (const void* data, size_t size, size_t capacity);
 
        base64_binary (void* data,
                       size_t size,
                       size_t capacity,
                       bool assume_ownership);
      public:
        base64_binary (const base64_binary& x,
                       flags f = 0,
                       container* c = 0)
            : B (x, f, c), buffer<C> (x)
        {
        }
 
        virtual base64_binary*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        base64_binary (istream<S>& s, flags f = 0, container* c = 0);
 
        base64_binary (const xercesc::DOMElement& e,
                       flags f = 0,
                       container* c = 0);
 
        base64_binary (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        base64_binary (const std::basic_string<C>& s,
                       const xercesc::DOMElement* e,
                       flags f = 0,
                       container* c = 0);
 
      public:
        base64_binary&
        operator= (const base64_binary& x)
        {
          buffer<C>& b (*this);
          b = x;
          return *this;
        }
 
      public:
        std::basic_string<C>
        encode () const;
 
      private:
        void
        decode (const XMLCh*);
      };
 
      template <typename C, typename B>
      inline bool
      operator== (const base64_binary<C, B>& a, const base64_binary<C, B>& b)
      {
        return static_cast<const buffer<C>&> (a) == b;
      }
 
      template <typename C, typename B>
      inline bool
      operator!= (const base64_binary<C, B>& a, const base64_binary<C, B>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B>
      class hex_binary: public B, public buffer<C>
      {
      public:
        //@cond
        typedef typename buffer<C>::size_t size_t;
        //@endcond
 
      public:
 
        explicit
        hex_binary (size_t size = 0);
 
        hex_binary (size_t size, size_t capacity);
 
        hex_binary (const void* data, size_t size);
 
        hex_binary (const void* data, size_t size, size_t capacity);
 
        hex_binary (void* data,
                    size_t size,
                    size_t capacity,
                    bool assume_ownership);
 
      public:
        hex_binary (const hex_binary& x, flags f = 0, container* c = 0)
            : B (x, f, c), buffer<C> (x)
        {
        }
 
        virtual hex_binary*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        hex_binary (istream<S>& s, flags f = 0, container* c = 0);
 
        hex_binary (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        hex_binary (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        hex_binary (const std::basic_string<C>& s,
                    const xercesc::DOMElement* e,
                    flags f = 0,
                    container* c = 0);
 
      public:
        hex_binary&
        operator= (const hex_binary& x)
        {
          buffer<C>& b (*this);
          b = x;
          return *this;
        }
 
      public:
        std::basic_string<C>
        encode () const;
 
      private:
        void
        decode (const XMLCh*);
      };
 
      template <typename C, typename B>
      inline bool
      operator== (const hex_binary<C, B>& a, const hex_binary<C, B>& b)
      {
        return static_cast<const buffer<C>&> (a) == b;
      }
 
      template <typename C, typename B>
      inline bool
      operator!= (const hex_binary<C, B>& a, const hex_binary<C, B>& b)
      {
        return !(a == b);
      }
 
      template <typename C, typename B>
      class entity: public B
      {
        typedef B base_type;
 
        base_type&
        base ()
        {
          return *this;
        }
 
      public:
 
        entity (const C* s)
            : base_type (s)
        {
        }
 
        entity (const C* s, std::size_t n)
            : base_type (s, n)
        {
        }
 
        entity (std::size_t n, C c)
            : base_type (n, c)
        {
        }
 
        entity (const std::basic_string<C>& s)
            : base_type (s)
        {
        }
 
        entity (const std::basic_string<C>& s,
                std::size_t pos,
                std::size_t n = std::basic_string<C>::npos)
            : base_type (s, pos, n)
        {
        }
 
      public:
        entity (const entity& x, flags f = 0, container* c = 0)
            : base_type (x, f, c)
        {
        }
 
        virtual entity*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        entity (istream<S>& s, flags f = 0, container* c = 0);
 
        entity (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        entity (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        entity (const std::basic_string<C>& s,
                const xercesc::DOMElement* e,
                flags f = 0,
                container* c = 0);
 
      public:
        entity&
        operator= (C c)
        {
          base () = c;
          return *this;
        }
 
        entity&
        operator= (const C* s)
        {
          base () = s;
          return *this;
        }
 
        entity&
        operator= (const std::basic_string<C>& s)
        {
          base () = s;
          return *this;
        }
 
        entity&
        operator= (const entity& x)
        {
          base () = x;
          return *this;
        }
 
      protected:
        //@cond
 
        entity ()
            : base_type ()
        {
        }
 
        //@endcond
      };
 
 
      template <typename C, typename B, typename entity>
      class entities: public B, public list<entity, C>
      {
        typedef list<entity, C> base_type;
 
      public:
 
        entities ()
            : base_type (this)
        {
        }
 
        entities (typename base_type::size_type n, const entity& x)
            : base_type (n, x, this)
        {
        }
 
        template <typename I>
        entities (const I& begin, const I& end)
            : base_type (begin, end, this)
        {
        }
 
      public:
        entities (const entities& x, flags f = 0, container* c = 0)
            : B (x, f, c), base_type (x, f, this)
        {
        }
 
#ifdef XSD_CXX11
        entities&
        operator= (const entities&) = default;
#endif
 
        virtual entities*
        _clone (flags f = 0, container* c = 0) const;
 
      public:
        template <typename S>
        entities (istream<S>& s, flags f = 0, container* c = 0);
 
        entities (const xercesc::DOMElement& e, flags f = 0, container* c = 0);
 
        entities (const xercesc::DOMAttr& a, flags f = 0, container* c = 0);
 
        entities (const std::basic_string<C>& s,
                  const xercesc::DOMElement* e,
                  flags f = 0,
                  container* c = 0);
      };
 
      template <typename C, typename B, typename entity>
      inline bool
      operator== (const entities<C, B, entity>& a,
                  const entities<C, B, entity>& b)
      {
        return static_cast<const list<entity, C>&> (a) == b;
      }
 
      template <typename C, typename B, typename entity>
      inline bool
      operator!= (const entities<C, B, entity>& a,
                  const entities<C, B, entity>& b)
      {
        return !(a == b);
      }
    }
  }
}
 
#include <xsd/cxx/tree/types.txx>
 
#endif  // XSD_CXX_TREE_TYPES_HXX