Fixes to make Minsky buildable

Author: highperformancecoder

RESTProcess_base.h

@@ -381,13 +381,13 @@ namespace classdesc
   RPPtr makeRESTProcessValueObject(T&& obj)
   {return std::make_shared<RESTProcessValueObject<typename std::remove_reference<T>::type>>(std::forward<T>(obj));}
   // specialization for string and string vector to allow
-   RPPtr makeRESTProcessValueObject(const char* s)
+  inline RPPtr makeRESTProcessValueObject(const char* s)
   {return std::make_shared<RESTProcessValueObject<std::string>>(s);}
-  RPPtr makeRESTProcessValueObject(const std::initializer_list<std::string>& init)
+  inline RPPtr makeRESTProcessValueObject(const std::initializer_list<std::string>& init)
   {return std::make_shared<RESTProcessValueObject<std::vector<std::string>>>(init);}
 
   /// class that represents the void, or null object
-  class RESTProcessVoid: public RESTProcessBase
+  struct RESTProcessVoid: public RESTProcessBase
   {
     std::shared_ptr<RESTProcessBase> process(const string&, const REST_PROCESS_BUFFER&) override
     {return std::make_shared<RESTProcessVoid>();}
@@ -712,7 +712,7 @@ namespace classdesc
         return RESTProcessObject<typename T::element_type>(*p).list();
       return makeRESTProcessValueObject({});
     }
-    REST_PROCESS_BUFFER type() const override {return REST_PROCESS_BUFFER(typeName<std::weak_ptr<T> >());}
+    RPPtr type() const override {return makeRESTProcessValueObject(typeName<std::weak_ptr<T> >());}
     object* getClassdescObject() override {
       auto p=ptr.lock();
       if (!p || is_const<typename T::element_type>::value) return nullptr;
@@ -722,6 +722,11 @@ namespace classdesc
       auto p=ptr.lock();
       return p? getClassdescObjectImpl(*p): nullptr;
     }
+    REST_PROCESS_BUFFER asBuffer() const override {
+      REST_PROCESS_BUFFER r;
+      auto p=ptr.lock();
+      return p? (r<<*p): r;
+    }
   };
 
 
@@ -1082,19 +1087,21 @@ namespace classdesc
     template <class U>
     typename enable_if<
       And<
-        is_default_constructible<remove_reference<U>>,
+        is_default_constructible<typename remove_reference<U>::type>,
+        //Not<is_abstract<typename remove_reference<U>::type>>,
         Not<is_void<U>>
         >,RPPtr>::T
     slist() const {
-      typename remove_reference<U>::type x;
+      typename remove_const<typename remove_reference<U>::type>::type x;
       return RESTProcessObject<U>(x).list();
     }
     // for now, we cannot extract the lists of a non-default constructible return type
     template <class U>
     typename enable_if<
       Not<
         And<
-          is_default_constructible<remove_reference<U>>,
+          is_default_constructible<typename remove_reference<U>::type>,
+          //Not<is_abstract<typename remove_reference<U>::type>>,
           Not<is_void<U>>
           >>,RPPtr>::T
     slist() const {return makeRESTProcessValueObject({});}
@@ -1171,7 +1178,7 @@ namespace classdesc
     RPPtr signature() const override;
     RPPtr list() const override {return makeRESTProcessValueObject({});}
     RPPtr type() const override {return makeRESTProcessValueObject(typeName<E>());}
-    REST_PROCESS_BUFFER asBuffer() const {return REST_PROCESS_BUFFER(enum_keys<E>()(e));}
+    REST_PROCESS_BUFFER asBuffer() const override {return REST_PROCESS_BUFFER(enum_keys<E>()(e));}
   };
 
   template <class E>

classdesc.cc

@@ -184,6 +184,25 @@ struct type_defined_t: hash_map<string,int>
 
 std::map<std::string, std::vector<std::string> > enum_keys;
 
+// insert a typename keyword on types with :: qualification
+string insertTypename(string type)
+{
+  // replace whitespace characters with space
+  for (size_t i=0; i<type.size(); ++i)
+    if (isspace(type[i]))
+      type[i]=' ';
+  if (type.find("::")==string::npos || type.find("typename ")!=string::npos)
+    return type; // nothing needs to be done
+  
+  type=trimWS(type);
+  static const int constSize=strlen("const ");
+  if (type.find("const ")==0)
+    // insert typename between const and type
+    return "const typename "+type.substr(constSize);
+  else
+    return "typename "+type;
+}
+
 // overloaded member database
 struct MemberSig
 {
@@ -193,16 +212,14 @@ struct MemberSig
   MemberSig(string d, string r, string a, string p, string n, Type t):
     declName(d), returnType(r), argList(a), prefix(p), name(n), type(t) {}
   string declare() {
-    // If qualified type, the typename qualifier required
-    string rType=returnType.find("::")!=string::npos && returnType.find("typename ")==string::npos? "typename "+returnType: returnType;
     switch (type)
       {
       case none:
-        return rType+"("+prefix+"*"+declName+")("+argList+")=&"+prefix+name+";";
+        return insertTypename(returnType)+"("+prefix+"*"+declName+")("+argList+")=&"+prefix+name+";";
       case is_const:
-        return rType+"("+prefix+"*"+declName+")("+argList+") const=&"+prefix+name+";";
+        return insertTypename(returnType)+"("+prefix+"*"+declName+")("+argList+") const=&"+prefix+name+";";
       case is_static:
-        return rType+"(*"+declName+")("+argList+")=&"+prefix+name+";";
+        return insertTypename(returnType)+"(*"+declName+")("+argList+")=&"+prefix+name+";";
       case is_constructor:
         return "void (*"+declName+")("+argList+")=0;";
       default: assert(false); return ""; // should never be executed, - statement to silence warning

classdesc.h

@@ -1058,6 +1058,10 @@ namespace classdesc
     bool operator!() const {return !val;}  
   };                                               
 
+  template <class T> struct is_excluded: public false_type {};
+  template <class T> struct is_excluded<Exclude<T> >: public true_type {};
+  
+  
   /// @}
 
   template <class T>

object.h

@@ -16,11 +16,11 @@
 namespace classdesc
 {
   struct object;
-  typedef std::vector<shared_ptr<object> > Factory;
-  inline Factory& factory()
+  typedef std::vector<shared_ptr<object> > ObjectFactory;
+  inline ObjectFactory& factory()
   {
     // ensure factory is initialised on first use
-    static Factory f;
+    static ObjectFactory f;
     return f;
   }
 

pack_base.h

@@ -477,7 +477,7 @@ namespace classdesc
   /// for use in metaprogramming support. Indicate that a given type
   /// is supported explicitly
   template <class T> struct pack_supported: 
-    public Or<is_fundamental<T>,is_container<T> > {};
+    public Or<is_fundamental<T>,is_container<T>,is_excluded<T> > {};
 
 #ifndef THROW_PTR_EXCEPTION
   template <class T>
@@ -755,6 +755,9 @@ namespace classdesc
     a=x;
   }
 
+  template <class T> void pack(pack_t&, const string&, const Exclude<T>&) {}
+  template <class T> void unpack(pack_t&, const string&, const Exclude<T>&) {}
+  
 }
 
 #include "use_mbr_pointers.h"

signature.h

@@ -22,4 +22,14 @@ namespace classdesc
 }
 
 #include "signature.cd"
+
+#pragma omit RESTProcess classdesc::Signature
+namespace classdesc_access
+{
+#ifdef RESTPROCESS_H // spurious, needed for old Classdesc
+  template <>
+  struct access_RESTProcess<classdesc::Signature>: public classdesc::NullDescriptor<classdesc::RESTProcess_t> {};
+#endif
+}
+
 #endif