Using clang-tidy tool to auto fix style of C++ code

Author: matyhtf

include/swoole_server.h

@@ -1157,7 +1157,7 @@ class Server {
 
     uint32_t get_idle_worker_num();
     int get_idle_task_worker_num();
-    int get_tasking_num();
+    int get_tasking_num() const;
 
     TaskId get_task_id(EventData *task) {
         return gs->task_workers.get_task_id(task);
@@ -1600,7 +1600,7 @@ class Server {
     void worker_start_callback(Worker *worker);
     void worker_stop_callback(Worker *worker);
     void worker_accept_event(DataHead *info);
-    void worker_signal_init(void);
+    void worker_signal_init();
 
     std::function<void(std::shared_ptr<Thread>, const WorkerFn &fn)> worker_thread_start;
 

src/server/base.cc

@@ -20,19 +20,19 @@ namespace swoole {
 
 Factory *Server::create_base_factory() {
     reactor_num = worker_num;
-    connection_list = (Connection *) sw_calloc(max_connection, sizeof(Connection));
+    connection_list = static_cast<Connection *>(sw_calloc(max_connection, sizeof(Connection)));
     if (connection_list == nullptr) {
         swoole_sys_warning("calloc[2](%d) failed", (int) (max_connection * sizeof(Connection)));
         return nullptr;
     }
-    gs->connection_nums = (sw_atomic_t *) sw_shm_calloc(worker_num, sizeof(sw_atomic_t));
+    gs->connection_nums = static_cast<sw_atomic_t *>(sw_shm_calloc(worker_num, sizeof(sw_atomic_t)));
     if (gs->connection_nums == nullptr) {
         swoole_error("sw_shm_calloc(%ld) for gs->connection_nums failed", worker_num * sizeof(sw_atomic_t));
         return nullptr;
     }
 
     for (auto port : ports) {
-        port->gs->connection_nums = (sw_atomic_t *) sw_shm_calloc(worker_num, sizeof(sw_atomic_t));
+        port->gs->connection_nums = static_cast<sw_atomic_t *>(sw_shm_calloc(worker_num, sizeof(sw_atomic_t)));
         if (port->gs->connection_nums == nullptr) {
             swoole_error("sw_shm_calloc(%ld) for port->connection_nums failed", worker_num * sizeof(sw_atomic_t));
             return nullptr;
@@ -53,7 +53,7 @@ void Server::destroy_base_factory() {
 
 BaseFactory::BaseFactory(Server *server) : Factory(server) {}
 
-BaseFactory::~BaseFactory() {}
+BaseFactory::~BaseFactory() = default;
 
 bool BaseFactory::start() {
     return true;
@@ -101,7 +101,7 @@ bool BaseFactory::dispatch(SendData *task) {
  * only stream fd
  */
 bool BaseFactory::notify(DataHead *info) {
-    Connection *conn = server_->get_connection(info->fd);
+    auto conn = server_->get_connection(info->fd);
     if (conn == nullptr || conn->active == 0) {
         swoole_warning("dispatch[type=%d] failed, socket#%ld is not active", info->type, info->fd);
         return false;

src/server/manager.cc

@@ -36,15 +36,14 @@ struct Manager {
     std::vector<pid_t> kill_workers;
 
     void wait(Server *_server);
-    void add_timeout_killer(Worker *workers, int n);
     void terminate_all_worker();
 
     static void signal_handler(int sig);
     static void timer_callback(Timer *timer, TimerNode *tnode);
 };
 
 void Manager::timer_callback(Timer *timer, TimerNode *tnode) {
-    Server *serv = (Server *) tnode->data;
+    auto *serv = (Server *) tnode->data;
     if (serv->isset_hook(Server::HOOK_MANAGER_TIMER)) {
         serv->call_hook(Server::HOOK_MANAGER_TIMER, serv);
     }
@@ -63,7 +62,7 @@ int Server::start_manager_process() {
         return SW_ERR;
     }
 
-    auto fn = [this](void) {
+    auto fn = [this]() {
         gs->manager_pid = SwooleG.pid = getpid();
 
         if (task_worker_num > 0) {
@@ -251,7 +250,7 @@ void Manager::wait(Server *_server) {
                         SW_START_SLEEP;
                         continue;
                     }
-                } while (0);
+                } while (false);
             }
 
             // task worker
@@ -330,8 +329,8 @@ void Manager::wait(Server *_server) {
 void Manager::terminate_all_worker() {
     // clear the timer
     alarm(0);
-    for (auto i = kill_workers.begin(); i != kill_workers.end(); i++) {
-        swoole_kill(*i, SIGKILL);
+    for (int & kill_worker : kill_workers) {
+        swoole_kill(kill_worker, SIGKILL);
     }
 }
 
@@ -374,7 +373,7 @@ void Manager::signal_handler(int signo) {
  * @return: success returns pid, failure returns SW_ERR.
  */
 int Server::wait_other_worker(ProcessPool *pool, const ExitStatus &exit_status) {
-    Server *serv = (Server *) pool->ptr;
+    auto serv = (Server *) pool->ptr;
     Worker *exit_worker = nullptr;
     int worker_type;
 
@@ -396,7 +395,7 @@ int Server::wait_other_worker(ProcessPool *pool, const ExitStatus &exit_status)
             }
         }
         return SW_ERR;
-    } while (0);
+    } while (false);
 
     serv->factory->check_worker_exit_status(exit_worker, exit_status);
 
@@ -426,15 +425,15 @@ void Server::read_worker_message(ProcessPool *pool, EventData *msg) {
         return;
     }
 
-    Server *serv = (Server *) pool->ptr;
+    auto serv = (Server *) pool->ptr;
     int command_id = msg->info.server_fd;
     auto iter = serv->command_handlers.find(command_id);
     if (iter == serv->command_handlers.end()) {
         swoole_error_log(SW_LOG_ERROR, SW_ERROR_SERVER_INVALID_COMMAND, "Unknown command[command_id=%d]", command_id);
         return;
     }
 
-    Server::Command::Handler handler = iter->second;
+    Command::Handler handler = iter->second;
     auto result = handler(serv, std::string(msg->data, msg->info.len));
 
     SendData task{};

src/server/master.cc

@@ -19,7 +19,7 @@
 #include "swoole_lock.h"
 #include "swoole_util.h"
 
-#include <assert.h>
+#include <cassert>
 
 using swoole::network::Address;
 using swoole::network::SendfileTask;
@@ -143,8 +143,8 @@ int Server::accept_command_result(Reactor *reactor, Event *event) {
 }
 
 int Server::accept_connection(Reactor *reactor, Event *event) {
-    Server *serv = (Server *) reactor->ptr;
-    ListenPort *listen_host = (ListenPort *) event->socket->object;
+    auto serv = static_cast<Server *>(reactor->ptr);
+    auto listen_host = static_cast<ListenPort *>(event->socket->object);
 
     for (int i = 0; i < SW_ACCEPT_MAX_COUNT; i++) {
         Socket *sock = event->socket->accept();
@@ -708,7 +708,7 @@ Server::Server(enum Mode _mode) {
     mode_ = _mode;
 
     // http server
-    http_compression = 1;
+    http_compression = true;
     http_compression_level = SW_Z_BEST_SPEED;
     compression_min_length = SW_COMPRESSION_MIN_LENGTH_DEFAULT;
 
@@ -1063,7 +1063,7 @@ void Server::destroy() {
 
     SW_LOOP_N(SW_MAX_HOOK_TYPE) {
         if (hooks[i]) {
-            std::list<Callback> *l = reinterpret_cast<std::list<Callback> *>(hooks[i]);
+            auto l = static_cast<std::list<Callback> *>(hooks[i]);
             hooks[i] = nullptr;
             delete l;
         }
@@ -1106,7 +1106,8 @@ bool Server::feedback(Connection *conn, enum ServerEventType event) {
     _send.info.reactor_id = conn->reactor_id;
 
     if (is_process_mode()) {
-        return send_to_reactor_thread((EventData *) &_send.info, sizeof(_send.info), conn->session_id) > 0;
+        return send_to_reactor_thread(
+                   reinterpret_cast<EventData *>(&_send.info), sizeof(_send.info), conn->session_id) > 0;
     } else {
         return send_to_connection(&_send) == SW_OK;
     }
@@ -1501,7 +1502,6 @@ int Server::send_to_connection(SendData *_send) {
         _socket->out_buffer->append(_send_data, _send_length);
         conn->send_queued_bytes = _socket->out_buffer->length();
 
-        ListenPort *port = get_port_by_fd(fd);
         if (onBufferFull && conn->high_watermark == 0 && _socket->out_buffer->length() >= port->buffer_high_watermark) {
             notify(conn, SW_SERVER_EVENT_BUFFER_FULL);
             conn->high_watermark = 1;
@@ -1988,7 +1988,7 @@ Connection *Server::add_connection(ListenPort *ls, Socket *_socket, int server_f
 
     connection->fd = fd;
     connection->reactor_id = reactor_id;
-    connection->server_fd = (sw_atomic_t) server_fd;
+    connection->server_fd = server_fd;
     connection->last_recv_time = connection->connect_time = microtime();
     connection->active = 1;
     connection->worker_id = -1;
@@ -2044,7 +2044,7 @@ void Server::init_pipe_sockets(MessageBus *mb) {
     size_t n = get_core_worker_num();
 
     SW_LOOP_N(n) {
-        Worker *worker = get_worker(i);
+        const auto worker = get_worker(i);
         if (i >= worker_num && task_ipc_mode != TASK_IPC_UNIXSOCK) {
             continue;
         }
@@ -2091,7 +2091,7 @@ int Server::get_idle_task_worker_num() {
     return idle_worker_num;
 }
 
-int Server::get_tasking_num() {
+int Server::get_tasking_num() const {
     // TODO Why need to reset ?
     int tasking_num = gs->tasking_num;
     if (tasking_num < 0) {

src/server/port.cc

@@ -455,15 +455,15 @@ int ListenPort::readable_callback_http(Reactor *reactor, ListenPort *port, Event
     }
 
     if (n == 0) {
-        if (0) {
+        if (false) {
         _bad_request:
             _socket->send(SW_STRL(SW_HTTP_BAD_REQUEST_PACKET), 0);
         }
-        if (0) {
+        if (false) {
         _too_large:
             _socket->send(SW_STRL(SW_HTTP_REQUEST_ENTITY_TOO_LARGE_PACKET), 0);
         }
-        if (0) {
+        if (false) {
         _unavailable:
             _socket->send(SW_STRL(SW_HTTP_SERVICE_UNAVAILABLE_PACKET), 0);
         }

src/server/process.cc

@@ -28,7 +28,7 @@ Factory *Server::create_process_factory() {
     /**
      * alloc the memory for connection_list
      */
-    connection_list = (Connection *) sw_shm_calloc(max_connection, sizeof(Connection));
+    connection_list = static_cast<Connection *>(sw_shm_calloc(max_connection, sizeof(Connection)));
     if (connection_list == nullptr) {
         swoole_error("calloc[1] failed");
         return nullptr;
@@ -381,7 +381,6 @@ bool ProcessFactory::end(SessionId session_id, int flags) {
 
     swoole_trace_log(SW_TRACE_CLOSE, "session_id=%ld, fd=%d", session_id, conn->fd);
 
-    Worker *worker;
     DataHead ev = {};
 
     /**
@@ -390,6 +389,7 @@ bool ProcessFactory::end(SessionId session_id, int flags) {
      * MUST forward to the correct worker process
      */
     if (conn->close_actively) {
+        Worker *worker;
         bool hash = server_->is_hash_dispatch_mode();
         int worker_id = hash ? server_->schedule_worker(conn->fd, nullptr) : conn->fd % server_->worker_num;
         if (server_->is_worker() && (!hash || worker_id == (int) swoole_get_process_id())) {

src/server/reactor_process.cc

@@ -15,7 +15,6 @@
  */
 
 #include "swoole_server.h"
-#include "swoole_memory.h"
 
 namespace swoole {
 using network::Socket;