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