Add in a has_index_operator and has_size type traits.

RESTProcess uses this to support operator[] in python or @elem.
has_index_operator needs to be marked up manually, alas, as I couldn't figure out how to SFINAE it.

Author: highperformancecoder

RESTProcess_base.h

@@ -482,6 +482,36 @@ namespace classdesc
     bool isObject() const override {return true;}
     const object* getConstClassdescObject() override {return getClassdescObjectImpl(obj);}
     bool isConst() const override {return std::is_const<T>::value;}
+    size_t size() const override {
+      if constexpr (is_class<T>::value)
+        if constexpr (has_size<T>::value)
+          return obj.size();
+      return 0;
+    }
+    RPPtr getElem(const REST_PROCESS_BUFFER& b) override {
+      if constexpr (is_class<T>::value)
+        if constexpr (has_index_operator<T>::value)
+           {
+             size_t index; b>>index;
+             return makeRESTProcessRef(obj[index]);
+           }
+      return RESTProcessBase::getElem(b);
+    }
+    /// sets element indexed/keyed by \a index to \a value
+    /// @return updated element
+    RPPtr setElem(const REST_PROCESS_BUFFER& b, const REST_PROCESS_BUFFER& value) override
+    {
+      if constexpr (is_class<T>::value && !is_const<T>::value)
+        if constexpr (has_index_operator<T>::value)
+          {
+            size_t index; b>>index;
+            value>>obj[index];
+            return makeRESTProcessRef(obj[index]);
+          }
+      return RESTProcessBase::setElem(b,value);
+    }
+    
+
   };
 
   /// same as \a RESTProcessObject, but internally stores the object. T must be copy constructible or moveable

classdesc.h

@@ -486,7 +486,23 @@ namespace classdesc
   push_back(T& x, const typename T::value_type& v) {} 
 
 
+  CLASSDESC_HAS_MEMBER(size);
+  template <class T> struct has_size: public has_member_size<T,size_t (T::*)()const> {};
+  CLASSDESC_HAS_MEMBER(value_type);
+  template <class T> struct has_value_type: public has_member_value_type<T,size_t (T::*)()const> {};
+
+  // doesn't quite work :(
+//  template <class T>                                   
+//  struct has_index_operator                                      
+//  {                                                               
+//    template <class U, decltype(&U::operator[])> struct SFINAE {};                          
+//    template <class U> static char test(SFINAE<U,&U::operator[]>*);    
+//    template <class U> static int test(...);                           
+//    const static bool value=sizeof(test<T>(0))==sizeof(char);          
+//  };
 
+  // specialise this to enable python indexing
+  template <class T> struct has_index_operator: public false_type {};
 
   //  template <class T>
   //  typename enable_if<is_sequence<T>,void>::T