update delegation pattern

Author: xiao cheng

CMakeLists.txt

@@ -23,4 +23,5 @@ if(Boost_FOUND)
     add_subdirectory(Adaptor)
     add_subdirectory(Bridge)
     add_subdirectory(Composite)
+    add_subdirectory(Delegation)
 endif()

Delegation/CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.8)
+
+project(Delegation)
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+add_executable(${PROJECT_NAME} Delegate.hpp Dispatcher.hpp FunctionDispatcher.hpp main.cpp Utils.hpp)
+
+target_link_libraries(${PROJECT_NAME} PUBLIC 
+ gtest_main
+ ${Boost_LIBRARIES}
+ )
+
+ add_test(
+     NAME ${PROJECT_NAME}
+     COMMAND ${PROJECT_NAME}
+ )
+ install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ../bin)

Delegation/Delegate.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+
+// instead of passing function pointer, passing wrapper
+template <typename T>
+class Delegate;
+
+template <typename Ret, typename... Args>
+class Delegate<Ret(Args...)>
+{
+    using CallbackType = Ret (*)(std::shared_ptr<void>, Args...);
+
+  public:
+    // object member function
+    template <typename T, Ret (T::*funcPtr)(Args...)>
+    static Delegate create(std::shared_ptr<T> obj)
+    {
+        return Delegate{obj, &memberCaller<T, funcPtr>};
+    }
+
+    template <Ret (*funcPtr)(Args...)>
+    static Delegate create()
+    {
+        // global function has no class, hence it is nullptr
+        return Delegate{nullptr, &globalCaller<funcPtr>};
+    }
+
+    // can be functors, lambdas, std::function objects. 
+    template <typename T>
+    static Delegate create(std::shared_ptr<T> t)
+    {
+        return Delegate{t, &functorCaller<T>};
+    }
+
+    Ret operator()(Args... args)
+    {
+        return callback(callee, args...);
+    }
+
+    bool operator==(const Delegate &other)
+    {
+        return callee == other.callee && callback == other.callback;
+    }
+
+  private:
+    std::shared_ptr<void> callee{nullptr};
+    CallbackType callback{nullptr};
+
+  private:
+    Delegate(std::shared_ptr<void> obj, CallbackType funcPtr) : callee{obj}, callback{funcPtr}
+    {
+    }
+
+    template <typename T, Ret (T::*funcPtr)(Args...)>
+    static Ret memberCaller(std::shared_ptr<void> callee, Args... args)
+    {
+        return (static_cast<T *>(callee.get())->*funcPtr)(args...);
+    }
+
+    template <Ret (*funcPtr)(Args...)>
+    static Ret globalCaller(std::shared_ptr<void>, Args... args)
+    {
+        return funcPtr(args...);
+    }
+
+    template <typename T>
+    static Ret functorCaller(std::shared_ptr<void> functor, Args... args)
+    {
+        return (*static_cast<T *>(functor.get()))(args...);
+    }
+};

Delegation/Dispatcher.hpp

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <vector>
+#include "Delegate.hpp"
+
+template <typename T>
+class Dispatcher;
+
+template <typename Ret, typename... Args>
+class Dispatcher<Ret(Args...)>
+{
+  public:
+    // for global function 
+    template <Ret (*funcPtr)(Args...)>
+    bool add()
+    {
+        return add(Delegate<Ret(Args...)>::template create<funcPtr>());
+    }
+
+    template <Ret (*funcPtr)(Args...)>
+    bool remove()
+    {
+        return remove(Delegate<Ret(Args...)>::template create<funcPtr>());
+    }
+
+    // for class member function
+    template <typename T, Ret (T::*funcPtr)(Args...)>
+    bool add(std::shared_ptr<T> obj)
+    {
+        return add(Delegate<Ret(Args...)>::template create<T, funcPtr>(obj));
+    }
+
+    template <typename T, Ret (T::*funcPtr)(Args...)>
+    bool remove(std::shared_ptr<T> obj)
+    {
+        return remove(Delegate<Ret(Args...)>::template create<T, funcPtr>(obj));
+    }
+
+    // can be functors, lambdas, std::function objects. 
+    template <typename T>
+    bool add(std::shared_ptr<T> t)
+    {
+        return add(Delegate<Ret(Args...)>::template create(t));
+    }
+
+    template <typename T>
+    bool remove(std::shared_ptr<T> t)
+    {
+        return remove(Delegate<Ret(Args...)>::template create(t));
+    }
+
+    void operator()(Args... args)
+    {
+        for (auto &delegate : delegates)
+        {
+            delegate(args...);
+        };
+    }
+
+    bool add(Delegate<Ret(Args...)> delegate)
+    {
+        if (find(delegates.begin(), delegates.end(), delegate) != delegates.end())
+        {
+            return false;
+        }
+
+        delegates.push_back(delegate);
+
+        return true;
+    }
+
+    bool remove(Delegate<Ret(Args...)> delegate)
+    {
+        auto it = find(delegates.begin(), delegates.end(), delegate);
+        if (it == delegates.end())
+        {
+            return false;
+        }
+
+        delegates.erase(it);
+
+        return true;
+    }
+
+  private:
+    std::vector<Delegate<Ret(Args...)>> delegates;
+};

Delegation/FunctionDispatcher.hpp

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <memory>
+#include <string>
+#include <vector>
+
+template <size_t>
+struct MyPlaceholder
+{
+};
+
+namespace std
+{
+template <size_t N>
+struct is_placeholder<MyPlaceholder<N>> : public integral_constant<size_t, N>
+{
+};
+} // namespace std
+
+template <typename T>
+class FunctionDispatcher;
+
+template <typename Ret, typename... Args>
+class FunctionDispatcher<Ret(Args...)>
+{
+  public:
+    template <Ret (*funcPtr)(Args...)>
+    bool add(const std::string &tag)
+    {
+        addImpl(tag, funcPtr);
+        return true;
+    }
+
+    template <typename T, Ret (T::*funcPtr)(Args...)>
+    bool add(const std::string &tag, std::shared_ptr<T> obj)
+    {
+        addImpl(tag, bindImpl(obj.get(), funcPtr, std::index_sequence_for<Args...>{}));
+        return true;
+    }
+
+    template <typename T>
+    bool add(const std::string &tag, std::shared_ptr<T> t)
+    {
+        addImpl(tag, *t.get());
+        return true;
+    }
+
+    bool remove(const std::string &tag)
+    {
+        auto it = find(tags.begin(), tags.end(), tag);
+        if (it == tags.end())
+        {
+            return false;
+        }
+
+        auto index{distance(tags.begin(), it)};
+        tags.erase(it);
+
+        delegates.erase(delegates.begin() + index);
+
+        return true;
+    }
+
+    void operator()(Args... args)
+    {
+        for (auto &delegate : delegates)
+        {
+            delegate(args...);
+        };
+    }
+
+  private:
+    bool addImpl(const std::string &tag, std::function<Ret(Args...)> delegate)
+    {
+        if (find(tags.begin(), tags.end(), tag) != tags.end())
+        {
+            return false;
+        }
+
+        delegates.push_back(delegate);
+        tags.push_back(tag);
+
+        return true;
+    }
+
+    template <typename T, size_t... Idx>
+    std::function<Ret(Args...)> bindImpl(T *obj, Ret (T::*funcPtr)(Args...), std::index_sequence<Idx...>)
+    {
+        return std::bind(funcPtr, obj, getPlaceholder<Idx>()...);
+    }
+
+    template <size_t N>
+    MyPlaceholder<N + 1> getPlaceholder()
+    {
+        return {};
+    }
+
+  private:
+    std::vector<std::function<Ret(Args...)>> delegates;
+    std::vector<std::string> tags;
+};

Delegation/Utils.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+template <typename T, typename L = typename std::decay<T>::type>
+std::shared_ptr<L> make_shared_lambda(T &&t)
+{
+    return std::make_shared<L>(std::forward<T>(t));
+}