fixed broken texts because of wrong return value of many chaining methods in Class.h

3 files changed, 43 insertions, 43 deletions

diff --git a/include/class.h b/include/class.h
index a63d35d..b9295ea 100644
--- a/include/class.h
+++ b/include/class.h
@@ -80,22 +80,22 @@ public:
      *  @param  args        Argument descriptions
      *  @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); }
+    Class<T> &method(const char *name, void  (T::*method)(),                         int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_0>(method), flags,  args); return *this; }
+    Class<T> &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); return *this; }
+    Class<T> &method(const char *name, Value (T::*method)(),                         int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_2>(method), flags,  args); return *this; }
+    Class<T> &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); return *this; }
+    Class<T> &method(const char *name, void  (T::*method)(),                                    const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_0>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params),                  const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_1>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, Value (T::*method)(),                                    const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_2>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, Value (T::*method)(Parameters &params),                  const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_3>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, void  (T::*method)()                   const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_4>(method), flags,  args); return *this; }
+    Class<T> &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); return *this; }
+    Class<T> &method(const char *name, Value (T::*method)()                   const, int flags, const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_6>(method), flags,  args); return *this; }
+    Class<T> &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); return *this; }
+    Class<T> &method(const char *name, void  (T::*method)()                   const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_4>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, void  (T::*method)(Parameters &params) const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_5>(method), Public, args); return *this; }
+    Class<T> &method(const char *name, Value (T::*method)()                   const,            const Arguments &args = {}) { ClassBase::method(name, static_cast<method_callback_6>(method), Public, args); return *this; }
+    Class<T> &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 *this; }
 
     /**
      *  Add a static method to a class
@@ -113,14 +113,14 @@ public:
      *  @param  args        Argument descriptions
      *  @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); }
+    Class<T> &method(const char *name, const native_callback_0 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); return *this; }
+    Class<T> &method(const char *name, const native_callback_1 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); return *this; }
+    Class<T> &method(const char *name, const native_callback_2 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); return *this; }
+    Class<T> &method(const char *name, const native_callback_3 &function, int flags, const Arguments &args = {}) { ClassBase::method(name, function, flags,  args); return *this; }
+    Class<T> &method(const char *name, const native_callback_0 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); return *this; }
+    Class<T> &method(const char *name, const native_callback_1 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); return *this; }
+    Class<T> &method(const char *name, const native_callback_2 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); return *this; }
+    Class<T> &method(const char *name, const native_callback_3 &function,            const Arguments &args = {}) { ClassBase::method(name, function, Public, args); return *this; }
 
     /**
      *  Add an abstract method to the class
@@ -133,8 +133,8 @@ public:
      *  @param  flags       Optional flags
      *  @param  args        Argument descriptions
      */
-    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); }
+    Class<T> &method(const char *name, int flags, const Arguments &args = {}) { ClassBase::method(name, flags  | Abstract, args); return *this; }
+    Class<T> &method(const char *name,            const Arguments &args = {}) { ClassBase::method(name, Public | Abstract, args); return *this; }
 
     /**
      *  Add a property to the class
@@ -149,15 +149,15 @@ public:
      *  @param  value       Actual property value
      *  @param  flags       Optional 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); }
+    Class<T> &property(const char *name, std::nullptr_t value,     int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, int64_t value,            int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, int32_t value,            int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, int16_t value,            int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, char value,               int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, const char *value,        int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, const std::string &value, int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, bool value,               int flags = Public) { ClassBase::property(name, value, flags); return *this; }
+    Class<T> &property(const char *name, double value,             int flags = Public) { ClassBase::property(name, value, flags); return *this; }
 
     /**
      *  Properties as methods
@@ -172,12 +172,12 @@ public:
      *  @param  getter      The getter method
      *  @param  setter      The setter method
      */
-    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)); }
+    Class<T> &property(const char *name, Value (T::*getter)()                                                   ) { ClassBase::property(name, static_cast<getter_callback_0>(getter)); return *this; }
+    Class<T> &property(const char *name, Value (T::*getter)() const                                             ) { ClassBase::property(name, static_cast<getter_callback_1>(getter)); return *this; }
+    Class<T> &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)); return *this; }
+    Class<T> &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)); return *this; }
+    Class<T> &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)); return *this; }
+    Class<T> &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)); return *this; }
     
 private:
     /**
diff --git a/include/value.h b/include/value.h
index 36f82af..34ac510 100644
--- a/include/value.h
+++ b/include/value.h
@@ -117,7 +117,7 @@ public:
      *  Wrap around an object implemented by us
      *  @param  object      Object to be wrapped
      */
-    Value(Base *base);
+    Value(const Base *base);
     
     /**
      *  Copy constructor
diff --git a/src/value.cpp b/src/value.cpp
index 9ea9c1a..26c753f 100644
--- a/src/value.cpp
+++ b/src/value.cpp
@@ -173,7 +173,7 @@ Value::Value(struct _zval_struct *val, bool ref)
  *  Wrap around an object
  *  @param  object
  */
-Value::Value(Base *object)
+Value::Value(const Base *object)
 {
     // there are two options: the object was constructed from user space,
     // and is already linked to a handle, or it was constructed from C++