Handle polymorphic classes properly in RESTProcess.

Author: highperformancecoder

RESTProcess_base.h

@@ -539,12 +539,14 @@ namespace classdesc
     is_class<T>,
     Not<is_container<T>>,
     Not<is_smart_ptr<T>>,
-    Not<is_string<T>>
+    Not<is_string<T>>,
+    Not<is_excluded<T>>
     > {};
 
 
   template <class T>
-  void RESTProcessp(RESTProcess_t& repo, const string& d, Exclude<T>& a)
+  typename enable_if<is_excluded<T>,void>::T
+  RESTProcessp(RESTProcess_t& repo, const string& d, T& a)
   {}
 
   template <class T>
@@ -658,7 +660,8 @@ namespace classdesc
     erase(U& o,typename U::iterator i) {o.erase(i);}
 
     template <class U>
-    void erase(U& o,typename U::const_iterator i) {}
+    typename enable_if<Not<is_same<typename U::iterator,typename U::const_iterator>>,void>::T
+    erase(U& o,typename U::const_iterator i) {}
 
     template <class U>
     typename enable_if<Not<has_member_erase<U,typename U::iterator(U::*)(typename U::const_iterator)>>,void>::T
@@ -714,6 +717,12 @@ namespace classdesc
     RESTProcessValueSequence(Args&&... args): RESTProcessSequence<T>(actual), actual(std::forward<Args>(args)...) {}
   };
 
+  template <class T, int R> RPPtr copyMultiArrayIterator(MultiArray<T,R>& x);
+  template <class T, int R> RPPtr copyMultiArrayIterator(const MultiArray<T,R>& x);
+
+  template <class T> RPPtr copyMultiArrayIterator(T& x)
+  {return std::make_shared<RESTProcessObject<T>>(x);}
+  
   template <class T> struct RESTProcessMultiArray: public RESTProcessBase
   {
     T actual;
@@ -732,7 +741,7 @@ namespace classdesc
     RPPtr getElem(const REST_PROCESS_BUFFER& index) override {
       size_t idx; index>>idx;
       if (idx<actual.size())
-        return std::make_shared<RESTProcessMultiArray<typename T::value_type>>(actual[idx]);
+        return copyMultiArrayIterator(actual[idx]);
       return std::make_shared<RESTProcessVoid>();
     }
     RPPtr setElem(const REST_PROCESS_BUFFER& index, const REST_PROCESS_BUFFER& value) override {
@@ -741,13 +750,18 @@ namespace classdesc
         {
           auto elem=actual[idx];
           convert(elem,value);
-          return std::make_shared<RESTProcessMultiArray<typename T::value_type>>(elem);
+          return copyMultiArrayIterator(elem);
         }
       return std::make_shared<RESTProcessVoid>();
     }
     size_t size() const override {return actual.size();}
   };
 
+  template <class T, int R> RPPtr copyMultiArrayIterator(MultiArray<T,R>& x)
+  {return std::make_shared<RESTProcessMultiArray<MultiArray<T,R>>>(x);}
+  template <class T, int R> RPPtr copyMultiArrayIterator(const MultiArray<T,R>& x)
+  {return std::make_shared<RESTProcessMultiArray<MultiArray<T,R>>>(x);}
+
   template <class T> struct RESTProcessMultiArray<classdesc::MultiArray<T,1>>:
     public RESTProcessSequence<classdesc::MultiArray<T,1>>
   {

RESTProcess_epilogue.h

@@ -102,14 +102,28 @@ namespace classdesc
     return {{"vector<string>",{}}};
   }
 
-  template <class T> 
-  RESTProcess_t RESTProcessObject<T>::list() const
+  template <class T>
+  typename enable_if<is_base_of<PolyRESTProcessBase, T>, RESTProcess_t>::T
+  rlist(T& obj)
+  {
+    RESTProcess_t map;
+    obj.RESTProcess(map,"");
+    return map;
+  }
+  
+  template <class T>
+  typename enable_if<Not<is_base_of<PolyRESTProcessBase, T>>, RESTProcess_t>::T
+  rlist(T& obj)
   {
     RESTProcess_t map;
     RESTProcess(map,"",obj);
     return map;
   }
 
+  template <class T> 
+  RESTProcess_t RESTProcessObject<T>::list() const
+  {return rlist(obj);}
+  
   inline RESTProcess_t RESTProcessOverloadedFunction::list() const {return {};}
 
   template <class T>
@@ -167,7 +181,7 @@ namespace classdesc
   RESTProcessp(RESTProcess_t& repo, string d, T& obj)
   {
     classdesc_access::access_RESTProcess<typename remove_const<T>::type,void>()(repo,d,obj);
-    repo.add(d, new RESTProcessObject<T>(obj));
+    if (!is_excluded<T>::value) repo.add(d, new RESTProcessObject<T>(obj));
   }
 
   inline RPPtr RESTProcessOverloadedFunction::process(const string& remainder, const REST_PROCESS_BUFFER& arguments)
@@ -285,7 +299,7 @@ namespace classdesc
         auto r=mapAndProcess(remainder.substr(idxEnd), arguments, *i);
         if (idxEnd==remainder.length() && T::rank>1)
           // create a copy of the MultiArray iterator before it goes out of scope
-          return std::make_shared<RESTProcessMultiArray<typename T::iterator::value_type>>(*i);
+          return copyMultiArrayIterator(*i);
         return r;
       }
     return sequenceProcess(actual,remainder,arguments);
@@ -489,11 +503,10 @@ namespace classdesc
         }
     }
 
-   template <class T>
+  template <class T>
   RPPtr mapAndProcess(const string& query, const REST_PROCESS_BUFFER& arguments, T& a)
   {
-    RESTProcess_t map;
-    RESTProcess(map,"",a);
+    RESTProcess_t map=RESTProcessObject<T>(a).list();
     if (query.empty())
       {
         auto i=map.find("");

classdesc.h

@@ -428,7 +428,7 @@ namespace classdesc
   ///@}
 
   /// transfer the constness property of T to U
-  template <class T, class U, bool c=is_const<T>::value> struct transfer_const;
+  template <class T, class U, bool c=Or<is_const<T>,is_const<U>>::value> struct transfer_const;
   template <class T, class U> struct transfer_const<T,U,true>
   {
     typedef typename add_const<U>::type type;
@@ -1065,6 +1065,7 @@ namespace classdesc
 
   template <class T> struct is_excluded: public false_type {};
   template <class T> struct is_excluded<Exclude<T> >: public true_type {};
+  template <class T> struct is_excluded<const Exclude<T> >: public true_type {};
 
 
   /// @}