update README.md

Author: Simon Ninon

README.md

@@ -24,7 +24,7 @@ In order to enable reflection, we must explicitly "register" our class.
 
 For this, `cpp_reflection` provides a simple macro: `REGISTER_REFLECTABLE(type, list of functions)`.
 * `Type` is the type on which we want to enable reflection
-* `List of functions` is the list of member functions we want to be able to call during reflection.
+* `List of functions` is the list of member functions we want to be able to call during reflection. These functions can have any signature (there is no restriction concerning the return value type, the number of parameters and the types of these parameters).
 
 The list of functions must be formatted in a specific way: `(fct1)(fct2)(fct3)...`.
 This format is the format used by Boost.PP (which is used in this library) and must be respected in order to compile.
@@ -34,11 +34,11 @@ For example, if we have the following class:
 ```cpp
 class SomeClass {
 public:
-    void fct(void) {
+    int fct(void) {
         std::cout << "fct()" << std::endl;
     }
 
-    void other_fct(void) {
+    void other_fct(const std::string&, float) {
         std::cout << "other_fct()" << std::endl;
     }
 };
@@ -49,9 +49,11 @@ We just need to do `REGISTER_REFLECTABLE(SomeClass, (fct)(other_fct))` and this
 ## Making Reflection
 Each time we register a type and its member functions, it stores this type into the `reflection_manager` singleton class.
 
-This class is the class which does the reflection. By calling `reflection_manager::make_reflection("class_name", "function_name")`, this will call `class_name::function_name` (on a new object).
+This class is the class which does the reflection. By calling `reflection_manager::make_reflection<RetVal, Params...>("class_name", "function_name", ...)`, this will call `class_name::function_name` (on a new object).
 
-If we take the previous example, by calling `cpp_reflection::reflection_manager::make_reflection("SomeClass", "fct");`, we will call `SomeClass::fct`.
+A facility function with a more elegant syntax is also provided: `make_reflection<RetVal(Params...)>::call("class_name", "function_name, ...")`. It provides the std::function template syntax which is more readable.
+
+If we take the previous example, by calling `cpp_reflection::make_reflection<void(const std::string&, float)>::call("SomeClass", "other_fct", some_str, some_float);`, we will call `SomeClass::fct`.
 
 # How does it work
 The `REGISTER_REFLECTABLE` macro uses variadic macro parameters and works with Boost.PP in order to iterate through the list of member functions.
@@ -60,10 +62,11 @@ This macro will create a static object of type `reflectable<SomeClass>`.
 For example `REGISTER_REFLECTABLE(SomeClass, (fct)(other_fct))` will generates the following code:
 
 ```cpp
-static reflectable<SomeClass> reflectable_int("SomeClass", {
+static reflectable<SomeClass> reflectable_int(
+    "SomeClass",
     { "fct", &SomeClass::fct },
     { "other_fct", &SomeClass::other_fct }
-});
+);
 ```
 
 This generation is done at compile time but the registration is only effective at runtime at the beginning of the execution. Registering a class for reflection will impact on the compilation time and at program startup (when all static variables are initialized).
@@ -74,25 +77,24 @@ The constructor of a reflectable object registers itself into the reflectable_ma
 ```cpp
 #include <iostream>
 
-#include "cpp_reflection/reflectable.hpp"
-#include "cpp_reflection/reflection_manager.hpp"
+#include "cpp_reflection/cpp_reflection.hpp"
 
 class SomeClass {
 public:
-    void fct(void) {
+    int fct(void) {
         std::cout << "fct()" << std::endl;
     }
 
-    void other_fct(void) {
+    void other_fct(const std::string&, float) {
         std::cout << "other_fct()" << std::endl;
     }
 };
 
 REGISTER_REFLECTABLE(SomeClass, (fct)(other_fct))
 
 int main(void) {
-    cpp_reflection::reflection_manager::make_reflection("SomeClass", "fct");
-    cpp_reflection::reflection_manager::make_reflection("SomeClass", "other_fct");
+    cpp_reflection::make_reflection<int()>::call("SomeClass", "fct");
+    cpp_reflection::make_reflection<void(const std::string&, float)>::call("SomeClass", "other_fct", std::string("hello"), 4.2);
 
     return 0;
 }