109 lines
2.7 KiB
C++
109 lines
2.7 KiB
C++
#pragma once
|
|
|
|
#include <functional>
|
|
#include <list>
|
|
#include <mutex>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
namespace bts {
|
|
namespace utils {
|
|
|
|
template <class T> struct EventSubscriber {
|
|
typedef int Handle;
|
|
typedef std::function<void(const T &)> Callback;
|
|
|
|
EventSubscriber() : _id(0), _subscribers(), _lock() {}
|
|
|
|
Handle subscribe(const Callback &cb) {
|
|
std::lock_guard<std::mutex> l(_lock);
|
|
auto id = ++_id;
|
|
_subscribers.push_back(std::make_tuple(id, cb));
|
|
return id;
|
|
}
|
|
void unsubscribe(Handle h) {
|
|
if (h) {
|
|
std::lock_guard<std::mutex> l(_lock);
|
|
_subscribers.erase(std::remove_if(
|
|
_subscribers.begin(), _subscribers.end(),
|
|
[h](std::tuple<Handle, Callback> &t) {
|
|
return std::get<Handle>(t) == h;
|
|
}));
|
|
}
|
|
}
|
|
|
|
protected:
|
|
void broadcast(const T &item) {
|
|
std::lock_guard<std::mutex> l(_lock);
|
|
for (const auto &t : _subscribers) {
|
|
std::get<Callback>(t)(item);
|
|
}
|
|
}
|
|
|
|
private:
|
|
Handle _id;
|
|
std::list<std::tuple<Handle, Callback>> _subscribers;
|
|
std::mutex _lock;
|
|
};
|
|
|
|
template <class T> struct EventPublisher {
|
|
typedef int Handle;
|
|
virtual void publish(const T &) = 0;
|
|
};
|
|
|
|
template <class T>
|
|
class Event : public EventSubscriber<T>, public EventPublisher<T> {
|
|
|
|
public:
|
|
void publish(const T &item) { this->broadcast(item); }
|
|
};
|
|
|
|
// template <class T>
|
|
// class ReplayEvent {
|
|
// typedef std::function<void(const T&)> Callback;
|
|
// typedef int Handle;
|
|
// Handle _id;
|
|
// std::vector<T> _items;
|
|
// std::list<std::tuple<Handle, Callback>> _subscribers;
|
|
|
|
// void broadcast(const T& item) {
|
|
// for(const auto& t : _subscribers) {
|
|
// std::get<Callback>(t)(item);
|
|
// }
|
|
// }
|
|
|
|
// public:
|
|
// ReplayEvent() :
|
|
// _id(0),
|
|
// _items(),
|
|
// _subscribers() {}
|
|
// ~ReplayEvent() {}
|
|
|
|
// void publish(T&& item) {
|
|
// _items.push_back(move(item));
|
|
// broadcast(_items.back());
|
|
// }
|
|
// void publish(const T& item) {
|
|
// _items.push_back(item);
|
|
// broadcast(item);
|
|
// }
|
|
|
|
// Handle subscribe(Callback& cb) {
|
|
// auto id = ++_id;
|
|
// _subscribers.push_back(std::make_tuple(id, cb));
|
|
// for (const auto& item : _items) {
|
|
// cb(item);
|
|
// }
|
|
// return id;
|
|
// }
|
|
// void unsubscribe(Handle h) {
|
|
// _subscribers.erase(
|
|
// std::remove_if(_subscribers.begin(),
|
|
// _subscribers.end(),
|
|
// [h](std::tuple<Handle,Callback>& t) { return
|
|
// std::get<Handle>(t) == h; }));
|
|
// }
|
|
// };
|
|
|
|
} // namespace utils
|
|
} // namespace bts
|