signal.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_SIGNAL_H
#define EGT_SIGNAL_H
 
#include <cstdint>
#include <egt/detail/cow.h>
#include <egt/detail/meta.h>
#include <functional>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
template<typename... Args>
class Signal
{
public:
 
    enum
    {
        INVALID_HANDLE = 0,
    };
 
    using EventCallback = std::function<void(Args...)>;
 
    using RegisterHandle = uint32_t;
 
    RegisterHandle on_event(const EventCallback& handler)
    {
        if (handler)
        {
            // TODO: m_handle_counter can wrap, making the handle non-unique
            auto handle = ++m_handle_counter;
            m_callbacks->emplace_back(handler, handle);
            return handle;
        }
 
        return 0;
    }
 
    inline RegisterHandle operator()(const EventCallback& handler)
    {
        return on_event(handler);
    }
 
    void invoke(Args... args)
    {
        if (!m_enabled)
            return;
 
        if (!m_callbacks)
            return;
 
        for (auto& callback : *m_callbacks)
            callback.callback(args...);
    }
 
    void clear()
    {
        if (!m_callbacks)
            return;
 
        m_callbacks->clear();
    }
 
    void remove(RegisterHandle handle)
    {
        if (!m_callbacks)
            return;
 
        auto i = std::find_if(m_callbacks->begin(), m_callbacks->end(),
                              [handle](const CallbackMeta & meta)
        {
            return meta.handle == handle;
        });
 
        if (i != m_callbacks->end())
            m_callbacks->erase(i);
    }
 
    void disable()
    {
        m_enabled = false;
    }
 
    void enable()
    {
        m_enabled = true;
    }
 
    EGT_NODISCARD bool enabled() const { return m_enabled; }
 
private:
 
    RegisterHandle m_handle_counter{INVALID_HANDLE};
 
    struct CallbackMeta
    {
        CallbackMeta(EventCallback c,
                     RegisterHandle h) noexcept
            : callback(std::move(c)),
              handle(h)
        {}
 
        EventCallback callback;
        RegisterHandle handle{0};
    };
 
    using CallbackArray = std::vector<CallbackMeta>;
 
    detail::CopyOnWriteAllocate<CallbackArray> m_callbacks;
 
    bool m_enabled{true};
};
 
template<typename... Args>
class SignalW
{
public:
 
    enum
    {
        INVALID_HANDLE = 0,
    };
 
    using EventCallback = std::function<void(Args...)>;
 
    using RegisterHandle = uint32_t;
 
    SignalW(Signal<Args...>* src)
    {
        m_src_signal = src;
    }
 
    RegisterHandle on_event(const EventCallback& handler)
    {
        return m_src_signal->on_event(handler);
    }
 
    inline RegisterHandle operator()(const EventCallback& handler)
    {
        return m_src_signal->on_event(handler);
    }
 
    void invoke(Args... args)
    {
        m_src_signal->invoke(args...);
    }
 
    void clear()
    {
        m_src_signal->clear();
    }
 
    void remove(RegisterHandle handle)
    {
        m_src_signal->remove(handle);
    }
 
    void disable()
    {
        m_src_signal->disable();
    }
 
    void enable()
    {
        m_src_signal->enable();
    }
 
    EGT_NODISCARD bool enabled() const
    {
        return m_src_signal->enable();
    }
 
    void set_src_signal(Signal<>* src)
    {
        m_src_signal = src;
    }
 
protected:
    Signal<Args...>* m_src_signal{nullptr};
 
};
 
}
}
 
#endif