Added tuple support to xml_pack/unpack.

Author: highperformancecoder

test/c++17/Makefile

@@ -3,7 +3,7 @@
 #define NOGUI if X-windows not installed
 NOGUI=
 
-EXES=testFunctional c++Features
+EXES=testFunctional c++Features testXSDGenerate
 OBJS=
 
 # note the internal type example cannot be correctly linked with g++ or icc!
@@ -90,11 +90,8 @@ else
 	if [ -f $@ ]; then touch $@; else echo "*** run make depend on a computer with gcc installed ***"; exit 1; fi
 endif
 
-depend: $(OBJS:.o=.d) $(EXES:=.d)
-	cat *.d >depend
-
 ifneq ($(MAKECMDGOALS),clean)
-include depend
+include $(OBJS:.o=.d) $(EXES:=.d)
 endif
 
 .cc.o:

test/c++17/c++Features.h

@@ -1,5 +1,6 @@
 #ifndef CPPFEATURES_H
 #define CPPFEATURES_H
+#include <tuple>
 
 struct CppFeatures
 {

test/c++17/runtests.sh

@@ -1,5 +1,11 @@
 #!/bin/bash
+set -e
 for i in $*; do
     echo $i;
     ./$i;
     done
+
+# XSD generation test
+xmllint --output /dev/null test1.xsd
+xmllint --output /dev/null --schema ../XMLSchema.xsd test1.xsd
+xmllint --output /dev/null --schema test1.xsd test1.xml

test/c++17/testXSDGenerate.cc

@@ -0,0 +1,34 @@
+#include "c++Features.h"
+#include "xml_pack_base.h"
+#include "xml_unpack_base.h"
+#include "xsd_generate_base.h"
+#include "classdesc_epilogue.h"
+#include <assert.h>
+using namespace std;
+using namespace classdesc;
+
+int main()
+{
+  xsd_generate_t g;
+  CppFeatures x;
+  x.tup={10,3}; // set to different from default
+  string rootTag="root";
+  xsd_generate(g, rootTag, x);
+
+  ofstream f("test1.xsd");
+
+  string schema="schema";
+  g.output(f,schema);
+  f.close();
+  f.open("test1.xml");
+  xml_pack_t xb(f,schema);
+  xb.prettyPrint=true;
+  xml_pack(xb,rootTag,x);
+
+  // check roundtrip serialisation
+  CppFeatures y;
+  xml_unpack_t ux("test1.xml");
+  ux>>y;
+  assert(x.tup==y.tup);
+}
+  

xml_pack_epilogue.h

@@ -27,6 +27,38 @@ namespace classdesc_access
     void operator()(classdesc::xml_pack_t& t,const classdesc::string& d, const T& a)
     {t.pack_notag(d,a);}
   };
+
+#if defined(__cplusplus) && __cplusplus>=201703L
+  
+  template <class... A>
+  struct access_xml_pack<std::tuple<A...>>
+  {
+    template <class T>
+    void xml_pack_tuple_element(classdesc::xml_pack_t& o, const cd::string& d, T& a)
+    {
+      if constexpr (std::tuple_size<T>::value>0)
+        {
+          // element name is given by the type name
+          std::string eName=classdesc::typeName<typename std::tuple_element<0,T>::type>();
+          eName=eName.substr(0,eName.find('<')); //trim off any template args
+          // strip leading namespace and qualifiers
+          const char *e=eName.c_str()+eName.length();
+          while (e!=eName.c_str() && *(e-1)!=' ' && *(e-1)!=':') e--;
+          ::xml_pack(o,e,std::get<0>(a));
+          auto tail=classdesc::tupleTail(a);
+          xml_pack_tuple_element(o,d,tail);
+        }
+    }
+
+    template <class U>
+    void operator()(classdesc::xml_pack_t& o, const cd::string& d, U& a)
+    {
+      classdesc::xml_pack_t::Tag tag(o,d); 
+      xml_pack_tuple_element(o, d, a);
+    }
+  };
+#endif
+  
 #endif
 
 #ifdef CLASSDESC_XML_UNPACK_BASE_H
@@ -45,6 +77,37 @@ namespace classdesc_access
       t.unpack(d,tmp);
     }
   };
+
+#if defined(__cplusplus) && __cplusplus>=201703L
+  template <class... A>
+  struct access_xml_unpack<std::tuple<A...>>
+  {
+    template <class T>
+    void xml_unpack_tuple_element(classdesc::xml_unpack_t& o, const cd::string& d, T& a, int i)
+    {
+      if constexpr (std::tuple_size<T>::value>0)
+        {
+          ::xml_unpack(o,classdesc::idx(d,i),std::get<0>(a));
+          auto tail=classdesc::tupleTail(a);
+          xml_unpack_tuple_element(o,d,tail,i+1);
+          a=std::tuple_cat(std::make_tuple(std::get<0>(a)), tail);
+        }
+    }
+    
+    template <class U>
+    void operator()(classdesc::xml_unpack_t& o, const cd::string& d, U& a)
+    {
+      // element name is given by the type name
+      std::string eName=classdesc::typeName<typename std::tuple_element<0,std::tuple<A...>>::type>();
+      eName=eName.substr(0,eName.find('<')); //trim off any template args
+      // strip leading namespace and qualifiers
+      const char *e=eName.c_str()+eName.length();
+      while (e!=eName.c_str() && *(e-1)!=' ' && *(e-1)!=':') e--;
+      xml_unpack_tuple_element(o,d+"."+e,a,0);
+    }
+  };
+#endif
+
 #endif
 }
 

xsd_generate_base.h

@@ -398,6 +398,27 @@ namespace classdesc
     processExtraClass(g, d+transformTypeName(typeName<T>()), T());
   }
 #endif
+
+#if defined(__cplusplus) && __cplusplus>=201703L
+  template <class... A>
+  void tuple_element_generate(xsd_generate_t& g, const string& d, const std::tuple<A...>& e)
+  {
+    if constexpr (std::tuple_size<std::tuple<A...>>::value>0)
+      {
+        xsd_generate(g,d+"."+transformTypeName(typeName<typename std::tuple_element<0,std::tuple<A...>>::type>()),
+                     std::get<0>(e));
+        tuple_element_generate(g,d,classdesc::tupleTail(e));
+      }
+  }
+  template <class... A>
+  void xsd_generate(xsd_generate_t& g, const string& d, const std::tuple<A...>& e)
+  {
+    g.openType(transformTypeName(typeName<std::tuple<A...>>()),d);
+    tuple_element_generate(g,d,e);
+    g.closeType();
+    g.addMember(tail(d), xsd_typeName<std::tuple<A...>>());
+  }
+#endif
 
   // support for maps
   template <class T, class U>
@@ -407,7 +428,7 @@ namespace classdesc
     xsd_generate(g,d+".first",a.first);
     xsd_generate(g,d+".second",a.second);
     g.closeType();
-    g.addMember(tail(d), xsd_typeName<std::pair<T,U>>());
+    g.addMember(tail(d), xsd_typeName<std::pair<T,U> >());
   }
 
   template <class T>