File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/CPP/panda/lib.x/i/panda/CallbackDispatcher.h

Criterion	Covered	Total	%
statement	49	51	96.0
branch	50	94	53.1
condition			n/a
subroutine			n/a
pod			n/a
total	99	145	68.2

#pragma once

#include
#include
#include
#include

namespace panda {

template
class CallbackDispatcher {
public:
    struct Event;
    using RetType = typename optional_tools::type;
    using Callback = function;
    using SimpleCallback = function;

    struct Wrapper {
        Callback real;
        SimpleCallback simple;

        explicit Wrapper(Callback real, SimpleCallback simple = nullptr) : real(real), simple(simple) {}

        template
        auto operator()(RealArgs&&... args) -> decltype(real(args...)) {
            return real(args...);
        }

        bool equal(const Wrapper& oth) {
            if (simple) {
                return simple == oth.simple;
            } else {
                return real == oth.real;
            }
        }

        template ())>
        bool equal(const T& oth) {
            if (simple) {
                return simple == oth;
            } else {
               return false;
            }
        }

        template ())>
        bool equal(const T& oth, Check* = nullptr) {
            return real == oth;
        }
    };

    using CallbackList = lib::owning_list;

    struct Event {
        CallbackDispatcher& dispatcher;
        typename CallbackList::iterator state;

        template
        RetType next(RealArgs&&... args) {
            return dispatcher.next(*this, std::forward(args)...);
        }
    };



    void add(const Callback& callback) {
        if (!callback) {
            return;
        }
        listeners.push_back(Wrapper(callback));
    }

    void add(Callback&& callback) {
        if (!callback) {
            return;
        }
        listeners.push_back(Wrapper(std::forward(callback)));
    }

    void add(const SimpleCallback& callback) {
        if (!callback) {
            return;
        }
        auto wrapper = [callback](Event& e, Args... args) -> RetType {
            callback(std::forward(args)...);
            return e.next(std::forward(args)...);
        };

        static_assert(panda::has_call_operator::value,
                      "argument of CallbackDispatcher::add should be callable with Args..." );

        listeners.push_back(Wrapper(wrapper, callback));
    }

    template
    auto/*RetType*/ operator()(RealArgs&&... args) -> decltype(std::declval()(std::declval(), std::forward(args)...)) {
        auto iter = listeners.begin();
        if (iter == listeners.end()) return optional_tools::default_value();

        Event e{*this, iter};
        return (*iter)(e, std::forward(args)...);
    }

    template
    void remove(const SmthComparable& callback) {
        for (auto iter = listeners.rbegin(); iter != listeners.rend(); ++iter) {
            if (iter->equal(callback)) {
                listeners.erase(iter);
                break;
            }
        }
    }

    template
    void remove_object(T&& makable,
                       decltype(tmp_abstract_function(std::forward(std::declval())))* = nullptr)
    {
        auto tmp = tmp_abstract_function(std::forward(makable));
        remove(tmp);
    }

    template
    void remove_object(T&& makable,
                       decltype(tmp_abstract_function(std::forward(std::declval())))* = nullptr)
    {
        auto tmp = tmp_abstract_function(std::forward(makable));
        remove(tmp);
    }

    void remove_all() {
        listeners.clear();
    }

    bool has_listeners() const {
        return listeners.size();
    }

private:
    template
    RetType next(Event& e, RealArgs&&... args) {
        ++e.state;
        if (e.state != listeners.end()) {
            return (*e.state)(e, std::forward(args)...);
        } else {
            return optional_tools::default_value();
        }
    }

    CallbackList listeners;
};

template
class CallbackDispatcher : public CallbackDispatcher {};

}