From 1a4099b78717b16f632b0e7e0980a27811221e52 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Thu, 3 Jul 2014 09:57:09 +0200
Subject: Implement anyType and anySimpleType content representation

anyType as a DOM fragment, similar to wildcards. anySimpleType as
a text string.
---
 libxsd/xsd/cxx/tree/elements.ixx | 213 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 207 insertions(+), 6 deletions(-)

(limited to 'libxsd/xsd/cxx/tree/elements.ixx')

diff --git a/libxsd/xsd/cxx/tree/elements.ixx b/libxsd/xsd/cxx/tree/elements.ixx
index da8a83e..844ccf7 100644
--- a/libxsd/xsd/cxx/tree/elements.ixx
+++ b/libxsd/xsd/cxx/tree/elements.ixx
@@ -45,20 +45,221 @@ namespace xsd
       {
       }
 
+      inline _type::
+      _type (const type& x, flags f, container* c)
+          : container_ (c)
+      {
+        if (x.content_.get () != 0)
+          content_ = x.content_->clone ();
+
+        if (x.dom_info_.get () != 0 && (f & flags::keep_dom))
+        {
+          dom_info_ = x.dom_info_->clone (*this, c);
+        }
+      }
+
+      inline const _type::dom_content_optional& _type::
+      dom_content () const
+      {
+        const content_type* c (content_.get ());
+
+        if (c == 0)
+        {
+          content_.reset (new dom_content_type);
+          c = content_.get ();
+        }
+
+        // Accessing non-DOM content via the DOM API.
+        //
+        assert (dynamic_cast<const dom_content_type*> (c) != 0);
+
+        return static_cast<const dom_content_type*> (c)->dom;
+      }
+
+      inline _type::dom_content_optional& _type::
+      dom_content ()
+      {
+        content_type* c (content_.get ());
+
+        if (c == 0)
+        {
+          content_.reset (new dom_content_type);
+          c = content_.get ();
+        }
+
+        // Accessing non-DOM content via the DOM API.
+        //
+        assert (dynamic_cast<dom_content_type*> (c) != 0);
+
+        return static_cast<dom_content_type*> (c)->dom;
+      }
+
+      inline void _type::
+      dom_content (const xercesc::DOMElement& e)
+      {
+        content_type* c (content_.get ());
+
+        if (c == 0)
+          content_.reset (new dom_content_type (e));
+        else
+        {
+          // Accessing non-DOM content via the DOM API.
+          //
+          assert (dynamic_cast<dom_content_type*> (c) != 0);
+          static_cast<dom_content_type*> (c)->dom.set (e);
+        }
+      }
+
+      inline void _type::
+      dom_content (xercesc::DOMElement* e)
+      {
+        content_type* c (content_.get ());
+
+        if (c == 0)
+          content_.reset (new dom_content_type (e));
+        else
+        {
+          // Accessing non-DOM content via the DOM API.
+          //
+          assert (dynamic_cast<dom_content_type*> (c) != 0);
+          static_cast<dom_content_type*> (c)->dom.set (e);
+        }
+      }
+
+      inline void _type::
+      dom_content (const dom_content_optional& d)
+      {
+        content_type* c (content_.get ());
+
+        if (c == 0)
+          content_.reset (new dom_content_type (d));
+        else
+        {
+          // Accessing non-DOM content via the DOM API.
+          //
+          assert (dynamic_cast<dom_content_type*> (c) != 0);
+          static_cast<dom_content_type*> (c)->dom = d;
+        }
+      }
+
+      inline const xercesc::DOMDocument& _type::
+      dom_content_document () const
+      {
+        const content_type* c (content_.get ());
+
+        if (c == 0)
+        {
+          content_.reset (new dom_content_type);
+          c = content_.get ();
+        }
+
+        // Accessing non-DOM content via the DOM API.
+        //
+        assert (dynamic_cast<const dom_content_type*> (c) != 0);
+
+        return *static_cast<const dom_content_type*> (c)->doc;
+      }
+
+      inline xercesc::DOMDocument& _type::
+      dom_content_document ()
+      {
+        content_type* c (content_.get ());
+
+        if (c == 0)
+        {
+          content_.reset (new dom_content_type);
+          c = content_.get ();
+        }
+
+        // Accessing non-DOM content via the DOM API.
+        //
+        assert (dynamic_cast<dom_content_type*> (c) != 0);
+
+        return *static_cast<dom_content_type*> (c)->doc;
+      }
+
+      inline bool _type::
+      null_content () const
+      {
+        return content_.get () == 0;
+      }
+
       // simple_type
       //
 
-      template <typename B>
-      inline simple_type<B>::
+      template <typename C, typename B>
+      inline simple_type<C, B>::
       simple_type ()
       {
       }
 
-      template <typename B>
-      template <typename C>
-      inline simple_type<B>::
-      simple_type (const C*)
+      template <typename C, typename B>
+      inline simple_type<C, B>::
+      simple_type (const C* s)
+      {
+        this->content_.reset (new text_content_type (s));
+      }
+
+      template <typename C, typename B>
+      inline simple_type<C, B>::
+      simple_type (const std::basic_string<C>& s)
       {
+        this->content_.reset (new text_content_type (s));
+      }
+
+      template <typename C, typename B>
+      inline const std::basic_string<C>& simple_type<C, B>::
+      text_content () const
+      {
+        const content_type* c (this->content_.get ());
+
+        if (c == 0)
+        {
+          this->content_.reset (new text_content_type);
+          c = this->content_.get ();
+        }
+
+        // Accessing non-text content via the text API.
+        //
+        assert (dynamic_cast<const text_content_type*> (c) != 0);
+
+        return static_cast<const text_content_type*> (c)->text;
+      }
+
+      template <typename C, typename B>
+      inline std::basic_string<C>& simple_type<C, B>::
+      text_content ()
+      {
+        content_type* c (this->content_.get ());
+
+        if (c == 0)
+        {
+          this->content_.reset (new text_content_type);
+          c = this->content_.get ();
+        }
+
+        // Accessing non-text content via the text API.
+        //
+        assert (dynamic_cast<text_content_type*> (c) != 0);
+
+        return static_cast<text_content_type*> (c)->text;
+      }
+
+      template <typename C, typename B>
+      inline void simple_type<C, B>::
+      text_content (const std::basic_string<C>& t)
+      {
+        content_type* c (this->content_.get ());
+
+        if (c == 0)
+          this->content_.reset (new text_content_type (t));
+        else
+        {
+          // Accessing non-text content via the text API.
+          //
+          assert (dynamic_cast<text_content_type*> (c) != 0);
+          static_cast<text_content_type*> (c)->text = t;
+        }
       }
     }
   }
-- 
cgit v1.1