I spent some time to modernize the implementation of callbacks by using C++11 std::function. Here is the result:

https://github.com/stavallo/ns-3-dev-git/commits/callbacks

My goals were to:

- make the code in callback.h more readable and compact
- allow the creation of callbacks pointing to lambdas and objects returned by std::bind
- remove the limitation on 3 bound parameters

The overall design is mostly untouched. Instead of having a CallbackImpl<> class and 5 subclasses, we have a single CallbackImpl<> class that stores any kind of callable objects as a std::function. Given that std::function objects cannot be compared, I thought that CallbackImpl<> could also keep a vector of callback "components": the original function and every bound argument. Callbacks are compared by comparing such components one by one. Partial specialization of the CallbackComponent class enables to avoid the comparison of lambdas (not allowed by compilers) and always return false.

Still, it is possible to check when two callbacks point to the *same* lambda. The traced-callback test has been modified to show that this can be done by simply storing a CallbackBase object (slicing works because the implementation is kept).

I borrowed the changes to traced-callback.h from Alexander's patch attached to bug 2457. Apart from three nasty attempts at casting 0 to a Callback, no other changes are required. Changes to the tests are mainly additions to showcase what can be done with callbacks.

All the tests and examples run fine, I verified that there are no memory leaks and I also successfully scanned the python bindings.

The C++11 version of the patch compiles fine on MacOS and on Linux with g++ >= 5 (see below).

Given that this patch and others make use of variadic templates, I think it may be useful to switch to C++14 by default. We may then exploit:

- auto deduction of function return types
- generation of compile time integer sequences and other helpers such as enable_if_t, remove_pointer_t, etc.
- generic lambdas

The C++14 version of the patch ("core: Make use of C++14 features") exploits the first two features of the list above. C++14 is supported by clang 3.4 [1] and by g++ 4.9/5 [2]. From my tests, the C++14 version of my patch compiles fine even with g++ 4.9. Thus, if we switch to C++14, there is no need to increase the requirement on the minimum version of g++.


[1] https://clang.llvm.org/cxx_status.html
[2] https://gcc.gnu.org/projects/cxx-status.html#cxx14