91 lines
3.3 KiB
C++
91 lines
3.3 KiB
C++
/// @file Connection.hpp
|
|
/// @description Callback handler for event connections
|
|
/// @author Josh O'Leary - Redacted Software
|
|
/// @revision 3
|
|
/// @lastedit 2024-02-21
|
|
/// @license Unlicense - Public Domain
|
|
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <functional>
|
|
#include <memory>
|
|
|
|
/// A delegate can be any function object or function-like object. The Args are the arguments accepted by that object
|
|
template <typename delegate, typename ... Args>
|
|
class BasicEvent {
|
|
public:
|
|
/// A type that represents a handle to an active event connection.
|
|
class Connection {
|
|
public:
|
|
Connection(BasicEvent<delegate, Args...> *creator, delegate cb);
|
|
bool Disconnect(); // Breaks the event connection, but does not destroy the instance
|
|
// If improperly used could lead to run away events? - Maxine
|
|
void Invoke(Args... e);
|
|
public:
|
|
// This is made public in the case of function-like objects which store extra data.
|
|
// This allows us to access members of the object when desired. See JTest's usage of the event system for an example.
|
|
delegate callback;
|
|
private:
|
|
BasicEvent<delegate, Args...> *owner;
|
|
bool active = true;
|
|
};
|
|
|
|
using EventPtr = std::shared_ptr<Connection>;
|
|
public:
|
|
// See JTest Unit for why making this virtual is convenient
|
|
virtual void Invoke(Args... args);
|
|
void operator()(Args... args);
|
|
Connection Connect(delegate callback);
|
|
void Disconnect(Connection &conn);
|
|
Connection operator+=(delegate callback);
|
|
protected:
|
|
std::vector<EventPtr> listeners;
|
|
};
|
|
|
|
template<typename delegate, typename... Args>
|
|
BasicEvent<delegate, Args...>::Connection::Connection(BasicEvent<delegate, Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}
|
|
|
|
template <typename delegate, typename... Args>
|
|
void BasicEvent<delegate, Args...>::Connection::Invoke(Args... e) { callback(e...); }
|
|
|
|
template <typename delegate, typename ... Args>
|
|
bool BasicEvent<delegate, Args...>::Connection::Disconnect() {
|
|
if (active) {
|
|
owner->Disconnect(this);
|
|
active = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename delegate, typename... Args>
|
|
BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::operator+=(delegate callback) { return Connect(callback); }
|
|
|
|
template<typename delegate, typename... Args>
|
|
void BasicEvent<delegate, Args...>::operator()(Args... args) { Invoke(args...); }
|
|
|
|
template <typename delegate, typename ... Args>
|
|
void BasicEvent<delegate, Args...>::Invoke(Args... args) {
|
|
for (EventPtr &connection_ptr: this->listeners) {
|
|
connection_ptr->Invoke(args...);
|
|
}
|
|
}
|
|
|
|
template <typename delegate, typename ... Args>
|
|
BasicEvent<delegate, Args...>::Connection BasicEvent<delegate, Args...>::Connect(delegate callback) {
|
|
EventPtr retval(new Connection(this, callback));
|
|
this->listeners.push_back(retval);
|
|
return *retval;
|
|
}
|
|
|
|
template <typename delegate, typename ... Args>
|
|
void BasicEvent<delegate, Args...>::Disconnect(BasicEvent<delegate, Args...>::Connection &conn) {
|
|
listeners.erase(std::remove(listeners.begin(), listeners.end(), 99), listeners.end());
|
|
}
|
|
|
|
/// Event is a generic event type. It is more often we will be using a void function rather than a function-like object.
|
|
template <typename ... Args>
|
|
using Event = BasicEvent<std::function<void(Args...)>, Args...>;
|
|
|