all methods to register functions, methods, properties and classes not return *this, to allow chaining these methods. This was suggested by valmat in issue #55

1 files changed, 45 insertions, 43 deletions

diff --git a/include/class.h b/include/class.h
index 192e653..a63d35d 100644
--- a/include/class.h
+++ b/include/class.h
@@ -78,23 +78,24 @@ public:
      *  @param  method      The actual method
      *  @param  flags       Optional flags
      *  @param  args        Argument descriptions
-     */
-    void method(const char *name, void  (T::*method)(),                         int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_0>(method), flags,  args); }
-    void method(const char *name, void  (T::*method)(Parameters &params),       int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_1>(method), flags,  args); }
-    void method(const char *name, Value (T::*method)(),                         int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_2>(method), flags,  args); }
-    void method(const char *name, Value (T::*method)(Parameters &params),       int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_3>(method), flags,  args); }
-    void method(const char *name, void  (T::*method)(),                                    const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_0>(method), Public, args); }
-    void method(const char *name, void  (T::*method)(Parameters &params),                  const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_1>(method), Public, args); }
-    void method(const char *name, Value (T::*method)(),                                    const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_2>(method), Public, args); }
-    void method(const char *name, Value (T::*method)(Parameters &params),                  const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_3>(method), Public, args); }
-    void method(const char *name, void  (T::*method)()                   const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_4>(method), flags,  args); }
-    void method(const char *name, void  (T::*method)(Parameters &params) const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_5>(method), flags,  args); }
-    void method(const char *name, Value (T::*method)()                   const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_6>(method), flags,  args); }
-    void method(const char *name, Value (T::*method)(Parameters &params) const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_7>(method), flags,  args); }
-    void method(const char *name, void  (T::*method)()                   const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_4>(method), Public, args); }
-    void method(const char *name, void  (T::*method)(Parameters &params) const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_5>(method), Public, args); }
-    void method(const char *name, Value (T::*method)()                   const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_6>(method), Public, args); }
-    void method(const char *name, Value (T::*method)(Parameters &params) const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_7>(method), Public, args); }
+     *  @return Class       Same object to allow chaining
+     */
+    Class<T> &method(const char *name, void  (T::*method)(),                         int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_0>(method), flags,  args); }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params),       int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_1>(method), flags,  args); }
+    Class<T> &method(const char *name, Value (T::*method)(),                         int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_2>(method), flags,  args); }
+    Class<T> &method(const char *name, Value (T::*method)(Parameters &params),       int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_3>(method), flags,  args); }
+    Class<T> &method(const char *name, void  (T::*method)(),                                    const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_0>(method), Public, args); }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params),                  const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_1>(method), Public, args); }
+    Class<T> &method(const char *name, Value (T::*method)(),                                    const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_2>(method), Public, args); }
+    Class<T> &method(const char *name, Value (T::*method)(Parameters &params),                  const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_3>(method), Public, args); }
+    Class<T> &method(const char *name, void  (T::*method)()                   const, int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_4>(method), flags,  args); }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params) const, int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_5>(method), flags,  args); }
+    Class<T> &method(const char *name, Value (T::*method)()                   const, int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_6>(method), flags,  args); }
+    Class<T> &method(const char *name, Value (T::*method)(Parameters &params) const, int flags, const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_7>(method), flags,  args); }
+    Class<T> &method(const char *name, void  (T::*method)()                   const,            const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_4>(method), Public, args); }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params) const,            const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_5>(method), Public, args); }
+    Class<T> &method(const char *name, Value (T::*method)()                   const,            const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_6>(method), Public, args); }
+    Class<T> &method(const char *name, Value (T::*method)(Parameters &params) const,            const Arguments &args = {}) { return ClassBase::method(name, static_cast<method_callback_7>(method), Public, args); }
 
     /**
      *  Add a static method to a class
@@ -110,15 +111,16 @@ public:
      *  @param  method      The actual method
      *  @param  flags       Optional flags
      *  @param  args        Argument descriptions
-     */
-    void method(const char *name, const native_callback_0 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); }
-    void method(const char *name, const native_callback_1 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); }
-    void method(const char *name, const native_callback_2 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); }
-    void method(const char *name, const native_callback_3 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); }
-    void method(const char *name, const native_callback_0 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); }
-    void method(const char *name, const native_callback_1 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); }
-    void method(const char *name, const native_callback_2 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); }
-    void method(const char *name, const native_callback_3 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); }
+     *  @return Class       Same object to allow chaining
+     */
+    Class<T> &method(const char *name, const native_callback_0 &function, int flags, const Arguments &args = {}) { return ClassBase::method(name, function, flags,  args); }
+    Class<T> &method(const char *name, const native_callback_1 &function, int flags, const Arguments &args = {}) { return ClassBase::method(name, function, flags,  args); }
+    Class<T> &method(const char *name, const native_callback_2 &function, int flags, const Arguments &args = {}) { return ClassBase::method(name, function, flags,  args); }
+    Class<T> &method(const char *name, const native_callback_3 &function, int flags, const Arguments &args = {}) { return ClassBase::method(name, function, flags,  args); }
+    Class<T> &method(const char *name, const native_callback_0 &function,            const Arguments &args = {}) { return ClassBase::method(name, function, Public, args); }
+    Class<T> &method(const char *name, const native_callback_1 &function,            const Arguments &args = {}) { return ClassBase::method(name, function, Public, args); }
+    Class<T> &method(const char *name, const native_callback_2 &function,            const Arguments &args = {}) { return ClassBase::method(name, function, Public, args); }
+    Class<T> &method(const char *name, const native_callback_3 &function,            const Arguments &args = {}) { return ClassBase::method(name, function, Public, args); }
 
     /**
      *  Add an abstract method to the class
@@ -131,8 +133,8 @@ public:
      *  @param  flags       Optional flags
      *  @param  args        Argument descriptions
      */
-    void method(const char *name, int flags, const Arguments &args = {}) { ClassBase::method(name, flags  | Abstract, args); }
-    void method(const char *name,            const Arguments &args = {}) { ClassBase::method(name, Public | Abstract, args); }
+    Class<T> &method(const char *name, int flags, const Arguments &args = {}) { return ClassBase::method(name, flags  | Abstract, args); }
+    Class<T> &method(const char *name,            const Arguments &args = {}) { return ClassBase::method(name, Public | Abstract, args); }
 
     /**
      *  Add a property to the class
@@ -147,15 +149,15 @@ public:
      *  @param  value       Actual property value
      *  @param  flags       Optional flags
      */
-    void property(const char *name, std::nullptr_t value,     int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, int64_t value,            int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, int32_t value,            int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, int16_t value,            int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, char value,               int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, const char *value,        int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, const std::string &value, int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, bool value,               int flags = Public) { ClassBase::property(name, value, flags); }
-    void property(const char *name, double value,             int flags = Public) { ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, std::nullptr_t value,     int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, int64_t value,            int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, int32_t value,            int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, int16_t value,            int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, char value,               int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, const char *value,        int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, const std::string &value, int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, bool value,               int flags = Public) { return ClassBase::property(name, value, flags); }
+    Class<T> &property(const char *name, double value,             int flags = Public) { return ClassBase::property(name, value, flags); }
 
     /**
      *  Properties as methods
@@ -170,12 +172,12 @@ public:
      *  @param  getter      The getter method
      *  @param  setter      The setter method
      */
-    void property(const char *name, Value (T::*getter)()                                                   ) { ClassBase::property(name, static_cast<getter_callback_0>(getter)); }
-    void property(const char *name, Value (T::*getter)() const                                             ) { ClassBase::property(name, static_cast<getter_callback_1>(getter)); }
-    void property(const char *name, Value (T::*getter)()      , void (T::*setter)(const Value &value)      ) { ClassBase::property(name, static_cast<getter_callback_0>(getter), static_cast<setter_callback_0>(setter)); }
-    void property(const char *name, Value (T::*getter)() const, void (T::*setter)(const Value &value)      ) { ClassBase::property(name, static_cast<getter_callback_1>(getter), static_cast<setter_callback_0>(setter)); }
-    void property(const char *name, Value (T::*getter)()      , void (T::*setter)(const Value &value) const) { ClassBase::property(name, static_cast<getter_callback_0>(getter), static_cast<setter_callback_1>(setter)); }
-    void property(const char *name, Value (T::*getter)() const, void (T::*setter)(const Value &value) const) { ClassBase::property(name, static_cast<getter_callback_1>(getter), static_cast<setter_callback_1>(setter)); }
+    Class<T> &property(const char *name, Value (T::*getter)()                                                   ) { return ClassBase::property(name, static_cast<getter_callback_0>(getter)); }
+    Class<T> &property(const char *name, Value (T::*getter)() const                                             ) { return ClassBase::property(name, static_cast<getter_callback_1>(getter)); }
+    Class<T> &property(const char *name, Value (T::*getter)()      , void (T::*setter)(const Value &value)      ) { return ClassBase::property(name, static_cast<getter_callback_0>(getter), static_cast<setter_callback_0>(setter)); }
+    Class<T> &property(const char *name, Value (T::*getter)() const, void (T::*setter)(const Value &value)      ) { return ClassBase::property(name, static_cast<getter_callback_1>(getter), static_cast<setter_callback_0>(setter)); }
+    Class<T> &property(const char *name, Value (T::*getter)()      , void (T::*setter)(const Value &value) const) { return ClassBase::property(name, static_cast<getter_callback_0>(getter), static_cast<setter_callback_1>(setter)); }
+    Class<T> &property(const char *name, Value (T::*getter)() const, void (T::*setter)(const Value &value) const) { return ClassBase::property(name, static_cast<getter_callback_1>(getter), static_cast<setter_callback_1>(setter)); }
     
 private:
     /**