DhtMessage : introduce Service and ServiceFilter

include/opendht/value.h

@@ -186,7 +186,7 @@ struct Value : public Serializable
         };
     }
 
-    static Filter chainFilters(Filter& f1, Filter& f2) {
+    static Filter chainFilters(Filter&& f1, Filter&& f2) {
         return [f1,f2](const Value& v){
             return f1(v) && f2(v);
         };
@@ -364,26 +364,55 @@ private:
     sockaddr_storage ss;
 };
 
-
 struct DhtMessage : public Serializable
 {
-    DhtMessage(uint16_t s, Blob msg = {}) : service(s), message(msg) {}
+    enum class Service : uint16_t {
+        UNDEFINED = 0,
+        IM_MESSAGE,
+        ICE_CANDIDATES
+    };
+
+    DhtMessage(uint16_t s, Blob msg = {}) : service(static_cast<Service>(s)), message(msg) {}
+    DhtMessage(Service s, Blob msg = {}) : service(s), message(msg) {}
 
     DhtMessage(const Blob& b) {
         unpackBlob(b);
     }
 
+    Service getService() const {
+        return service;
+    }
+
+    const Blob& getMessage() const {
+        return message;
+    }
+
     virtual void pack(Blob& res) const;
     virtual void unpack(Blob::const_iterator& begin, Blob::const_iterator& end);
 
     static const ValueType TYPE;
     static bool storePolicy(InfoHash, std::shared_ptr<Value>&, InfoHash, const sockaddr*, socklen_t);
 
+    static Value::Filter ServiceFilter(Service s) {
+        return Value::chainFilters(
+            Value::TypeFilter(TYPE),
+            [s](const Value& v) {
+                try {
+                    auto b = v.data.cbegin(), e = v.data.cend();
+                    auto service = deserialize<Service>(b, e);
+                    return service == s;
+                } catch (const std::exception& e) {
+                    return false;
+                }
+            }
+        );
+    }
+
     /** print value for debugging */
     friend std::ostream& operator<< (std::ostream&, const DhtMessage&);
 
 private:
-    uint16_t service;
+    Service service;
     Blob message;
 };
 

src/value.cpp

@@ -227,14 +227,14 @@ std::ostream& operator<< (std::ostream& s, const DhtMessage& v)
 void
 DhtMessage::pack(Blob& res) const
 {
-    serialize<int16_t>(service, res);
+    serialize<Service>(service, res);
     serialize<Blob>(message, res);
 }
 
 void
 DhtMessage::unpack(Blob::const_iterator& begin, Blob::const_iterator& end)
 {
-    service = deserialize<int16_t>(begin, end);
+    service = deserialize<Service>(begin, end);
     message = deserialize<Blob>(begin, end);
 }
 
@@ -242,7 +242,7 @@ bool
 DhtMessage::storePolicy(InfoHash, std::shared_ptr<Value>& v, InfoHash, const sockaddr* from, socklen_t fromlen)
 {
     DhtMessage request {v->data};
-    if (request.service == 0)
+    if (request.service == Service::UNDEFINED)
         return false;
     return true;
 }