+}
+
+
+Event::Event(EventManager::EventType type, QVariantMap &map)
+ : _type(type)
+ , _valid(true)
+{
+ if (!map.contains("flags") || !map.contains("timestamp")) {
+ qWarning() << "Received invalid serialized event:" << map;
+ setValid(false);
+ return;
+ }
+
+ Q_ASSERT(SignalProxy::current());
+ Q_ASSERT(SignalProxy::current()->sourcePeer());
+
+ setFlags(static_cast<EventManager::EventFlags>(map.take("flags").toInt())); // TODO sanity check?
+
+ if (SignalProxy::current()->sourcePeer()->hasFeature(Quassel::Feature::LongTime)) {
+ // timestamp is a qint64, signed rather than unsigned
+ setTimestamp(QDateTime::fromMSecsSinceEpoch(map.take("timestamp").toLongLong()));
+ } else {
+ setTimestamp(QDateTime::fromTime_t(map.take("timestamp").toUInt()));
+ }
+}
+
+
+void Event::toVariantMap(QVariantMap &map) const
+{
+ Q_ASSERT(SignalProxy::current());
+ Q_ASSERT(SignalProxy::current()->targetPeer());
+
+ map["type"] = static_cast<int>(type());
+ map["flags"] = static_cast<int>(flags());
+ if (SignalProxy::current()->targetPeer()->hasFeature(Quassel::Feature::LongTime)) {
+ // toMSecs returns a qint64, signed rather than unsigned
+ map["timestamp"] = timestamp().toMSecsSinceEpoch();
+ } else {
+ map["timestamp"] = timestamp().toTime_t();
+ }
+}
+
+
+QVariantMap Event::toVariantMap() const
+{
+ QVariantMap map;
+ toVariantMap(map);
+ return map;
+}
+
+
+Event *Event::fromVariantMap(QVariantMap &map, Network *network)
+{
+ int inttype = map.take("type").toInt();
+ // sanity check if we have a valid enum value
+ if (EventManager::enumName(inttype).isEmpty()) {
+ qWarning() << "Received a serialized event with unknown type" << inttype;
+ return 0;
+ }
+
+ EventManager::EventType type = static_cast<EventManager::EventType>(inttype);
+ if (type == EventManager::Invalid || type == EventManager::GenericEvent)
+ return 0;
+
+ EventManager::EventType group = static_cast<EventManager::EventType>(type & EventManager::EventGroupMask);
+
+ Event *e = 0;