notifier.hpp

// Copyright 2020 Pokitec
// All rights reserved.
 
#pragma once
 
#include "TTauri/Foundation/required.hpp"
#include <mutex>
#include <vector>
#include <tuple>
#include <functional>
 
namespace tt {
 
template<typename... Args>
class notifier {
public:
    using callback_type = std::function<void(Args const &...)>;
 
private:
    mutable std::recursive_mutex mutex;
    mutable bool executing_callbacks = false;
    size_t counter = 0;
    std::vector<std::pair<size_t,callback_type>> callbacks;
 
public:
    size_t add(callback_type callback) noexcept {
        auto lock = std::scoped_lock(mutex);
        tt_assert(!executing_callbacks);
 
        auto id = ++counter;
        callbacks.emplace_back(id, std::move(callback));
        return id;
    }
 
    size_t add_and_call(callback_type callback, Args const &... args) noexcept {
        auto lock = std::scoped_lock(mutex);
 
        ttlet id = add(callback);
 
        executing_callbacks = true;
        callback(args...);
        executing_callbacks = false;
 
        return id;
    }
 
    void remove(size_t id) noexcept {
        auto lock = std::scoped_lock(mutex);
        tt_assert(!executing_callbacks);
 
        ttlet new_end = std::remove_if(callbacks.begin(), callbacks.end(), [id](ttlet &item) {
            return item.first == id;
        });
        callbacks.erase(new_end, callbacks.cend());
    }
 
    void operator()(Args const &... args) const noexcept {
        auto lock = std::scoped_lock(mutex);
        tt_assert(!executing_callbacks);
 
        executing_callbacks = true;
        for (ttlet &[id, callback] : callbacks) {
            callback(args...);
        }
        executing_callbacks = false;
    }
 
};
 
}