ChangeLogTag:Tue Sep 28 15:16:03 2004 Balachandran Natarajan <bala@dre.vanderbilt.edu>

7 files changed, 640 insertions, 209 deletions

diff --git a/TAO/CIAO/DAnCE/Config_Handlers/ChangeLog b/TAO/CIAO/DAnCE/Config_Handlers/ChangeLog
index df36467cff4..123917c0605 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/ChangeLog
+++ b/TAO/CIAO/DAnCE/Config_Handlers/ChangeLog
@@ -1,3 +1,22 @@
+Tue Sep 28 15:16:03 2004  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
+
+	* DAnCE/Config_Handlers/XSCRT/Elements.hpp:
+	* DAnCE/Config_Handlers/XSCRT/Elements.ipp:
+	* DAnCE/Config_Handlers/XSCRT/Elements.tpp:
+	* DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp:
+	* DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.ipp:
+	* DAnCE/Config_Handlers/XSCRT/Parser.hpp:
+	* DAnCE/Config_Handlers/XSCRT/Parser.ipp:
+	* DAnCE/Config_Handlers/XSCRT/Parser.tpp:
+	* DAnCE/Config_Handlers/XSCRT/Traversal.hpp:
+	* DAnCE/Config_Handlers/XSCRT/Traversal.ipp:
+	* DAnCE/Config_Handlers/XSCRT/Traversal.tpp:
+	* DAnCE/Config_Handlers/XSCRT/XMLSchema.hpp:
+	* DAnCE/Config_Handlers/XSCRT/XMLSchema.ipp:
+	* DAnCE/Config_Handlers/XSCRT/XMLSchema.tpp:
+
+	  Checked in XSCRT-0.0.5
+
 Tue Sep 28 14:43:48 2004  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
 
 	* DAnCE/Config_Handlers/Basic_Deployment_Data.cpp:
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Elements.hpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Elements.hpp
index ae73ae8a0b1..e8727e00afb 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Elements.hpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Elements.hpp
@@ -8,7 +8,7 @@
 #include <map>
 #include <string>
 #include <sstream>
-//#include <iostream> //@@ tmp
+// #include <iostream> //@@ tmp
 
 #include <XSCRT/Parser.hpp>
 
@@ -232,7 +232,7 @@ namespace XSCRT
         }
       }
 
-      throw 1;
+      return 0;
     }
 
 
@@ -309,138 +309,17 @@ namespace XSCRT
     X x_;
   };
 
-#if !defined (_MSC_VER) || (_MSC_VER >= 1300)
+#if (!defined (_MSC_VER) || (_MSC_VER >= 1300)) && \
+    (__GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ > 2)))
+
 
   // Stuff for normal compilers.
   //
 
   // Specialization for `signed char'
-    //
-  template <>
-  class FundamentalType<signed char> : public Type
-  {
-  public:
-    FundamentalType ()
-    {
-    }
-
-    template<typename C>
-    FundamentalType (XML::Element<C> const& e)
-    {
-      std::basic_stringstream<C> s;
-      s << e.value ();
-
-      short t;
-      s >> t;
-
-      x_ = static_cast<signed char> (t);
-    }
-
-    template<typename C>
-    FundamentalType (XML::Attribute<C> const& a)
-    {
-      std::basic_stringstream<C> s;
-      s << a.value ();
-
-      short t;
-      s >> t;
-
-      x_ = static_cast<signed char> (t);
-    }
-
-    FundamentalType (signed char const& x)
-        : x_ (x)
-    {
-    }
-
-    FundamentalType&
-    operator= (signed char const& x)
-    {
-      x_ = x;
-      return *this;
-    }
-
-  public:
-    operator signed char const& () const
-    {
-      return x_;
-    }
-
-    operator signed char& ()
-    {
-      return x_;
-    }
-
-  protected:
-    signed char x_;
-  };
-
-  // Specialization for unsigned char.
-  //
-  template <>
-  class FundamentalType<unsigned char> : public Type
-  {
-  public:
-    FundamentalType ()
-    {
-    }
-
-    template<typename C>
-    FundamentalType (XML::Element<C> const& e)
-    {
-      std::basic_stringstream<C> s;
-      s << e.value ();
-
-      unsigned short t;
-      s >> t;
-
-      x_ = static_cast<unsigned char> (t);
-    }
-
-    template<typename C>
-    FundamentalType (XML::Attribute<C> const& a)
-    {
-      std::basic_stringstream<C> s;
-      s << a.value ();
-
-      unsigned short t;
-      s >> t;
-
-      x_ = static_cast<unsigned char> (t);
-    }
-
-    FundamentalType (unsigned char const& x)
-        : x_ (x)
-    {
-    }
-
-    FundamentalType&
-    operator= (unsigned char const& x)
-    {
-      x_ = x;
-      return *this;
-    }
-
-  public:
-    operator unsigned char const& () const
-    {
-      return x_;
-    }
-
-    operator unsigned char& ()
-    {
-      return x_;
-    }
-
-  protected:
-    unsigned char x_;
-  };
-
   //
   //
-  // Commented out with Boris's advice since g++ 3.2.3 doesn't handle
-  // this.
-  /*  template<>
+  template<>
   template<typename C>
   inline
   FundamentalType<signed char>::
@@ -503,50 +382,10 @@ namespace XSCRT
     x_ = static_cast<unsigned char> (t);
   }
 
-  */
-
-  // Specialization for `bool'
-  //
-  //
-  template<>
-  template<>
-  inline
-  FundamentalType<bool>::
-  FundamentalType (XML::Element<char> const& e)
-  {
-    x_ = e.value () == "true";
-  }
-
-  template<>
-  template<>
-  inline
-  FundamentalType<bool>::
-  FundamentalType (XML::Element<wchar_t> const& e)
-  {
-    x_ = e.value () == L"true";
-  }
-
-  template<>
-  template<>
-  inline
-  FundamentalType<bool>::
-  FundamentalType (XML::Attribute<char> const& a)
-  {
-    x_ = a.value () == "true";
-  }
-
-  template<>
-  template<>
-  inline
-  FundamentalType<bool>::
-  FundamentalType (XML::Attribute<wchar_t> const& a)
-  {
-    x_ = a.value () == L"true";
-  }
-
 #else
 
-  // Stuff for broken VC6. Don't like what you see - use better compiler!
+  // Stuff for broken VC6 & gcc < 3.3. Don't like what you see - use better
+  // compiler!
   //
 
   // Specialization for signed char.
@@ -671,8 +510,53 @@ namespace XSCRT
     unsigned char x_;
   };
 
+#endif
+
+
   // Specialization for bool.
   //
+  //
+
+#if !defined (_MSC_VER) || (_MSC_VER >= 1300)
+
+  template<>
+  template<>
+  inline
+  FundamentalType<bool>::
+  FundamentalType (XML::Element<char> const& e)
+  {
+    x_ = (e.value () == "true") || (e.value () == "1");
+  }
+
+  template<>
+  template<>
+  inline
+  FundamentalType<bool>::
+  FundamentalType (XML::Element<wchar_t> const& e)
+  {
+    x_ = (e.value () == L"true") || (e.value () == L"1");
+  }
+
+  template<>
+  template<>
+  inline
+  FundamentalType<bool>::
+  FundamentalType (XML::Attribute<char> const& a)
+  {
+    x_ = (a.value () == "true") || (a.value () == "1");
+  }
+
+  template<>
+  template<>
+  inline
+  FundamentalType<bool>::
+  FundamentalType (XML::Attribute<wchar_t> const& a)
+  {
+    x_ = (a.value () == L"true") || (a.value () == L"1");
+  }
+
+#else
+
   template <>
   class FundamentalType<bool> : public Type
   {
@@ -684,13 +568,13 @@ namespace XSCRT
     template<typename C>
     FundamentalType (XML::Element<C> const& e)
     {
-      x_ = e.value ()[0] == 't';
+      x_ = (e.value ()[0] == 't') || (e.value ()[0] == '1');
     }
 
     template<typename C>
     FundamentalType (XML::Attribute<C> const& a)
     {
-      x_ = a.value ()[0] == 't';
+      x_ = (a.value ()[0] == 't') || (a.value ()[0] == '1');
     }
 
     FundamentalType (bool const& x)
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp
index 6a380e5d971..51f1930eea9 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/ExtendedTypeInfo.hpp
@@ -36,6 +36,13 @@ namespace XSCRT
     friend std::ostream&
     operator << (std::ostream& os, TypeId const& t);
     */
+    
+  public:
+    char const*
+    name () const
+    {
+      return tid_->name ();
+    }
 
   private:
     std::type_info const* tid_;
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Parser.hpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Parser.hpp
index 66d73e1f348..a5261f64ee3 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Parser.hpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Parser.hpp
@@ -5,12 +5,15 @@
 #ifndef XSCRT_PARSER_HPP
 #define XSCRT_PARSER_HPP
 
-#include <stack>
 #include <string>
 
 #include <xercesc/dom/DOM.hpp>
 #include <xercesc/util/XMLString.hpp>
 
+//@@ tmp
+#include <iostream>
+
+
 //@@ VC6
 #if defined (_MSC_VER) && (_MSC_VER < 1300)
 namespace std
@@ -101,6 +104,43 @@ namespace XSCRT
       return r;
     }
 
+    class XStr
+    {
+    public :
+      template <typename C>
+      XStr (std::basic_string<C> const& s)
+          : s_ (XSCRT::XML::transcode<C> (s))
+      {
+      }
+
+      template <typename C>
+      XStr (C const* s)
+          : s_ (XSCRT::XML::transcode<C> (s))
+      {
+      }
+
+      ~XStr ()
+      {
+        delete[] s_;
+      }
+
+      XMLCh const*
+      c_str () const
+      {
+        return s_;
+      }
+
+    private :
+      XMLCh* s_;
+    };
+
+    template <typename C>
+    class Element;
+
+    template <typename C>
+    std::basic_string<C>
+    ns_prefix (std::basic_string<C> const& ns, Element<C> const& e);
+
     template <typename C>
     class Element
     {
@@ -108,12 +148,59 @@ namespace XSCRT
 
     public:
       Element (xercesc::DOMElement const* e)
+          : e_ (0),
+            ce_ (e),
+            name_ (transcode<C> (e->getLocalName (), 0)),
+            namespace__ (transcode<C> (e->getNamespaceURI (), 0))
+      {
+      }
+
+      Element (xercesc::DOMElement* e)
           : e_ (e),
+            ce_ (e),
             name_ (transcode<C> (e->getLocalName (), 0)),
             namespace__ (transcode<C> (e->getNamespaceURI (), 0))
       {
       }
 
+      Element (string_ const& name, Element& parent)
+          : e_ (0),
+            ce_ (0),
+            name_ (name)
+      {
+        xercesc::DOMDocument* doc (
+          parent.dom_element ()->getOwnerDocument ());
+
+        e_ = doc->createElement (XStr (name).c_str ());
+
+        parent.dom_element ()->appendChild (e_);
+
+        ce_ = e_;
+      }
+
+      Element (string_ const& name, string_ const& ns, Element& parent)
+          : e_ (0),
+            ce_ (0),
+            name_ (name),
+            namespace__ (ns)
+      {
+        string_ prefix (ns_prefix (ns, parent));
+
+        xercesc::DOMDocument* doc (
+          parent.dom_element ()->getOwnerDocument ());
+
+        e_ = doc->createElementNS (
+          XStr (ns).c_str (),
+          XStr (prefix.empty ()
+                ? name
+                : prefix + string_ (1, ':') + name).c_str ());
+
+        parent.dom_element ()->appendChild (e_);
+
+        ce_ = e_;
+      }
+
+    public:
       string_
       name () const
       {
@@ -130,7 +217,7 @@ namespace XSCRT
       Element<C>
       parent () const
       {
-        return dynamic_cast<xercesc::DOMElement const*>(e_->getParentNode ());
+        return dynamic_cast<xercesc::DOMElement const*>(ce_->getParentNode ());
       }
 
     public:
@@ -140,13 +227,23 @@ namespace XSCRT
         return XML::transcode<C> (dom_element ()->getTextContent (), 0);
       }
 
+      void
+      value (string_ const& v)
+      {
+        xercesc::DOMText* text (
+          dom_element ()->getOwnerDocument ()->createTextNode(
+            XStr (v).c_str ()));
+        
+        dom_element ()->appendChild (text);
+      }
+
     public:
       string_
       operator[] (string_ const& s) const
       {
         //@@ VC6
         XMLCh* name = transcode (s);
-        XMLCh const* value = e_->getAttribute (name);
+        XMLCh const* value = ce_->getAttribute (name);
         delete[] name;
 
         return transcode<C> (value, 0);
@@ -156,13 +253,18 @@ namespace XSCRT
       xercesc::DOMElement const*
       dom_element () const
       {
-        return e_;
+        return ce_;
       }
 
-    private:
+      xercesc::DOMElement*
+      dom_element ()
+      {
+        return e_;
+      }
 
     private:
-      xercesc::DOMElement const* e_;
+      xercesc::DOMElement* e_;
+      xercesc::DOMElement const* ce_;
 
       string_ name_;
       string_ namespace__;
@@ -176,12 +278,68 @@ namespace XSCRT
 
     public:
       Attribute (xercesc::DOMAttr const* a)
+          : a_ (0),
+            ca_ (a),
+            name_ (transcode<C> (a->getLocalName (), 0)),
+            value_ (transcode<C> (a->getValue (), 0))
+      {
+      }
+
+      Attribute (xercesc::DOMAttr* a)
           : a_ (a),
+            ca_ (a),
             name_ (transcode<C> (a->getLocalName (), 0)),
             value_ (transcode<C> (a->getValue (), 0))
       {
       }
 
+      Attribute (string_ const& name,
+                 string_ const& v,
+                 Element<C>& parent)
+          : a_ (0),
+            ca_ (0),
+            name_ (name),
+            value_ ()
+      {
+        xercesc::DOMDocument* doc (
+          parent.dom_element ()->getOwnerDocument ());
+
+        a_ = doc->createAttribute (XStr (name).c_str ());
+
+        value (v);
+
+        parent.dom_element ()->setAttributeNode (a_);
+
+        ca_ = a_;
+      }
+
+      Attribute (string_ const& name,
+                 string_ const& ns,
+                 string_ const& v,
+                 Element<C>& parent)
+          : a_ (0),
+            ca_ (0),
+            name_ (name),
+            value_ ()
+      {
+        string_ prefix (ns_prefix (ns, parent));
+
+        xercesc::DOMDocument* doc (
+          parent.dom_element ()->getOwnerDocument ());
+
+        a_ = doc->createAttributeNS (
+          XStr (ns).c_str (),
+          XStr (prefix.empty ()
+                ? name
+                : prefix + string_ (1, ':') + name).c_str ());
+
+        value (v);
+
+        parent.dom_element ()->setAttributeNodeNS (a_);
+
+        ca_ = a_;
+      }
+
       string_
       name () const
       {
@@ -194,17 +352,31 @@ namespace XSCRT
         return value_;
       }
 
+      void
+      value (string_ const& v)
+      {
+        value_ = v;
+        a_->setValue (XStr (v).c_str ());
+      }
+
     public:
       xercesc::DOMAttr const*
       dom_attribute () const
       {
+        return ca_;
+      }
+
+      xercesc::DOMAttr*
+      dom_attribute ()
+      {
         return a_;
       }
 
     private:
 
     private:
-      xercesc::DOMAttr const* a_;
+      xercesc::DOMAttr* a_;
+      xercesc::DOMAttr const* ca_;
 
       string_ name_;
       string_ value_;
@@ -247,7 +419,7 @@ namespace XSCRT
       XMLCh const* xns = e.dom_element ()->lookupNamespaceURI (p);
       std::basic_string<C> ns (
         xns ? transcode<C> (xns, 0) : std::basic_string<C> ());
-      
+
       delete[] p;
       return ns;
 
@@ -262,6 +434,34 @@ namespace XSCRT
 
       return ns.empty () ? un : (ns + C ('#') + un);
     }
+
+    class no_prefix {};
+
+    template <typename C>
+    std::basic_string<C>
+    ns_prefix (std::basic_string<C> const& ns, Element<C> const& e)
+    {
+      XStr xns (ns);
+
+      XMLCh const* p (
+        e.dom_element ()->lookupNamespacePrefix (xns.c_str (), false));
+
+      if (p == 0)
+      {
+        bool r (e.dom_element ()->isDefaultNamespace (xns.c_str ()));
+
+        if (r)
+        {
+          return std::basic_string<C> ();
+        }
+        else
+        {
+          throw no_prefix ();
+        }
+      }
+
+      return transcode<C> (p, 0);
+    }
   }
 
   template <typename C>
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.hpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.hpp
index c898caa7681..0177dc6c120 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.hpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.hpp
@@ -9,6 +9,10 @@
 #include <set>
 #include <vector>
 
+// #include <iostream>
+// using std::wcerr;
+// using std::endl;
+
 #include <XSCRT/ExtendedTypeInfo.hpp>
 
 namespace XSCRT
@@ -30,6 +34,9 @@ namespace XSCRT
       virtual void
       trampoline (B& n) = 0;
 
+      virtual void
+      trampoline (B const& n) = 0;
+
       /*@@ VC6
       template <typename X>
       friend class DispatcherBase;
@@ -50,9 +57,15 @@ namespace XSCRT
       virtual void
       dispatch (B& n);
 
+      virtual void
+      dispatch (B const& n);
+
       void
       map (TypeId id, TraverserBase<B>& t)
       {
+        //wcerr << "map for " << id.name () << " to " << &t
+	//      << " in " << &traversal_map_ << endl;
+
         //@@ VC6
         Traversers& traversers = traversal_map_[id];
         traversers.push_back (&t);
@@ -122,8 +135,13 @@ namespace XSCRT
     class Dispatcher : public virtual DispatcherBase<B>
     {
     public:
+      Dispatcher ()
+          : merge_ (true)
+      {
+      }
+
       void
-      traverser (Dispatcher& d)
+      traverser (DispatcherBase<B>& d)
       {
         for (typename DispatcherBase<B>::Iterator
                i (d.begin ()), end (d.end ());
@@ -138,24 +156,65 @@ namespace XSCRT
         }
       }
 
-    protected:
-      DispatcherBase<B>&
-      traverser ()
+    public:
+      virtual void
+      dispatch (B& n)
+      {
+        merge ();
+        dispatcher_.dispatch (n);
+      }
+
+      virtual void
+      dispatch (B const& n)
       {
-        return dispatcher_;
+        merge ();
+        dispatcher_.dispatch (n);
       }
 
-      template <typename I>
+      using DispatcherBase<B>::begin;
+      using DispatcherBase<B>::end;
+
+    private:
       void
-      iterate_and_dispatch (I begin, I end)
+      merge ()
       {
-        for (; begin != end; ++begin)
+        if (merge_)
         {
-          traverser ().dispatch (*begin);
+          for (typename DispatcherBase<B>::Iterator
+                 i (begin ()), e (end ()); i != e; ++i)
+          {
+            for (typename DispatcherBase<B>::Traversers::const_iterator
+                   t (i->second.begin ()), e (i->second.end ()); t != e; ++t)
+            {
+              dispatcher_.map (i->first, **t);
+            }
+          }
+
+          merge_ = false;
+        }
+      }
+
+    protected:
+      // DispatcherBase<B>&
+      // traverser ()
+      // {
+      //   return dispatcher_;
+      // }
+
+      template <typename X, typename A, typename I>
+      void
+      iterate_and_dispatch (I begin, I end, X& x, void (X::*next)(A&), A& a)
+      {
+        for (; begin != end;)
+        {
+          dispatch (*begin);
+
+          if (++begin != end) (x.*next) (a);
         }
       }
 
     private:
+      bool merge_;
       DispatcherBase<B> dispatcher_;
     };
 
@@ -177,17 +236,35 @@ namespace XSCRT
       }
 
       virtual void
-      traverse (Type&) = 0;
+      traverse (Type&)
+      {
+        abort ();
+      }
+
+      virtual void
+      traverse (Type const&)
+      {
+        abort ();
+      }
 
     protected:
       virtual void
       trampoline (B& n)
       {
-        //cerr << "trampoline for " << &n << " to type "
-        //     << typeid (Type).name () << endl;
+        //wcerr << "trampoline for " << &n << " to type "
+        //      << typeid (Type).name () << endl;
 
         traverse (dynamic_cast<Type&> (n));
       }
+
+      virtual void
+      trampoline (B const& n)
+      {
+        //wcerr << "trampoline for " << &n << " to type "
+        //      << typeid (Type).name () << endl;
+
+        traverse (dynamic_cast<Type const&> (n));
+      }
     };
   }
 }
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.tpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.tpp
index 019a2a6a78e..b798178621b 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.tpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/Traversal.tpp
@@ -26,6 +26,9 @@ namespace XSCRT
     {
     }
 
+    //@@ merge after dropping VC6
+    //
+    //
     template <typename B>
     void DispatcherBase<B>::
     dispatch (B& n)
@@ -39,9 +42,74 @@ namespace XSCRT
 
 
       //wcerr << "starting dispatch process for "
-      //      << n.type_info ().type_id () << " with "
+      //      << typeid (n).name () << " with "
+      //      << max << " levels" << endl;
+
+      for (unsigned long l = 0; l < max + 1; ++l)
+      {
+        TypeInfoSet dispatched;
+
+        for (typename LevelMap::const_iterator
+               i (levels.begin ()), e (levels.end ());
+             i != e; ++i)
+        {
+          if (i->second == l)
+          {
+            typename TraversalMap::const_iterator v (
+              traversal_map_.find (i->first.type_id ()));
+
+            if (v != traversal_map_.end ())
+            {
+              //wcerr << "dispatching traversers for "
+              //      << typeid (n).name () << " as "
+              //      << i->first.type_id ().name () << endl;
+
+              //@@ VC6
+              Traversers const& traversers  = v->second;
+              for (typename Traversers::const_iterator
+                     ti (traversers.begin ()), te (traversers.end ());
+                   ti != te; ++ti)
+              {
+                (*ti)->trampoline (n);
+              }
+
+              flatten_tree (i->first, dispatched);
+            }
+          }
+        }
+
+        // Remove traversed types from the level map.
+        //
+	//@@ VC6
+        {
+          for (typename TypeInfoSet::const_iterator i = dispatched.begin ();
+               i != dispatched.end ();
+               ++i)
+          {
+            levels.erase (*i);
+          }
+	}
+      }
+    }
+
+    template <typename B>
+    void DispatcherBase<B>::
+    dispatch (B const& n)
+    {
+      LevelMap levels;
+
+      //@@ VC6
+      ExtendedTypeInfo const& ti = extended_type_info (n);
+
+      unsigned long max = compute_levels (ti, 0, levels);
+
+
+      //wcerr << "starting dispatch process for "
+      //      << typeid (n).name () << " with "
       //      << max << " levels" << endl;
 
+      //wcerr << "using " << &traversal_map_ << " traversal map" << endl;
+
       for (unsigned long l = 0; l < max + 1; ++l)
       {
         TypeInfoSet dispatched;
@@ -58,8 +126,8 @@ namespace XSCRT
             if (v != traversal_map_.end ())
             {
               //wcerr << "dispatching traversers for "
-              //      << n.type_info ().type_id () << " as "
-              //      << i->first.type_id () << endl;
+              //      << typeid (n).name () << " as "
+              //      << i->first.type_id ().name () << endl;
 
               //@@ VC6
               Traversers const& traversers  = v->second;
diff --git a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/XMLSchema.hpp b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/XMLSchema.hpp
index 49e04e7ec00..d414ec0460e 100644
--- a/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/XMLSchema.hpp
+++ b/TAO/CIAO/DAnCE/Config_Handlers/XSCRT/XMLSchema.hpp
@@ -85,6 +85,11 @@ namespace XMLSchema
     {
     }
 
+    string (C const* x)
+        : Base__ (x)
+    {
+    }
+
     string&
     operator= (Base__ const& x)
     {
@@ -120,6 +125,11 @@ namespace XMLSchema
     {
     }
 
+    normalizedString (C const* x)
+        : string<C> (x)
+    {
+    }
+
     normalizedString&
     operator= (Base__ const& x)
     {
@@ -155,6 +165,11 @@ namespace XMLSchema
     {
     }
 
+    token (C const* x)
+        : normalizedString<C> (x)
+    {
+    }
+
     token&
     operator= (Base__ const& x)
     {
@@ -190,6 +205,11 @@ namespace XMLSchema
     {
     }
 
+    NMTOKEN (C const* x)
+        : token<C> (x)
+    {
+    }
+
     NMTOKEN&
     operator= (Base__ const& x)
     {
@@ -224,6 +244,11 @@ namespace XMLSchema
     {
     }
 
+    Name (C const* x)
+        : token<C> (x)
+    {
+    }
+
     Name&
     operator= (Base__ const& x)
     {
@@ -259,6 +284,11 @@ namespace XMLSchema
     {
     }
 
+    NCName (C const* x)
+        : Name<C> (x)
+    {
+    }
+
     NCName&
     operator= (Base__ const& x)
     {
@@ -329,6 +359,11 @@ namespace XMLSchema
     {
     }
 
+    ID (C const* x)
+        : NCName<C> (x), id_provider_ (*this)
+    {
+    }
+
     ID&
     operator= (Base__ const& x)
     {
@@ -364,7 +399,7 @@ namespace XMLSchema
       NCName<C>::container (c);
 
       register_id ();
-    }    
+    }
 
   private:
     using NCName<C>::empty;
@@ -400,8 +435,11 @@ namespace XMLSchema
 
   struct IDREF_Base : public XSCRT::Type
   {
-    virtual XSCRT::Type*
+    virtual XSCRT::Type const*
     get () const = 0;
+
+    virtual XSCRT::Type*
+    get () = 0;
   };
 
   template <typename C>
@@ -433,6 +471,11 @@ namespace XMLSchema
     {
     }
 
+    IDREF (C const* id)
+        : id_ (id), id_provider_ (id_)
+    {
+    }
+
     IDREF&
     operator= (IDREF const& x)
     {
@@ -448,19 +491,38 @@ namespace XMLSchema
     }
 
   public:
-    XSCRT::Type*
+    NCName<C>
+    id () const
+    {
+      return id_;
+    }
+
+  public:
+    XSCRT::Type const*
     operator-> () const
     {
       return get ();
     }
 
-    XSCRT::Type&
+    XSCRT::Type*
+    operator-> ()
+    {
+      return get ();
+    }
+
+    XSCRT::Type const&
     operator* () const
     {
       return *(get ());
     }
 
-    virtual XSCRT::Type*
+    XSCRT::Type&
+    operator* ()
+    {
+      return *(get ());
+    }
+
+    virtual XSCRT::Type const*
     get () const
     {
       if (!id_.empty () && container () != this)
@@ -473,13 +535,31 @@ namespace XMLSchema
       }
     }
 
+    virtual XSCRT::Type*
+    get ()
+    {
+      if (!id_.empty () && container () != this)
+      {
+        return root ()->lookup_id (id_provider_);
+      }
+      else
+      {
+        return 0;
+      }
+    }
+
     // conversion to bool
     //
-    typedef XSCRT::Type* (IDREF::*bool_convertable)() const;
+    typedef void (IDREF::*bool_convertable)();
 
     operator bool_convertable () const
     {
-      return get () ? &IDREF::operator-> : 0;
+      return get () ? &IDREF::true_ : 0;
+    }
+
+  private:
+    void true_ ()
+    {
     }
 
   private:
@@ -498,19 +578,28 @@ namespace XMLSchema
 {
   namespace Traversal
   {
-    template <typename T>
-    struct Traverser : XSCRT::Traversal::Traverser<T, XSCRT::Type>,
-                       XSCRT::Traversal::Traverser<IDREF_Base, XSCRT::Type>
+    // Automatic traversal of IDREFs.
+    //
+    struct IDREF :
+      XSCRT::Traversal::Traverser<XMLSchema::IDREF_Base, XSCRT::Type>
     {
-      typedef
-      T
-      Type;
-
       virtual void
       traverse (XMLSchema::IDREF_Base& r)
       {
         if (r.get ()) dispatch (*(r.get ()));
       }
+
+      virtual void
+      traverse (XMLSchema::IDREF_Base const& r)
+      {
+        if (r.get ()) dispatch (*(r.get ()));
+      }
+    };
+
+
+    template <typename T>
+    struct Traverser : XSCRT::Traversal::Traverser<T, XSCRT::Type>
+    {
     };
 
     typedef Traverser<byte> byte;
@@ -546,7 +635,6 @@ namespace XMLSchema
 // ExtendedTypeInfo for XML Schema types
 //
 //
-
 #include <XSCRT/ExtendedTypeInfo.hpp>
 
 namespace XMLSchema
@@ -558,6 +646,94 @@ namespace XMLSchema
   };
 }
 
+// Writer
+//
+//
+#if !defined (_MSC_VER) || (_MSC_VER >= 1300)
+
+#include <XSCRT/Writer.hpp>
+
+namespace XMLSchema
+{
+  namespace Writer
+  {
+    template <typename T, typename C>
+    struct FundamentalType : Traversal::Traverser<T>,
+                             virtual XSCRT::Writer<C>
+    {
+      FundamentalType (XSCRT::XML::Element<C>& e)
+          : XSCRT::Writer<C> (e)
+      {
+      }
+
+      using XSCRT::Writer<C>::top_;
+      using XSCRT::Writer<C>::attr_;
+
+      virtual void
+      traverse (T const& o)
+      {
+        using namespace XSCRT::XML;
+
+        std::basic_ostringstream<C> os;
+
+        os << o;
+
+        if (Attribute<C>* a = attr_ ())
+        {
+          a->value (os.str ());
+        }
+        else
+        {
+          top_().value (os.str ());
+        }
+      }
+
+    protected:
+      FundamentalType ()
+      {
+      }
+    };
+
+
+    template <typename C>
+    struct IDREF : Traversal::Traverser<XMLSchema::IDREF<C> >,
+                   virtual XSCRT::Writer<C>
+    {
+      IDREF (XSCRT::XML::Element<C>& e)
+          : XSCRT::Writer<C> (e)
+      {
+      }
+
+      using XSCRT::Writer<C>::top_;
+      using XSCRT::Writer<C>::attr_;
+
+      virtual void
+      traverse (
+        typename Traversal::Traverser<XMLSchema::IDREF<C> >::Type const& o)
+      {
+        using namespace XSCRT::XML;
+
+        if (Attribute<C>* a = attr_ ())
+        {
+          a->value (o.id ());
+        }
+        else
+        {
+          top_().value (o.id ());
+        }
+      }
+
+    protected:
+      IDREF ()
+      {
+      }
+    };
+  }
+}
+
+#endif
+
+
 #include <XSCRT/XMLSchema.ipp>
 #include <XSCRT/XMLSchema.tpp>