Added tuple support for pack descriptor, available at C++17, and wired tests in the C++17 suite.

Author: highperformancecoder

Makefile

@@ -119,7 +119,8 @@ aegis-all: build latex-docs
 # This is now broken, as of OpenJDK 15. Not worth supporting. 
 #	if which javac; then cd java && $(MAKE) && cd ../javaExamples && $(MAKE); fi
 	cd test && $(MAKE)
-	cd test/c++11 && $(MAKE)
+	cd test/c++11 && $(MAKE) sure
+	cd test/c++17 && $(MAKE) sure
 	cd RESTProcessExample && $(MAKE)
 #	-cd objc-examples && $(MAKE)
 

classdesc.h

@@ -1165,6 +1165,83 @@ namespace classdesc
     std::cout<<msg<<std::endl;
 #endif
   }
+
+  // tuple support
+#if defined(__cplusplus) && __cplusplus>=201103L
+  template <class... A> struct tn<std::tuple<A...>>
+  {
+    // TODO unpack argpack to explicitly name template parameters
+    static string name() {return "std::tuple<...>";}
+  };
+#endif
+  
+#if defined(__cplusplus) && __cplusplus>=201703L
+  
+  // The helper function that does the heavy lifting
+  template <typename Tuple, std::size_t... Is>
+  auto tupleTailImpl(Tuple&& t, std::index_sequence<Is...>) {
+    // We add 1 to each index 'Is' to skip the first element (index 0)
+    return std::make_tuple(std::get<Is + 1>(std::forward<Tuple>(t))...);
+  }
+
+  template <typename Tuple>
+  auto tupleTail(Tuple&& t) {
+    constexpr std::size_t N = std::tuple_size<std::decay_t<Tuple>>::value;
+    
+    // Ensure the tuple isn't empty before trying to take the tail
+    static_assert(N > 0, "Cannot take the tail of an empty tuple.");
+
+    if constexpr (N == 1) {
+        return std::make_tuple(); // Tail of a single-element tuple is empty
+    } else {
+        // Generate indices from 0 to N-2
+        return tupleTailImpl(std::forward<Tuple>(t), 
+                            std::make_index_sequence<N - 1>{});
+    }
+  }
+#endif
+  
+//#if defined(__cplusplus) && __cplusplus>=201103L
+//
+//
+//  
+//  template <template <class...> class T> struct Tuple1TailType;
+//  template <template <class...> class T, class A, class... B>
+//  struct Tuple1TailType<class T<A, B...>>
+//  {
+//    using type=T<B...>;
+//  };
+//
+//  template <int N, class T> struct TupleTailType;
+//  
+//  template <class T>
+//  struct TupleTailType<1, T>
+//  {
+//    using type=typename Tuple1TailType<T>::type;
+//  };
+//  
+//  template <int N, template <class...> class T, class A, class... B>
+//  struct TupleTailType<N, T<A, B...>>
+//  {
+//    using type=typename TupleTailType<N-1, B...>::type;
+//  };
+// 
+//  template <class T, int N> struct TupleTail
+//  {
+//    typename TupleTailType<N, T>::type tuple;
+//    TupleTail(const T& x):
+//      tuple(std::tuple_cat(std::make_tuple(std::get<N>(x)), TupleTail<T,N+1>(x).tuple)) {}
+//  };
+//
+//  template <class T> struct TupleTail<T, std::tuple_size<T>::value-1>
+//  {
+//    std::tuple<
+//      typename std::tuple_element<std::tuple_size<T>::value-1,T>::type> tuple;
+//    TupleTail(const T& x):
+//      tuple(std::get<std::tuple_size<T>::value-1>(x)) {}
+//  };
+//#endif
+  
 }
 
 

pack_base.h

@@ -601,7 +601,7 @@ namespace classdesc
   //generic pack, unpack - defined in pack_stream
   template <class T> typename
   enable_if<Not<pack_supported<T> >, void>::T
-  pack(pack_t& buf, const string& desc, T& arg)
+  pack(pack_t& buf, const string& desc, const T& arg)
   {classdesc_access::access_pack<T>()(buf,desc,arg);}
 
 

pack_stl.h

@@ -17,6 +17,7 @@
 
 #if defined(__cplusplus) && __cplusplus>=201103L
 #include <array>
+#include <tuple>
 #endif
 #include <iterator>
 #include <string>
@@ -302,6 +303,33 @@ namespace classdesc_access
       ::unpack(targ,desc,arg.second);
     }
   };
+#if defined(__cplusplus) && __cplusplus>=201703L
+  template <class... A> struct access_pack<std::tuple<A...>>
+  {
+    template <class U>
+    void operator()(classdesc::pack_t& targ, const classdesc::string& desc, U& arg) 
+    {
+      ::pack(targ,desc,std::get<0>(arg));
+      if constexpr (std::tuple_size<U>::value>1)
+        ::pack(targ,desc,classdesc::tupleTail(arg));
+    }
+  };
+
+  template <class... A> struct access_unpack<std::tuple<A...> >
+  {
+    template <class U>
+    void operator()(classdesc::pack_t& targ, const classdesc::string& desc, U& arg) 
+    {
+      ::unpack(targ,desc,std::get<0>(arg));
+      if constexpr (std::tuple_size<U>::value>1)
+        {
+          auto tail=classdesc::tupleTail(arg);
+          ::unpack(targ,desc,tail);
+          arg=std::tuple_cat(std::make_tuple(std::get<0>(arg)), tail);
+        }
+    }
+  };
+#endif
 }
 #ifdef _CLASSDESC
 #pragma omit pack std::plus

pythonExample/Makefile

@@ -1,6 +1,6 @@
 .SUFFIXES: .c .cc .o .d .h .cd
 OBJS=pythonExample.o
-CFLAGS=-g `pkg-config --cflags python3` -I.. -I. -I../json5_parser/json5_parser -fPIC -std=c++11 -DUSE_UNROLLED
+CFLAGS=-g `pkg-config --cflags python3` -I.. -I. -I../json5_parser/json5_parser -fPIC -std=c++17 -DUSE_UNROLLED
 VPATH=..
 
 example.so: $(OBJS)

test/c++11/Makefile

@@ -107,7 +107,7 @@ endif
 	../../classdesc -I .. -nodef -typeName -i $< pack unpack >$@
 # check that duplicate typeNames can be issued
 #	../classdesc -I .. -nodef -typeName <$< >>$@
-	../../classdesc -I .. -nodef -typeName -respect_private -i $< xml_pack xml_unpack dump xsd_generate  >>$@
+	../../classdesc -I .. -nodef -typeName -respect_private -i $< xml_pack xml_unpack json_pack json_unpack dump xsd_generate  >>$@
 
 xml_unpack_base.cd: xml_unpack_base.h
 	../../classdesc -I .. -nodef pack unpack <$< >$@

test/c++17/Makefile

@@ -3,7 +3,7 @@
 #define NOGUI if X-windows not installed
 NOGUI=
 
-EXES=testFunctional
+EXES=testFunctional c++Features
 OBJS=
 
 # note the internal type example cannot be correctly linked with g++ or icc!

test/c++17/c++Features.cc

@@ -0,0 +1,39 @@
+// why are these lines needed?? Bug in gcc?
+#include <vector>
+#include <unordered_map>
+#include <classdesc.h>
+namespace std
+{
+  template <class T>
+  struct hash<vector<T> >
+  {
+    unsigned operator()(const vector<T>& x) const {
+      unsigned r=0;
+      for (auto i: x)
+        r ^= hash<T>()(i);
+      return r;
+    }
+  };
+}
+
+#include "pack_stl.h"
+#include "c++Features.h"
+#include "classdesc_epilogue.h"
+
+using namespace classdesc;
+
+
+using std::cout;
+using std::endl;
+
+int main()
+{
+  pack_t b;
+  CppFeatures x, y;
+  x.tup={10,3}; // set to different from default
+  b<<x>>y;
+  assert(x.tup==y.tup); // checks brace initialiser
+
+  // make sure various C++17 types have valid typenames
+  cout << typeName<std::tuple<int,int>>() << endl;
+}

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

@@ -0,0 +1,12 @@
+#ifndef CPPFEATURES_H
+#define CPPFEATURES_H
+
+struct CppFeatures
+{
+  std::tuple<int, int> tup{3,2};
+};
+
+
+
+#include "c++Features.cd"
+#endif