Apply all the clang-tidy modernize-* fixes

src/bridge/colors.cpp

@@ -4,7 +4,7 @@
 #include <algorithm>
 #include <iostream>
 
-#include <string.h>
+#include <cstring>
 
 using namespace std::string_literals;
 

src/identd/identd_socket.hpp

@@ -2,7 +2,6 @@
 
 #include <network/socket_handler.hpp>
 
-#include <cassert>
 #include <network/tcp_socket_handler.hpp>
 
 #include <logger/logger.hpp>

src/irc/iid.cpp

@@ -1,3 +1,4 @@
+#include <utility>
 #include <utils/tolower.hpp>
 #include <config/config.hpp>
 #include <bridge/bridge.hpp>
@@ -7,10 +8,10 @@
 
 constexpr char Iid::separator[];
 
-Iid::Iid(const std::string& local, const std::string& server, Iid::Type type):
-        type(type),
-        local(local),
-        server(server)
+Iid::Iid(std::string local, std::string server, Iid::Type type):
+        type(std::move(type)),
+        local(std::move(local)),
+        server(std::move(server))
 {
 }
 

src/irc/iid.hpp

@@ -59,7 +59,7 @@ public:
   Iid(const std::string& iid, const std::set<char>& chantypes);
   Iid(const std::string& iid, const std::initializer_list<char>& chantypes);
   Iid(const std::string& iid, const Bridge* bridge);
-  Iid(const std::string& local, const std::string& server, Type type);
+  Iid(std::string  local, std::string  server, Type type);
   Iid() = default;
   Iid(const Iid&) = default;
 

src/irc/irc_client.cpp

@@ -1,3 +1,4 @@
+#include <utility>
 #include <utils/timed_events.hpp>
 #include <database/database.hpp>
 #include <irc/irc_message.hpp>
@@ -127,16 +128,16 @@ static const std::unordered_map<std::string,
   {"502", {&IrcClient::on_generic_error, {2, 0}}},
 };
 
-IrcClient::IrcClient(std::shared_ptr<Poller>& poller, const std::string& hostname,
-                     const std::string& nickname, const std::string& username,
-                     const std::string& realname, const std::string& user_hostname,
+IrcClient::IrcClient(std::shared_ptr<Poller>& poller, std::string hostname,
+                     std::string nickname, std::string username,
+                     std::string realname, std::string user_hostname,
                      Bridge& bridge):
   TCPClientSocketHandler(poller),
-  hostname(hostname),
-  user_hostname(user_hostname),
-  username(username),
-  realname(realname),
-  current_nick(nickname),
+  hostname(std::move(hostname)),
+  user_hostname(std::move(user_hostname)),
+  username(std::move(username)),
+  realname(std::move(realname)),
+  current_nick(std::move(nickname)),
   bridge(bridge),
   welcomed(false),
   chanmodes({"", "", "", ""}),
@@ -791,10 +792,10 @@ void IrcClient::on_nickname_conflict(const IrcMessage& message)
 {
   const std::string nickname = message.arguments[1];
   this->on_generic_error(message);
-  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  for (const auto& pair: this->channels)
   {
     Iid iid;
-    iid.set_local(it->first);
+    iid.set_local(pair.first);
     iid.set_server(this->hostname);
     iid.type = Iid::Type::Channel;
     this->bridge.send_nickname_conflict_error(iid, nickname);
@@ -808,10 +809,10 @@ void IrcClient::on_nickname_change_too_fast(const IrcMessage& message)
   if (message.arguments.size() >= 3)
     txt = message.arguments[2];
   this->on_generic_error(message);
-  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  for (const auto& pair: this->channels)
   {
     Iid iid;
-    iid.set_local(it->first);
+    iid.set_local(pair.first);
     iid.set_server(this->hostname);
     iid.type = Iid::Type::Channel;
     this->bridge.send_presence_error(iid, nickname,
@@ -896,13 +897,13 @@ void IrcClient::on_error(const IrcMessage& message)
 {
   const std::string leave_message = message.arguments[0];
   // The user is out of all the channels
-  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  for (const auto& pair: this->channels)
   {
     Iid iid;
-    iid.set_local(it->first);
+    iid.set_local(pair.first);
     iid.set_server(this->hostname);
     iid.type = Iid::Type::Channel;
-    IrcChannel* channel = it->second.get();
+    IrcChannel* channel = pair.second.get();
     if (!channel->joined)
       continue;
     std::string own_nick = channel->get_self()->nick;
@@ -917,10 +918,10 @@ void IrcClient::on_quit(const IrcMessage& message)
   std::string txt;
   if (message.arguments.size() >= 1)
     txt = message.arguments[0];
-  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  for (const auto& pair: this->channels)
     {
-      const std::string chan_name = it->first;
-      IrcChannel* channel = it->second.get();
+      const std::string& chan_name = pair.first;
+      IrcChannel* channel = pair.second.get();
       const IrcUser* user = channel->find_user(message.prefix);
       if (user)
         {
@@ -966,9 +967,9 @@ void IrcClient::on_nick(const IrcMessage& message)
     {
       change_nick_func("", &this->get_dummy_channel());
     }
-  for (auto it = this->channels.begin(); it != this->channels.end(); ++it)
+  for (const auto& pair: this->channels)
     {
-      change_nick_func(it->first, it->second.get());
+      change_nick_func(pair.first, pair.second.get());
     }
 }
 

src/irc/irc_client.hpp

@@ -26,9 +26,9 @@ class Bridge;
 class IrcClient: public TCPClientSocketHandler
 {
 public:
-  explicit IrcClient(std::shared_ptr<Poller>& poller, const std::string& hostname,
-                     const std::string& nickname, const std::string& username,
-                     const std::string& realname, const std::string& user_hostname,
+  explicit IrcClient(std::shared_ptr<Poller>& poller, std::string  hostname,
+                     std::string nickname, std::string username,
+                     std::string realname, std::string user_hostname,
                      Bridge& bridge);
   ~IrcClient();
 

src/main.cpp

@@ -11,7 +11,7 @@
 #endif
 
 #include <atomic>
-#include <signal.h>
+#include <csignal>
 #ifdef USE_DATABASE
 # include <litesql.hpp>
 #endif

src/network/poller.cpp

@@ -2,8 +2,8 @@
 #include <logger/logger.hpp>
 #include <utils/timed_events.hpp>
 
-#include <assert.h>
-#include <errno.h>
+#include <cassert>
+#include <cerrno>
 #include <stdio.h>
 #include <signal.h>
 #include <unistd.h>

src/network/tcp_client_socket_handler.cpp

@@ -256,6 +256,6 @@ std::string TCPClientSocketHandler::get_port() const
 
 bool TCPClientSocketHandler::match_port_pairt(const uint16_t local, const uint16_t remote) const
 {
-  const uint16_t remote_port = static_cast<uint16_t>(std::stoi(this->port));
+  const auto remote_port = static_cast<uint16_t>(std::stoi(this->port));
   return this->is_connected() && local == this->local_port && remote == remote_port;
 }

src/network/tcp_server_socket.hpp

@@ -12,7 +12,6 @@
 #include <netinet/ip.h>
 
 #include <cstring>
-#include <cassert>
 
 template <typename RemoteSocketType>
 class TcpSocketServer: public SocketHandler

src/network/tcp_socket_handler.cpp

@@ -8,7 +8,7 @@
 #include <sys/types.h>
 #include <stdexcept>
 #include <unistd.h>
-#include <errno.h>
+#include <cerrno>
 #include <cstring>
 
 #ifdef BOTAN_FOUND

src/utils/encoding.cpp

@@ -4,7 +4,7 @@
 
 #include <stdexcept>
 
-#include <assert.h>
+#include <cassert>
 #include <string.h>
 #include <iconv.h>
 #include <cerrno>

src/utils/timed_events.cpp

@@ -1,22 +1,23 @@
+#include <utility>
 #include <utils/timed_events.hpp>
 
 TimedEvent::TimedEvent(std::chrono::steady_clock::time_point&& time_point,
-                       std::function<void()> callback, const std::string& name):
+                       std::function<void()> callback, std::string name):
   time_point(std::move(time_point)),
-  callback(callback),
+  callback(std::move(callback)),
   repeat(false),
   repeat_delay(0),
-  name(name)
+  name(std::move(name))
 {
 }
 
 TimedEvent::TimedEvent(std::chrono::milliseconds&& duration,
-                       std::function<void()> callback, const std::string& name):
+                       std::function<void()> callback, std::string name):
   time_point(std::chrono::steady_clock::now() + duration),
-  callback(callback),
+  callback(std::move(callback)),
   repeat(true),
   repeat_delay(std::move(duration)),
-  name(name)
+  name(std::move(name))
 {
 }
 

src/utils/timed_events.hpp

@@ -25,9 +25,9 @@ public:
    * An event the occurs only once, at the given time_point
    */
   explicit TimedEvent(std::chrono::steady_clock::time_point&& time_point,
-                      std::function<void()> callback, const std::string& name="");
+                      std::function<void()> callback, std::string name="");
   explicit TimedEvent(std::chrono::milliseconds&& duration,
-                      std::function<void()> callback, const std::string& name="");
+                      std::function<void()> callback, std::string name="");
 
   explicit TimedEvent(TimedEvent&&) = default;
   TimedEvent& operator=(TimedEvent&&) = default;

src/xmpp/adhoc_command.cpp

@@ -1,11 +1,12 @@
+#include <utility>
 #include <xmpp/adhoc_command.hpp>
 #include <xmpp/xmpp_component.hpp>
 #include <utils/reload.hpp>
 
 using namespace std::string_literals;
 
-AdhocCommand::AdhocCommand(std::vector<AdhocStep>&& callbacks, const std::string& name, const bool admin_only):
-  name(name),
+AdhocCommand::AdhocCommand(std::vector<AdhocStep>&& callbacks, std::string name, const bool admin_only):
+  name(std::move(name)),
   callbacks(std::move(callbacks)),
   admin_only(admin_only)
 {

src/xmpp/adhoc_command.hpp

@@ -17,7 +17,7 @@ class AdhocCommand
 {
   friend class AdhocSession;
 public:
-  AdhocCommand(std::vector<AdhocStep>&& callbacks, const std::string& name, const bool admin_only);
+  AdhocCommand(std::vector<AdhocStep>&& callbacks, std::string name, const bool admin_only);
   ~AdhocCommand() = default;
   AdhocCommand(const AdhocCommand&) = default;
   AdhocCommand(AdhocCommand&&) = default;

src/xmpp/biboumi_component.cpp

@@ -83,10 +83,8 @@ BiboumiComponent::BiboumiComponent(std::shared_ptr<Poller>& poller, const std::s
 
 void BiboumiComponent::shutdown()
 {
-  for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
-  {
-    it->second->shutdown("Gateway shutdown");
-  }
+  for (auto& pair: this->bridges)
+    pair.second->shutdown("Gateway shutdown");
 }
 
 void BiboumiComponent::clean()
@@ -696,8 +694,8 @@ Bridge* BiboumiComponent::find_user_bridge(const std::string& full_jid)
 std::vector<Bridge*> BiboumiComponent::get_bridges() const
 {
   std::vector<Bridge*> res;
-  for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
-    res.push_back(it->second.get());
+  for (const auto& bridge: this->bridges)
+    res.push_back(bridge.second.get());
   return res;
 }
 

src/xmpp/jid.cpp

@@ -53,7 +53,7 @@ std::string jidprep(const std::string& original)
 
   char local[max_jid_part_len] = {};
   memcpy(local, jid.local.data(), std::min(max_jid_part_len, jid.local.size()));
-  Stringprep_rc rc = static_cast<Stringprep_rc>(::stringprep(local, max_jid_part_len,
+  auto rc = static_cast<Stringprep_rc>(::stringprep(local, max_jid_part_len,
                      static_cast<Stringprep_profile_flags>(0), stringprep_xmpp_nodeprep));
   if (rc != STRINGPREP_OK)
   {

src/xmpp/xmpp_stanza.cpp

@@ -7,7 +7,7 @@
 #include <iostream>
 #include <sstream>
 
-#include <string.h>
+#include <cstring>
 
 std::string xml_escape(const std::string& data)
 {