another rename to Socket callbacks

ice-server/src/IceServer.cpp

@@ -36,10 +36,10 @@ IceServer::IceServer(int argc, char* argv[]) :
 
     // set processPacket as the verified packet callback for the udt::Socket
     using std::placeholders::_1;
-    _serverSocket.setVerifiedPacketHandler(std::bind(&IceServer::processPacket, this, _1));
+    _serverSocket.setPacketHandler(std::bind(&IceServer::processPacket, this, _1));
     
     // set packetVersionMatch as the verify packet operator for the udt::Socket
-    _serverSocket.setPacketVerificationHandler(std::bind(&IceServer::packetVersionMatch, this, _1));
+    _serverSocket.setPacketFilterOperator(std::bind(&IceServer::packetVersionMatch, this, _1));
 
     // setup our timer to clear inactive peers
     QTimer* inactivePeerTimer = new QTimer(this);

libraries/networking/src/LimitedNodeList.cpp

@@ -99,10 +99,10 @@ LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short
     
     // set &PacketReceiver::handleVerifiedPacket as the verified packet callback for the udt::Socket
     using std::placeholders::_1;
-    _nodeSocket.setVerifiedPacketHandler(std::bind(&PacketReceiver::handleVerifiedPacket, _packetReceiver, _1));
+    _nodeSocket.setPacketHandler(std::bind(&PacketReceiver::handleVerifiedPacket, _packetReceiver, _1));
 
     // set our isPacketVerified method as the verify operator for the udt::Socket
-    _nodeSocket.setPacketVerificationHandler(std::bind(&LimitedNodeList::isPacketVerified, this, _1));
+    _nodeSocket.setPacketFilterOperator(std::bind(&LimitedNodeList::isPacketVerified, this, _1));
     
     _packetStatTimer.start();
     

libraries/networking/src/udt/Socket.cpp

@@ -89,10 +89,10 @@ void Socket::readPendingDatagrams() {
         auto packet = Packet::fromReceivedPacket(std::move(buffer), packetSizeWithHeader, senderSockAddr);
         
         // call our verification operator to see if this packet is verified
-        if (_unfilteredSockAddrs.contains(senderSockAddr) || !_packetVerificationHandler || _packetVerificationHandler(*packet)) {
+        if (_unfilteredSockAddrs.contains(senderSockAddr) || !_packetFilterOperator || _packetFilterOperator(*packet)) {
-            if (_verifiedPacketHandler) {
+            if (_packetHandler) {
                 // call the verified packet callback to let it handle this packet
-                return _verifiedPacketHandler(std::move(packet));
+                return _packetHandler(std::move(packet));
             }
         }
     }

libraries/networking/src/udt/Socket.h

@@ -24,8 +24,8 @@
 
 namespace udt {
 
-using PacketVerificationHandler = std::function<bool(const Packet&)>;
+using PacketFilterOperator = std::function<bool(const Packet&)>;
-using VerifiedPacketHandler = std::function<void(std::unique_ptr<Packet>)>;
+using PacketHandler = std::function<void(std::unique_ptr<Packet>)>;
 
 class Socket : public QObject {
     Q_OBJECT
@@ -43,8 +43,8 @@ public:
     void bind(const QHostAddress& address, quint16 port = 0) { _udpSocket.bind(address, port); }
     void rebind();
     
-    void setPacketVerificationHandler(PacketVerificationHandler handler) { _packetVerificationHandler = handler; }
+    void setPacketFilterOperator(PacketFilterOperator filterOperator) { _packetFilterOperator = filterOperator; }
-    void setVerifiedPacketHandler(VerifiedPacketHandler handler) { _verifiedPacketHandler = handler; }
+    void setPacketHandler(PacketHandler handler) { _packetHandler = handler; }
     
     void setBufferSizes(int numBytes);
     
@@ -55,8 +55,8 @@ private slots:
     
 private:
     QUdpSocket _udpSocket { this };
-    PacketVerificationHandler _packetVerificationHandler;
+    PacketFilterOperator _packetFilterOperator;
-    VerifiedPacketHandler _verifiedPacketHandler;
+    PacketHandler _packetHandler;
     
     QSet<HifiSockAddr> _unfilteredSockAddrs;
 };