registerListenerForTypes optimisations

assignment-client/src/audio/AudioMixer.cpp

@@ -97,13 +97,10 @@ AudioMixer::AudioMixer(NLPacket& packet) :
 
     auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
 
-    QSet<PacketType> nodeAudioPackets {
+    packetReceiver.registerListenerForTypes({ PacketType::MicrophoneAudioNoEcho, PacketType::MicrophoneAudioWithEcho,
-        PacketType::MicrophoneAudioNoEcho, PacketType::MicrophoneAudioWithEcho,
                                               PacketType::InjectAudio, PacketType::SilentAudioFrame,
-        PacketType::AudioStreamStats
+                                              PacketType::AudioStreamStats },
-    };
+                                            this, "handleNodeAudioPacket");
-
-    packetReceiver.registerListenerForTypes(nodeAudioPackets, this, "handleNodeAudioPacket");
     packetReceiver.registerListener(PacketType::MuteEnvironment, this, "handleMuteEnvironmentPacket");
 }
 

interface/src/octree/OctreePacketProcessor.cpp

@@ -19,12 +19,9 @@
 OctreePacketProcessor::OctreePacketProcessor() {
     auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
 
-    QSet<PacketType> types {
+    packetReceiver.registerDirectListenerForTypes({ PacketType::OctreeStats, PacketType::EntityData,
-        PacketType::OctreeStats, PacketType::EntityData,
+                                                    PacketType::EntityErase, PacketType::OctreeStats },
-        PacketType::EntityErase, PacketType::OctreeStats
+                                                  this, "handleOctreePacket");
-    };
-
-    packetReceiver.registerDirectListenerForTypes(types, this, "handleOctreePacket");
 }
 
 void OctreePacketProcessor::handleOctreePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {

libraries/networking/src/PacketReceiver.cpp

@@ -19,48 +19,47 @@
 #include "NodeList.h"
 #include "SharedUtil.h"
 
-PacketReceiver::PacketReceiver(QObject* parent) :
+PacketReceiver::PacketReceiver(QObject* parent) : QObject(parent) {
-    QObject(parent),
-    _packetListenerMap()
-{
     qRegisterMetaType<QSharedPointer<NLPacket>>();
 }
 
-bool PacketReceiver::registerListenerForTypes(const QSet<PacketType>& types, QObject* listener, const char* slot) {
+bool PacketReceiver::registerListenerForTypes(PacketTypeList types, QObject* listener, const char* slot) {
-    QSet<PacketType> nonSourcedTypes;
+    Q_ASSERT_X(!types.empty(), "PacketReceiver::registerListenerForTypes", "No types to register");
-    QSet<PacketType> sourcedTypes;
+    Q_ASSERT_X(listener, "PacketReceiver::registerListenerForTypes", "No object to register");
+    Q_ASSERT_X(slot, "PacketReceiver::registerListenerForTypes", "No slot to register");
     
-    foreach(PacketType type, types) {
+    // Partition types based on whether they are sourced or not (non sourced in front)
-        if (NON_SOURCED_PACKETS.contains(type)) {
+    auto middle = std::partition(std::begin(types), std::end(types), [](PacketType type) {
-            nonSourcedTypes << type;
+        return NON_SOURCED_PACKETS.contains(type);
-        } else {
+    });
-            sourcedTypes << type;
+    
+    QMetaMethod nonSourcedMethod, sourcedMethod;
+    
+    // Check we have a valid method for non sourced types if any
+    if (middle != std::begin(types)) {
+        nonSourcedMethod = matchingMethodForListener(*std::begin(types), listener, slot);
+        if (!nonSourcedMethod.isValid()) {
+            return false;
         }
     }
     
-    Q_ASSERT(listener);
+    // Check we have a valid method for sourced types if any
+    if (middle != std::end(types)) {
+        sourcedMethod = matchingMethodForListener(*middle, listener, slot);
+        if (!sourcedMethod.isValid()) {
+            return false;
+        }
+    }
     
-    if (nonSourcedTypes.size() > 0) {
+    // Register non sourced types
-        QMetaMethod nonSourcedMethod = matchingMethodForListener(*nonSourcedTypes.begin(), listener, slot);
+    std::for_each(std::begin(types), middle, [this, &listener, &nonSourcedMethod](PacketType type) {
-        if (nonSourcedMethod.isValid()) {
-            foreach(PacketType type, nonSourcedTypes) {
         registerVerifiedListener(type, listener, nonSourcedMethod);
-            }
+    });
-        } else {
-            return false;
-        }
-    }
     
-    if (sourcedTypes.size() > 0) {
+    // Register sourced types
-        QMetaMethod sourcedMethod = matchingMethodForListener(*sourcedTypes.begin(), listener, slot);
+    std::for_each(middle, std::end(types), [this, &listener, &sourcedMethod](PacketType type) {
-        if (sourcedMethod.isValid()) {
-            foreach(PacketType type, sourcedTypes) {
         registerVerifiedListener(type, listener, sourcedMethod);
-            }
+    });
-        } else {
-            return false;
-        }
-    }
     
     return true;
 }
@@ -77,10 +76,10 @@ void PacketReceiver::registerDirectListener(PacketType type, QObject* listener,
     }
 }
 
-void PacketReceiver::registerDirectListenerForTypes(const QSet<PacketType>& types,
+void PacketReceiver::registerDirectListenerForTypes(PacketTypeList types,
                                                     QObject* listener, const char* slot) {
     // just call register listener for types to start
-    bool success = registerListenerForTypes(types, listener, slot);
+    bool success = registerListenerForTypes(std::move(types), listener, slot);
     if (success) {
         _directConnectSetMutex.lock();
         

libraries/networking/src/PacketReceiver.h

@@ -13,6 +13,8 @@
 #ifndef hifi_PacketReceiver_h
 #define hifi_PacketReceiver_h
 
+#include <vector>
+
 #include <QtCore/QMap>
 #include <QtCore/QMetaMethod>
 #include <QtCore/QMutex>
@@ -30,6 +32,8 @@ class OctreePacketProcessor;
 class PacketReceiver : public QObject {
     Q_OBJECT
 public:
+    using PacketTypeList = std::vector<PacketType>;
+    
     PacketReceiver(QObject* parent = 0);
     PacketReceiver(const PacketReceiver&) = delete;
 
@@ -42,8 +46,8 @@ public:
     
     void resetCounters() { _inPacketCount = 0; _inByteCount = 0; }
 
-    bool registerListenerForTypes(const QSet<PacketType>& types, QObject* listener, const char* slot);
+    bool registerListenerForTypes(PacketTypeList types, QObject* listener, const char* slot);
-    bool registerMessageListener(PacketType types, QObject* listener, const char* slot);
+    bool registerMessageListener(PacketType type, QObject* listener, const char* slot);
     bool registerListener(PacketType type, QObject* listener, const char* slot);
     void unregisterListener(QObject* listener);
     
@@ -56,7 +60,7 @@ signals:
 private:
     // these are brutal hacks for now - ideally GenericThread / ReceivedPacketProcessor
     // should be changed to have a true event loop and be able to handle our QMetaMethod::invoke
-    void registerDirectListenerForTypes(const QSet<PacketType>& types, QObject* listener, const char* slot);
+    void registerDirectListenerForTypes(PacketTypeList types, QObject* listener, const char* slot);
     void registerDirectListener(PacketType type, QObject* listener, const char* slot);
 
     QMetaMethod matchingMethodForListener(PacketType type, QObject* object, const char* slot) const;