From 62eecde248bf0fde592becc3686d62b8ab9f27dd Mon Sep 17 00:00:00 2001
From: Neels99 <vasile.danil1@gmail.com>
Date: Sat, 17 Feb 2024 23:33:09 +0300
Subject: [PATCH] [feature] Update libp2p Handler

---
 libp2p/handler.h  | 51 ++++++++++++++++++++---------------------------
 libp2p/protocol.h | 10 ++++++----
 2 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/libp2p/handler.h b/libp2p/handler.h
index 890084de..e4586f31 100644
--- 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>>;
\ No newline at end of file
+using HandlerManagerPtr = std::shared_ptr<HandlerManager>;
\ No newline at end of file
diff --git a/libp2p/protocol.h b/libp2p/protocol.h
index 5fd7d481..efba26b1 100644
--- 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