[feature] Update libp2p Handler

frstrtr · Feb 17, 2024 · 62eecde · 62eecde
1 parent 5eed88c
commit 62eecde
Show file tree

Hide file tree

Showing 2 changed files with 28 additions and 33 deletions.
diff --git a/libp2p/handler.h b/libp2p/handler.h
@@ -9,77 +9,77 @@
 #include "message.h"
 #include <libdevcore/stream.h>
 
+// От этого класса должен наследоваться любой класс, который собирается принимать сообщения.
+class NetworkHandler
+{
+};
+
 template <typename MessageType, typename ProtocolType>
 using handler_type = std::function<void(std::shared_ptr<MessageType>, ProtocolType*)>;
 
-template <typename ProtocolType>
 class Handler
 {
 public:
-    virtual void invoke(PackStream &stream, ProtocolType* _protocol) = 0;
+    virtual void invoke(PackStream &stream, NetworkHandler* protocol_) = 0;
 };
 
 template <typename MessageType, typename ProtocolType>
-class MessageHandler : public Handler<ProtocolType>
+class MessageHandler : public Handler
 {
 protected:
-    handler_type<MessageType, ProtocolType> handlerF;
+    handler_type<MessageType, ProtocolType> handler;
 
     std::shared_ptr<MessageType> generate_message(PackStream &stream)
     {
-        std::shared_ptr<MessageType> msg = std::make_shared<MessageType>();
-
         LOG_DEBUG_P2P << "\tMessage data: " << stream;
-
+
+        std::shared_ptr<MessageType> msg = std::make_shared<MessageType>();
         stream >> *msg;
         return msg;
     }
 
 public:
-    MessageHandler(handler_type<MessageType, ProtocolType> _handlerF) : handlerF(_handlerF) {}
+    MessageHandler(handler_type<MessageType, ProtocolType> handler_) : handler(handler_) {}
 
-    void invoke(PackStream &stream, ProtocolType* _protocol) override
+    void invoke(PackStream &stream, NetworkHandler* protocol_) override
     {
         auto msg = generate_message(stream);
-//        auto protocol = std::static_pointer_cast<ProtocolType>(_protocol);
-        handlerF(msg, _protocol);
+        handler(msg, static_cast<ProtocolType*>(protocol_));
     }
 };
 
-template <typename ProtocolType>
-using HandlerPtr = std::shared_ptr<Handler<ProtocolType>>;
+using HandlerPtr = std::shared_ptr<Handler>;
 
 template <typename MessageType, typename ProtocolType>
-HandlerPtr<ProtocolType> make_handler(handler_type<MessageType, ProtocolType> handlerF)
+HandlerPtr make_handler(handler_type<MessageType, ProtocolType> handler_)
 {
-    HandlerPtr<ProtocolType> handler = std::make_shared<MessageHandler<MessageType, ProtocolType>>(std::move(handlerF));
+    HandlerPtr handler = std::make_shared<MessageHandler<MessageType, ProtocolType>>(std::move(handler_));
     return handler;
 }
 
-template <typename ProtocolType>
 class HandlerManager
 {
 private:
-    std::map<std::string, HandlerPtr<ProtocolType>> handlers;
+    std::map<std::string, HandlerPtr> handlers;
 
 public:
     HandlerManager() = default;
 
     HandlerManager(const HandlerManager& manager) = delete;
 
-    template<typename MessageType>
-    void new_handler(std::string command, handler_type<MessageType, ProtocolType> handlerF)
+    template<typename MessageType, typename ProtocolType>
+    void new_handler(std::string command, handler_type<MessageType, ProtocolType> handler_)
     {
         if (!handlers.count(command))
         {
-            handlers[command] = make_handler<MessageType, ProtocolType>(handlerF);
+            handlers[command] = make_handler<MessageType, ProtocolType>(handler_);
         } else
         {
             // TODO: handler for this command already exist in <handlers> map
         }
     }
 
-    HandlerPtr<ProtocolType> operator[](std::string command)
+    HandlerPtr get_handler(std::string command)
     {
         if (handlers.count(command))
         {
@@ -90,13 +90,6 @@ class HandlerManager
             return nullptr;
         }
     }
-
-    // operator[] for pointers
-    HandlerPtr<ProtocolType> get_handler(std::string command)
-    {
-        return (*this)[command];
-    }
 };
 
-template <typename ProtocolType>
-using HandlerManagerPtr = std::shared_ptr<HandlerManager<ProtocolType>>;
+using HandlerManagerPtr = std::shared_ptr<HandlerManager>;
diff --git a/libp2p/protocol.h b/libp2p/protocol.h
@@ -12,19 +12,21 @@
 #include "protocol_events.h"
 #include "handler.h"
 
-template <typename SocketType, typename ProtocolType, typename... COMPONENTS>
-class BaseProtocol : public ProtocolEvents, public COMPONENTS... 
+template <typename SocketType, typename... COMPONENTS>
+class BaseProtocol : public NetworkHandler, public ProtocolEvents, public COMPONENTS... 
 {
 protected:
 	typedef SocketType socket_type;
-    HandlerManagerPtr<ProtocolType> handler_manager;
+
+    HandlerManagerPtr handler_manager;
 	SocketType* socket;
 
 public:
     virtual void write(std::shared_ptr<Message> msg) = 0;
 
 public:
-    explicit BaseProtocol (socket_type* socket_, HandlerManagerPtr<ProtocolType> handler_manager_) 
+    template <typenames... Args>
+    explicit BaseProtocol (socket_type* socket_, HandlerManagerPtr handler_manager_, Args... args) 
         : socket(socket_), handler_manager(handler_manager_), COMPONENTS(this, std::forward<Args>(args))...
     {
         socket->set_message_handler