EventManager.h
/********************************************************************************
* Copyright (C) 2014-2017 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
* *
* This software is distributed under the terms of the *
* GNU Lesser General Public Licence (LGPL) version 3, *
* copied verbatim in the file "LICENSE" *
********************************************************************************/
#ifndef FAIR_MQ_EVENTMANAGER_H
#define FAIR_MQ_EVENTMANAGER_H
#include <memory>
#include <mutex>
#include <string>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include <vector>
#include <boost/any.hpp>
#include <boost/functional/hash.hpp>
#include <boost/signals2.hpp>
namespace fair
{
namespace mq
{
// Inherit from this base event type to create custom event types
template<typename K>
struct Event
{
using KeyType = K;
};
class EventManager
{
public:
// Clang 3.4-3.8 has a bug and cannot properly deal with the following template alias.
// Therefore, we leave them here commented out for now.
// template<typename E, typename ...Args>
// using Callback = std::function<void(typename E::KeyType, Args...)>;
template<typename E, typename ...Args>
using Signal = boost::signals2::signal<void(typename E::KeyType, Args...)>;
template<typename E, typename ...Args>
auto Subscribe(const std::string& subscriber, std::function<void(typename E::KeyType, Args...)> callback) -> void
{
const std::type_index event_type_index{typeid(E)};
const std::type_index callback_type_index{typeid(std::function<void(typename E::KeyType, Args...)>)};
const auto signalsKey = std::make_pair(event_type_index, callback_type_index);
const auto connectionsKey = std::make_pair(subscriber, signalsKey);
const auto connection = GetSignal<E, Args...>(signalsKey)->connect(callback);
{
std::lock_guard<std::mutex> lock{fMutex};
if (fConnections.find(connectionsKey) != fConnections.end())
{
fConnections.at(connectionsKey).disconnect();
fConnections.erase(connectionsKey);
}
fConnections.insert({connectionsKey, connection});
}
}
template<typename E, typename ...Args>
auto Unsubscribe(const std::string& subscriber) -> void
{
const std::type_index event_type_index{typeid(E)};
const std::type_index callback_type_index{typeid(std::function<void(typename E::KeyType, Args...)>)};
const auto signalsKey = std::make_pair(event_type_index, callback_type_index);
const auto connectionsKey = std::make_pair(subscriber, signalsKey);
std::lock_guard<std::mutex> lock{fMutex};
fConnections.at(connectionsKey).disconnect();
fConnections.erase(connectionsKey);
}
template<typename E, typename ...Args>
auto Emit(typename E::KeyType key, Args... args) const -> void
{
const std::type_index event_type_index{typeid(E)};
const std::type_index callback_type_index{typeid(std::function<void(typename E::KeyType, Args...)>)};
const auto signalsKey = std::make_pair(event_type_index, callback_type_index);
(*GetSignal<E, Args...>(signalsKey))(key, std::forward<Args>(args)...);
}
private:
using SignalsKey = std::pair<std::type_index, std::type_index>;
// event , callback
using SignalsValue = boost::any;
using SignalsMap = std::unordered_map<SignalsKey, SignalsValue, boost::hash<SignalsKey>>;
mutable SignalsMap fSignals;
using ConnectionsKey = std::pair<std::string, SignalsKey>;
// subscriber , event/callback
using ConnectionsValue = boost::signals2::connection;
using ConnectionsMap = std::unordered_map<ConnectionsKey, ConnectionsValue, boost::hash<ConnectionsKey>>;
ConnectionsMap fConnections;
mutable std::mutex fMutex;
template<typename E, typename ...Args>
auto GetSignal(const SignalsKey& key) const -> std::shared_ptr<Signal<E, Args...>>
{
std::lock_guard<std::mutex> lock{fMutex};
if (fSignals.find(key) == fSignals.end())
{
// wrapper is needed because boost::signals2::signal is neither copyable nor movable
// and I don't know how else to insert it into the map
auto signal = std::make_shared<Signal<E, Args...>>();
fSignals.insert(std::make_pair(key, signal));
}
return boost::any_cast<std::shared_ptr<Signal<E, Args...>>>(fSignals.at(key));
}
}; /* class EventManager */
} /* namespace mq */
} /* namespace fair */
#endif /* FAIR_MQ_EVENTMANAGER_H */
fair::mq::Event
Definition: EventManager.h:33
fair::mq::EventManager
Manages event callbacks from different subscribers.
Definition: EventManager.h:53
fair
Tools for interfacing containers to the transport via polymorphic allocators.
Definition: DeviceRunner.h:23

privacy