Event.hpp

/*
 * Copyright (C) 2020 Alexander Kornilov (akornilov.82@gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef CPP_MATE_EVENT_HPP
#define CPP_MATE_EVENT_HPP
 
#include <CppMate/Checkers.hpp>
 
#include <unordered_set>
#include <memory>
#include <functional>
 
namespace CppMate {
 
template<typename E, typename S>
class Event final
{
public:
 
    using Function = void(*)(const S&, const E&);
 
    using Lambda = std::function<void(const S& sender, const E& event)>;
 
    Event(const S& sender): _sender(sender) {}
 
    template<typename T>
    inline void subscribe(const T& instance, void (T::* method)(const S&, const E&)) const {
        addReceiver(&instance, *reinterpret_cast<Method*>(&method));
    }
 
    template<typename T>
    inline void subscribe(std::shared_ptr<T> instance, void (T::* method)(const S&, const E&)) const {
        checkArg(instance.get());
        addReceiver(std::weak_ptr<void>(instance), *reinterpret_cast<Method*>(&method));
    }
 
    void subscribe(Function subscriber) const { addReceiver(subscriber); }
 
    void subscribe(Lambda subscriber) const { addReceiver(subscriber); }
 
    template<typename T>
    inline bool unsubscribe(const T& instance, void (T::* method)(const S&, const E&)) const {
        return removeReceiver(&instance, *reinterpret_cast<Method*>(&method));
    }
 
    template<typename T>
    inline bool unsubscribe(std::shared_ptr<T> instance, void (T::* method)(const S&, const E&)) const {
        checkArg(instance.get());
        return removeReceiver(std::weak_ptr<void>(instance), *reinterpret_cast<Method*>(&method));
    }
 
    bool unsubscribe(Function subscriber) const { return removeReceiver(subscriber); }
 
    template<typename T>
    inline bool hasSubscriber(const T& instance, void (T::* method)(const S&, const E&)) const {
        return hasReceiver(&instance, *reinterpret_cast<Method*>(&method));
    }
 
    template<typename T>
    inline bool hasSubscriber(std::shared_ptr<T> instance, void (T::* method)(const S&, const E&)) const {
        return instance.get() && hasReceiver(std::weak_ptr<void>(instance), *reinterpret_cast<Method*>(&method));
    }
 
    bool hasSubscriber(Function subscriber) const {
        return subscriber && hasReceiver(subscriber);
    }
 
    bool isEmpty() const { return _receivers.empty(); }
 
    size_t getSubscribersCount() const { return _receivers.size(); }
 
    void emit(const E& event) {
        for (auto it = std::begin(_receivers); it != std::end(_receivers);) {
            const auto& receiver = *it;
            receiver(_sender, event) ? ++it : it = _receivers.erase(it);
        }
    }
 
    void unsubscribeAll() { _receivers.clear(); }
 
private:
    class Receiver;
 
    using Method = void(*)(const void*, const S&, const E&);
 
    struct ReceiverHasher {
        size_t operator()(const Receiver& receiver) const { return receiver.getHash(); }
    };
 
    template<typename... T>
    inline bool hasReceiver(T&&... args) const {
        return _receivers.find(Receiver(std::forward<T>(args)...)) != _receivers.end();
    }
 
    template<typename... T>
    inline void addReceiver(T&&... args) const {
        _receivers.emplace(std::forward<T>(args)...);
    }
 
    template<typename... T>
    inline bool removeReceiver(T&&... args) const {
        return  _receivers.erase(Receiver(std::forward<T>(args)...)) > 0;
    }
 
    const S& _sender;
    mutable std::unordered_set<Receiver, ReceiverHasher> _receivers;
};
 
template<typename E, typename S>
class Event<E, S>::Receiver final
{
public:
    Receiver(const void* instance, Method method):
        _type(Type::Method),
        _instance(instance),
        _method(reinterpret_cast<decltype(_method)>(method)) {}
 
    Receiver(const std::weak_ptr<void>&& instance, Method method):
        _type(Type::Method),
        _instance(nullptr),
        _method(reinterpret_cast<decltype(_method)>(method)),
        _instancePtr(std::move(instance)) {}
 
    Receiver(Function receiver):
        _type(Type::Function),
        _instance(nullptr),
        _method(reinterpret_cast<decltype(_method)>(receiver))
    {
        checkArg(receiver);
    }
 
    Receiver(Lambda receiver):
        _type(Type::Lambda),
        _instance(nullptr),
        _method(nullptr),
        _lambda(std::move(receiver)) {}
 
    bool operator==(const Receiver& other) const {
        return _type == other._type
                    && _method == other._method
                    && getInstance() == other.getInstance();
    }
 
    bool operator!=(const Receiver& other) const { return !(*this == other); }
 
    bool operator()(const S& sender, const E& event) const {
        switch (_type) {
        case Receiver::Type::Method:
            return callMethod(sender, event);
        case Receiver::Type::Function:
            return callFunction(sender, event);
        case Receiver::Type::Lambda:
            return callLambda(sender, event);
        }
        return false;
    }
 
    size_t getHash() const {
        return std::hash<decltype(_type)>{}(_type) ^ std::hash<decltype(_method)>{}(_method) ^ std::hash<decltype(_instance)>{}(getInstance());
    }
 
private:
    enum class Type: uint8_t {
        Method,
        Function,
        Lambda
    };
 
    const void* getInstance() const {
        return _instance ? _instance : _instancePtr.lock().get();
    }
 
    bool callMethod(const S& sender, const E& event) const {
        const auto* instance = getInstance();
        if (!instance) {
            return false;
        }
        reinterpret_cast<Method>(_method)(instance, sender, event);
        return true;
    }
 
    bool callFunction(const S& sender, const E& event) const {
        reinterpret_cast<Function>(_method)(sender, event);
        return true;
    }
 
    bool callLambda(const S& sender, const E& event) const {
        _lambda(sender, event);
        return true;
    }
 
    Type _type;
    const void* _instance;
    std::weak_ptr<void> _instancePtr;
    void* _method;
    Lambda _lambda;
};
 
} // namespace CppMate
 
#endif // CPP_MATE_EVENT_HPP