rework after PR review

Author: StephanKa

src/protobuf.cppzmq/client/main.cpp

@@ -11,41 +11,25 @@ int main()
 
     // construct a REQ (request) socket and connect to interface
     zmq::socket_t socket{ context, zmq::socket_type::req };
-    socket.connect("tcp://localhost:5555");
+    socket.connect("tcp://127.0.0.1:5555");
 
     // set up some static data to send
     const std::string senderName{ "Client" };
-    int32_t pingCount = 0;
-    int32_t pongCount = 0;
 
-    for (;;) {
-        // send the request message
-        own::proto::Event event;
-        event.set_sender(senderName);
-        event.set_action(own::proto::Event::PONG);
-        event.set_ping_count(pingCount);
-        event.set_pong_count(pongCount);
-
-        std::string data;
-        event.SerializeToString(&data);
+    zmq::message_t request{};
+    // send the request message
+    auto [sendEvent, serializedData] = Common::prepareMessage(senderName, request);
 
+    for (;;) {
         // send to the server
-        socket.send(zmq::buffer(data), zmq::send_flags::none);
+        socket.send(zmq::buffer(serializedData), zmq::send_flags::none);
 
         // wait for reply from server
-        zmq::message_t reply{};
-        socket.recv(reply, zmq::recv_flags::none);
-
-        own::proto::Event receivedEvent;
-        receivedEvent.ParseFromArray(reply.data(), static_cast<int>(reply.size()));
-        pingCount = receivedEvent.ping_count();
-        pongCount = receivedEvent.pong_count() + 1;
-
-        spdlog::info("Received from: {} Action: {} Ping count: {} Pong count: {}",
-          receivedEvent.sender(),
-          own::proto::Event_PingPong_Name(receivedEvent.action()),
-          receivedEvent.ping_count(),
-          receivedEvent.pong_count());
+        socket.recv(request, zmq::recv_flags::none);
+        const auto [receivedEvent, _] = Common::prepareMessage(senderName, request);
+        serializedData = Common::incrementPingPong(sendEvent, own::proto::Event::PONG);
+        sendEvent = receivedEvent;
+        Common::logProtoEvent(receivedEvent);
 
         if (receivedEvent.pong_count() == Common::maxCount) { break; }
     }

src/protobuf.cppzmq/common/include/common.h

@@ -1,3 +1,50 @@
+#include <spdlog/spdlog.h>
+#include <zmq.hpp>
+
 namespace Common {
 constexpr auto maxCount = 10;
+
+std::tuple<own::proto::Event, std::string> prepareMessage(const std::string &senderName, const zmq::message_t &request)
+{
+    own::proto::Event receivedEvent{};
+    std::string data;
+    receivedEvent.ParseFromArray(request.data(), static_cast<int>(request.size()));
+
+    own::proto::Event event{};
+    event.set_sender(senderName);
+    event.SerializeToString(&data);
+    return std::make_tuple(receivedEvent, data);
 }
+
+[[nodiscard]]std::string incrementPingPong(own::proto::Event& event, own::proto::Event_PingPong eventType)
+{
+    switch (eventType) {
+    case own::proto::Event::PING: {
+        event.set_action(own::proto::Event::PING);
+        event.set_ping_count(event.ping_count() + 1);
+        event.set_pong_count(event.pong_count());
+    }
+    case own::proto::Event::PONG: {
+        event.set_action(own::proto::Event::PONG);
+        event.set_ping_count(event.ping_count());
+        event.set_pong_count(event.pong_count() + 1);
+        break;
+    }
+    default: {
+        break;
+    }
+    }
+    std::string data;
+    event.SerializeToString(&data);
+    return data;
+}
+
+void logProtoEvent(const own::proto::Event &receivedEvent)
+{
+    spdlog::info("Received from: {} - Action: {} - Ping count: {} - Pong count: {}",
+      receivedEvent.sender(),
+      own::proto::Event_PingPong_Name(receivedEvent.action()),
+      receivedEvent.ping_count(),
+      receivedEvent.pong_count());
+}
+}// namespace Common

src/protobuf.cppzmq/server/main.cpp

@@ -1,9 +1,7 @@
 #include "event.pb.h"
 #include <chrono>
 #include <include/common.h>
-#include <spdlog/spdlog.h>
 #include <thread>
-#include <zmq.hpp>
 
 int main()
 {
@@ -19,33 +17,19 @@ int main()
     // prepare some static data for responses
     const std::string senderName{ "Server" };
 
+    zmq::message_t request{};
     for (;;) {
-        zmq::message_t request;
-
         // receive a request from client
         socket.recv(request, zmq::recv_flags::none);
-        own::proto::Event receivedEvent;
-        receivedEvent.ParseFromArray(request.data(), static_cast<int>(request.size()));
-
         // simulate work
         std::this_thread::sleep_for(500ms);
-        own::proto::Event event;
-        event.set_sender(senderName);
-        event.set_action(own::proto::Event::PING);
-        event.set_ping_count(receivedEvent.ping_count() + 1);
-        event.set_pong_count(receivedEvent.pong_count());
-
-        std::string data;
-        event.SerializeToString(&data);
-
-        // send the reply to the client
-        socket.send(zmq::buffer(data), zmq::send_flags::none);
-
-        spdlog::info("Received from: {} Action: {} Ping count: {} Pong count: {}",
-          receivedEvent.sender(),
-          own::proto::Event_PingPong_Name(receivedEvent.action()),
-          receivedEvent.ping_count(),
-          receivedEvent.pong_count());
+
+        auto [receivedEvent, serializedData] = Common::prepareMessage(senderName, request);
+        serializedData = Common::incrementPingPong(receivedEvent, own::proto::Event::PING);
+        Common::logProtoEvent(receivedEvent);
+
+          // send the reply to the client
+        socket.send(zmq::buffer(serializedData), zmq::send_flags::none);
 
         if (receivedEvent.ping_count() == Common::maxCount) { break; }
     }