serialization nearly ready for containment

src/xml-cxx/xml.hxx

@@ -17,6 +17,34 @@
 #include <typeinfo>
 #include <stdexcept>
 
+#include <cassert>
+#include <iostream>
+#include <iomanip>
+class MethodTrace {
+  public:
+    MethodTrace(const void* addr, const std::string& name) throw():
+        _addr(addr), _name(name) {
+      std::clog<<std::hex<<std::setw(15)<<_addr<<": "
+               <<std::dec<<std::setw(2+_level)
+               <<std::setfill(' ')<<"\\ "<<_name<<std::endl;
+                ++_level;
+    }
+    ~MethodTrace() throw() {
+        --_level;
+        std::clog<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec
+                 <<std::setw(2+_level)<<std::setfill(' ')
+                 <<"/ "<<_name<<std::endl;
+    }
+  private:
+    const void* _addr;
+    const std::string _name;
+    static unsigned int _level;  
+};
+#define TRACE MethodTrace XXX_METHOD(this, __PRETTY_FUNCTION__)
+#define LOG(X) std::clog<<__PRETTY_FUNCTION__<<"\t**** "<<X<<std::endl
+
+
+
 /*! @mainpage
 
     @section maintitle C++ XML Class Library
@@ -646,6 +674,7 @@ namespace xml {
       Factory& operator=(const Node& t) throw();
       Factory& append(const Node& node) throw();
       const Node& operator*() const throw(factory_not_valid);
+      const Node*const operator->() const throw(factory_not_valid);
       operator bool() const throw();
       friend std::ostream& operator<<(std::ostream& os,
                                       const Factory& factory) throw();
@@ -764,9 +793,13 @@ namespace xml {
       Serialize() throw();
       Serialize(const std::string& className) throw();
       virtual ~Serialize();
-      void className(const std::string& name) throw();
+      Serialize& className(const std::string& name) throw();
+      Serialize& persist(Serialize& ser) throw();
       template<typename TYPE>
-          Serialize& persist(TYPE& member, const std::string& name) {
+          Serialize& persist(TYPE& member, const std::string& name) throw() {
+        assert(mapName<TYPE>().find(name)==mapName<TYPE>().end());
+        assert(mapMember<TYPE>().find(&member)==mapMember<TYPE>().end());
+        assert(_xmlNames.find(name)==_xmlNames.end());
         mapName<TYPE>()[name] = &member;
         mapMember<TYPE>()[&member] = name;
         _xmlNames[name] = &typeid(TYPE);

src/xml.cxx

@@ -10,31 +10,7 @@
 #include <sstream>
 #include <cstdlib>
 
-#include <cassert>
-#include <iomanip>
-class MethodTrace {
-  public:
-    MethodTrace(const void* addr, const std::string& name) throw():
-        _addr(addr), _name(name) {
-      std::clog<<std::hex<<std::setw(15)<<_addr<<": "
-               <<std::dec<<std::setw(2+_level)
-               <<std::setfill(' ')<<"\\ "<<_name<<std::endl;
-                ++_level;
-    }
-    ~MethodTrace() throw() {
-        --_level;
-        std::clog<<std::hex<<std::setw(15)<<_addr<<": "<<std::dec
-                 <<std::setw(2+_level)<<std::setfill(' ')
-                 <<"/ "<<_name<<std::endl;
-    }
-  private:
-    const void* _addr;
-    const std::string _name;
-    static unsigned int _level;  
-};
 unsigned int MethodTrace::_level(0);
-#define TRACE MethodTrace XXX_METHOD(this, __PRETTY_FUNCTION__)
-#define LOG(X) std::clog<<__PRETTY_FUNCTION__<<"\t**** "<<X<<std::endl
 
 namespace xml {
   
@@ -790,6 +766,11 @@ namespace xml {
   } catch (...) {
     throw factory_not_valid();
   }
+  const Node*const Factory::operator->() const throw(factory_not_valid) try {
+    return &_template[0];
+  } catch (...) {
+    throw factory_not_valid();
+  }
   Factory::operator bool() const throw() {
     return _template.children()>0;
   }
@@ -1009,14 +990,35 @@ namespace xml {
 
   //============================================================== Serialization
 
+  //----------------------------------------------------------------------------
+  template<> void Serialize::fromNode<Serialize>(Serialize* member,
+                                                 xml::Node& node) {
+    member->_xmlFactory = node[member->_xmlFactory->name()];
+  }
+  template<> void Serialize::toNode<Serialize>(Serialize* member,
+                                    xml::Node& node) const {
+    node[member->_xmlFactory->name()] = *member->_xmlFactory;
+  }
   //----------------------------------------------------------------------------
   Serialize::Serialize() throw() {}
   Serialize::Serialize(const std::string& className) throw():
       _xmlFactory(xml::Node(xml::String(className).limits(1,1))) {
   }
   Serialize::~Serialize() {};
-  void Serialize::className(const std::string& name) throw() {
+  Serialize& Serialize::className(const std::string& name) throw() {
     _xmlFactory=xml::Node(xml::String(name).limits(1,1));
+    return *this;
+  }
+  Serialize& Serialize::persist(Serialize& ser) throw() {
+    ser.initXmlMembers();
+    std::string name(ser._xmlFactory->name());
+    mapName<Serialize>()[name] = &ser;
+    mapMember<Serialize>()[&ser] = name;
+    _xmlNames[name] = &typeid(Serialize);
+    xml::Node schema(*_xmlFactory);
+    schema<<*ser._xmlFactory;
+    _xmlFactory = schema;
+    return *this;
   }
   std::ostream& Serialize::saveXml(std::ostream& os) const throw() {
     if (!_xmlFactory) const_cast<Serialize*>(this)->initXmlMembers();
@@ -1028,6 +1030,7 @@ namespace xml {
       if (*it->second==typeid(TYPE))                \
         toNode(mapName<TYPE>()[it->first], node);   \
       else
+      QWERTZ_CHECK_TYPE_ZTREWQ___XXX(Serialize)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(std::string)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(float)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(double)
@@ -1060,6 +1063,7 @@ namespace xml {
       if (*it->second==typeid(TYPE))                   \
           fromNode(mapName<TYPE>()[it->first], *node); \
       else
+      QWERTZ_CHECK_TYPE_ZTREWQ___XXX(Serialize)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(std::string)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(float)
       QWERTZ_CHECK_TYPE_ZTREWQ___XXX(double)
@@ -1082,5 +1086,5 @@ namespace xml {
     return is;
   }
   void Serialize::initXmlMembers() {}
-
+  
 }