hook.hpp

#ifndef HOOK_HPP_RNAM6XF4
#define HOOK_HPP_RNAM6XF4
 
#include <functional>
#include <utility>
 
namespace vanetza
{
 
/**
 * Hook mechanism for realising extension points
 */
template<typename... Args>
class Hook
{
public:
    typedef std::function<void(Args...)> callback_type;
 
    /**
     * Assign a callback to hook, replaces previously assigned one
     * \param cb A callable used as hook callback, e.g. lambda
     */
    void operator=(callback_type&& cb)
    {
        m_function = std::move(cb);
    }
 
    void operator=(const callback_type& cb)
    {
        m_function = cb;
    }
 
    /**
     * Execute hook callback if assigned
     * \param Args... various arguments passed to assigned callback
     */
    void operator()(Args... args)
    {
        if (m_function) {
            // that's an arcane syntax, isn't it?
            m_function(std::forward<Args>(args)...);
        }
    }
 
    /**
     * Reset previously assigned callback.
     * No callback will be invoked when triggering hook after reset.
     */
    void reset()
    {
        m_function = nullptr;
    }
 
    /**
     * \deprecated previous name of reset
     */
    void clear() { reset(); }
 
private:
    callback_type m_function;
};
 
/**
 * Hook registry (non-callable view of a hook)
 *
 * Callbacks can be assigned to a hook via the corresponding registry,
 * but the callback cannot be invoked through the registry.
 */
template<typename... Args>
class HookRegistry
{
public:
    using hook_type = Hook<Args...>;
    using callback_type = typename hook_type::callback_type;
 
    HookRegistry(hook_type& hook) : m_hook(hook) {}
 
    void operator=(callback_type&& cb)
    {
        m_hook = std::move(cb);
    }
 
    void operator=(const callback_type& cb)
    {
        m_hook = cb;
    }
 
    void reset()
    {
        m_hook.reset();
    }
 
private:
    hook_type& m_hook;
};
 
} // namespace vanetza
 
#endif /* HOOK_HPP_RNAM6XF4 */