make format

Author: w0lek

vpr/src/server/gateio.cpp

@@ -16,7 +16,7 @@ static ActivityStatus check_client_connection(sockpp::tcp6_acceptor& tcp_server,
     sockpp::inet6_address peer;
     sockpp::tcp6_socket client = tcp_server.accept(&peer);
     if (client) {
-        logger.queue(LogLevel::Info, "client", client.address().to_string() , "connection accepted");
+        logger.queue(LogLevel::Info, "client", client.address().to_string(), "connection accepted");
         client.set_non_blocking(true);
         client_opt = std::move(client);
 
@@ -38,12 +38,12 @@ static ActivityStatus handle_sending_data(sockpp::tcp6_socket& client, std::mute
             if (bytes_sent <= task->orig_reponse_bytes_num()) {
                 task->chop_num_sent_bytes_from_response_buffer(bytes_sent);
                 logger.queue(LogLevel::Detail,
-                            "sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
-                            "from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
-                            "left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
+                             "sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
+                             "from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
+                             "left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
                 status = ActivityStatus::CLIENT_ACTIVITY;
             }
-        } catch(...) {
+        } catch (...) {
             logger.queue(LogLevel::Detail, "error while writing chunk");
             status = ActivityStatus::COMMUNICATION_PROBLEM;
         }
@@ -57,7 +57,7 @@ static ActivityStatus handle_sending_data(sockpp::tcp6_socket& client, std::mute
     std::size_t tasks_num_before_removing = send_tasks.size();
 
     auto partition_iter = std::partition(send_tasks.begin(), send_tasks.end(),
-                                        [](const TaskPtr& task) { return !task->is_response_fully_sent(); });
+                                         [](const TaskPtr& task) { return !task->is_response_fully_sent(); });
     send_tasks.erase(partition_iter, send_tasks.end());
     bool is_removing_took_place = tasks_num_before_removing != send_tasks.size();
     if (!send_tasks.empty() && is_removing_took_place) {
@@ -72,7 +72,7 @@ static ActivityStatus handle_receiving_data(sockpp::tcp6_socket& client, comm::T
     std::size_t bytes_actually_received{0};
     try {
         bytes_actually_received = client.read_n(&received_message[0], CHUNK_MAX_BYTES_NUM);
-    } catch(...) {
+    } catch (...) {
         logger.queue(LogLevel::Error, "fail to receiving");
         status = ActivityStatus::COMMUNICATION_PROBLEM;
     }
@@ -90,7 +90,7 @@ static ActivityStatus handle_telegrams(std::vector<comm::TelegramFramePtr>& tele
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
     telegram_frames.clear();
     telegram_buff.take_telegram_frames(telegram_frames);
-    for (const comm::TelegramFramePtr& telegram_frame: telegram_frames) {
+    for (const comm::TelegramFramePtr& telegram_frame : telegram_frames) {
         // process received data
         std::string message{telegram_frame->body};
         bool is_echo_telegram = false;
@@ -108,7 +108,7 @@ static ActivityStatus handle_telegrams(std::vector<comm::TelegramFramePtr>& tele
             if (job_id_opt && cmd_opt && options_opt) {
                 TaskPtr task = std::make_unique<Task>(job_id_opt.value(), static_cast<comm::CMD>(cmd_opt.value()), options_opt.value());
                 const comm::TelegramHeader& header = telegram_frame->header;
-                logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/true));
+                logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/ true));
                 std::unique_lock<std::mutex> lock(tasks_mutex);
                 received_tasks.push_back(std::move(task));
             } else {
@@ -134,7 +134,7 @@ static ActivityStatus handle_client_alive_tracker(sockpp::tcp6_socket& client, s
                     logger.queue(LogLevel::Detail, "sent", comm::ECHO_TELEGRAM_BODY);
                     client_alive_tracker_ptr->on_echo_sent();
                 }
-            } catch(...) {
+            } catch (...) {
                 logger.queue(LogLevel::Debug, "fail to sent", comm::ECHO_TELEGRAM_BODY);
                 status = ActivityStatus::COMMUNICATION_PROBLEM;
             }
@@ -160,7 +160,6 @@ static void handle_activity_status(ActivityStatus status, std::unique_ptr<Client
     }
 }
 
-
 GateIO::GateIO() {
     m_is_running.store(false);
 }
@@ -189,7 +188,7 @@ void GateIO::stop() {
 
 void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
     std::unique_lock<std::mutex> lock(m_tasks_mutex);
-    for (TaskPtr& task: m_received_tasks) {
+    for (TaskPtr& task : m_received_tasks) {
         m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "for processing");
         tasks.push_back(std::move(task));
     }
@@ -198,7 +197,7 @@ void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
 
 void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
     std::unique_lock<std::mutex> lock(m_tasks_mutex);
-    for (TaskPtr& task: tasks) {
+    for (TaskPtr& task : tasks) {
         m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "finished", (task->has_error() ? "with error" : "successfully"), task->error(), "to send queue");
         m_send_tasks.push_back(std::move(task));
     }
@@ -208,7 +207,7 @@ void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
 void GateIO::start_listening() {
 #ifdef ENABLE_CLIENT_ALIVE_TRACKER
     std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr =
-         std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
+        std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
 #else
     std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr;
 #endif
@@ -232,7 +231,7 @@ void GateIO::start_listening() {
     received_message.resize(CHUNK_MAX_BYTES_NUM);
 
     /// comm event loop
-    while(m_is_running.load()) {
+    while (m_is_running.load()) {
         bool is_communication_problem_detected = false;
 
         if (!client_opt) {
@@ -262,7 +261,7 @@ void GateIO::start_listening() {
             // forward telegramBuffer errors
             std::vector<std::string> telegram_buffer_errors;
             telegram_buff.take_errors(telegram_buffer_errors);
-            for (const std::string& error: telegram_buffer_errors) {
+            for (const std::string& error : telegram_buffer_errors) {
                 m_logger.queue(LogLevel::Info, error);
             }
 

vpr/src/server/gateio.h

@@ -25,16 +25,16 @@ enum class ActivityStatus : int {
     COMMUNICATION_PROBLEM
 };
 
-enum class LogLevel: int {
+enum class LogLevel : int {
     Error,
     Info,
     Detail,
     Debug
 };
 
-const std::size_t CHUNK_MAX_BYTES_NUM = 2*1024*1024; // 2Mb
+const std::size_t CHUNK_MAX_BYTES_NUM = 2 * 1024 * 1024; // 2Mb
 
- /**
+/**
  * @brief Helper class aimed to help detecting a client offline.
  *
  * The ClientAliveTracker is pinged each time there is some activity from the client side.
@@ -44,12 +44,13 @@ const std::size_t CHUNK_MAX_BYTES_NUM = 2*1024*1024; // 2Mb
  * and it's time to start accepting new client connections in GateIO.
  */
 class ClientAliveTracker {
-public:
+  public:
     ClientAliveTracker(const std::chrono::milliseconds& echoIntervalMs, const std::chrono::milliseconds& clientTimeoutMs)
-        : m_echo_interval_ms(echoIntervalMs), m_client_timeout_ms(clientTimeoutMs) {
+        : m_echo_interval_ms(echoIntervalMs)
+        , m_client_timeout_ms(clientTimeoutMs) {
         reset();
     }
-    ClientAliveTracker()=default;
+    ClientAliveTracker() = default;
 
     void on_client_activity() {
         m_last_client_activity_time = std::chrono::high_resolution_clock::now();
@@ -62,13 +63,13 @@ class ClientAliveTracker {
     bool is_time_to_sent_echo() const {
         return (duration_since_last_client_activity_ms() > m_echo_interval_ms) && (durationSinceLastEchoSentMs() > m_echo_interval_ms);
     }
-    bool is_client_timeout() const  { return duration_since_last_client_activity_ms() > m_client_timeout_ms; }
+    bool is_client_timeout() const { return duration_since_last_client_activity_ms() > m_client_timeout_ms; }
 
     void reset() {
         on_client_activity();
     }
 
-private:
+  private:
     std::chrono::high_resolution_clock::time_point m_last_client_activity_time;
     std::chrono::high_resolution_clock::time_point m_last_echo_sent_time;
     std::chrono::milliseconds m_echo_interval_ms;
@@ -84,10 +85,8 @@ class ClientAliveTracker {
     }
 };
 
-
-
 class TLogger {
-public:
+  public:
     TLogger() {
         m_log_level = static_cast<int>(LogLevel::Info);
     }
@@ -113,7 +112,7 @@ class TLogger {
         }
     }
 
-private:
+  private:
     std::stringstream m_log_stream;
     std::mutex m_log_stream_mutex;
     std::atomic<int> m_log_level;
@@ -135,12 +134,11 @@ class TLogger {
  *   and responsiveness of the application.
  * - GateIO is not started automatically upon creation, you have to use the 'start' method with the port number.
  * - The socket is initialized in a non-blocking mode to function properly in a multithreaded environment.
-*/
-class GateIO
-{
+ */
+class GateIO {
     const int LOOP_INTERVAL_MS = 100;
 
-public:
+  public:
     /**
      * @brief Default constructor for GateIO.
      */
@@ -154,10 +152,10 @@ class GateIO
     GateIO& operator=(GateIO&&) = delete;
 
     /**
-    * @brief Returns a bool indicating whether or not the port listening process is currently running.
-    *
-    * @return True if the port listening process is running, false otherwise.
-    */
+     * @brief Returns a bool indicating whether or not the port listening process is currently running.
+     *
+     * @return True if the port listening process is running, false otherwise.
+     */
     bool is_running() const { return m_is_running.load(); }
 
     /**
@@ -178,7 +176,7 @@ class GateIO
      * remains empty after the operation.
      * 
      * @param tasks A reference to a vector containing the tasks to be moved to the send queue.
-    */
+     */
     void move_tasks_to_send_queue(std::vector<TaskPtr>& tasks);
 
     /**
@@ -187,7 +185,7 @@ class GateIO
      * @note Must be called from the main thread since it's invoke std::cout.
      * Calling this method from other threads may result in unexpected behavior.
      */
-    void print_logs(); 
+    void print_logs();
 
     /**
      * @brief Starts the server on the specified port number.
@@ -210,16 +208,16 @@ class GateIO
      */
     void stop();
 
-private:
+  private:
     int m_port_num = -1;
 
     std::atomic<bool> m_is_running; // is true when started
 
     std::thread m_thread; // thread to execute socket IO work
 
-    std::mutex m_tasks_mutex; // we used single mutex to guard both vectors m_received_tasks and m_sendTasks
+    std::mutex m_tasks_mutex;              // we used single mutex to guard both vectors m_received_tasks and m_sendTasks
     std::vector<TaskPtr> m_received_tasks; // tasks from client (requests)
-    std::vector<TaskPtr> m_send_tasks; // tasks to client (responses)
+    std::vector<TaskPtr> m_send_tasks;     // tasks to client (responses)
 
     TLogger m_logger;
 
@@ -231,4 +229,3 @@ class GateIO
 #endif /* NO_SERVER */
 
 #endif /* GATEIO_H */
-