~singpolyma/biboumi

5402a256d1f0ebbeafa32d250d000cf38fe748fb — louiz’ 5 years ago dd4c54c
Apply all the clang-tidy modernize-* fixes
M src/bridge/colors.cpp => src/bridge/colors.cpp +1 -1
@@ 4,7 4,7 @@
#include <algorithm>
#include <iostream>

#include <string.h>
#include <cstring>

using namespace std::string_literals;


M src/identd/identd_socket.hpp => src/identd/identd_socket.hpp +0 -1
@@ 2,7 2,6 @@

#include <network/socket_handler.hpp>

#include <cassert>
#include <network/tcp_socket_handler.hpp>

#include <logger/logger.hpp>

M src/irc/iid.cpp => src/irc/iid.cpp +5 -4
@@ 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))
{
}


M src/irc/iid.hpp => src/irc/iid.hpp +1 -1
@@ 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;


M src/irc/irc_client.cpp => src/irc/irc_client.cpp +21 -20
@@ 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());
    }
}


M src/irc/irc_client.hpp => src/irc/irc_client.hpp +3 -3
@@ 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();


M src/main.cpp => src/main.cpp +1 -1
@@ 11,7 11,7 @@
#endif

#include <atomic>
#include <signal.h>
#include <csignal>
#ifdef USE_DATABASE
# include <litesql.hpp>
#endif

M src/network/poller.cpp => src/network/poller.cpp +2 -2
@@ 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>

M src/network/tcp_client_socket_handler.cpp => src/network/tcp_client_socket_handler.cpp +1 -1
@@ 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;
}

M src/network/tcp_server_socket.hpp => src/network/tcp_server_socket.hpp +0 -1
@@ 12,7 12,6 @@
#include <netinet/ip.h>

#include <cstring>
#include <cassert>

template <typename RemoteSocketType>
class TcpSocketServer: public SocketHandler

M src/network/tcp_socket_handler.cpp => src/network/tcp_socket_handler.cpp +1 -1
@@ 8,7 8,7 @@
#include <sys/types.h>
#include <stdexcept>
#include <unistd.h>
#include <errno.h>
#include <cerrno>
#include <cstring>

#ifdef BOTAN_FOUND

M src/utils/encoding.cpp => src/utils/encoding.cpp +1 -1
@@ 4,7 4,7 @@

#include <stdexcept>

#include <assert.h>
#include <cassert>
#include <string.h>
#include <iconv.h>
#include <cerrno>

M src/utils/timed_events.cpp => src/utils/timed_events.cpp +7 -6
@@ 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))
{
}


M src/utils/timed_events.hpp => src/utils/timed_events.hpp +2 -2
@@ 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;

M src/xmpp/adhoc_command.cpp => src/xmpp/adhoc_command.cpp +3 -2
@@ 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)
{

M src/xmpp/adhoc_command.hpp => src/xmpp/adhoc_command.hpp +1 -1
@@ 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;

M src/xmpp/biboumi_component.cpp => src/xmpp/biboumi_component.cpp +4 -6
@@ 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;
}


M src/xmpp/jid.cpp => src/xmpp/jid.cpp +1 -1
@@ 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)
  {

M src/xmpp/xmpp_stanza.cpp => src/xmpp/xmpp_stanza.cpp +1 -1
@@ 7,7 7,7 @@
#include <iostream>
#include <sstream>

#include <string.h>
#include <cstring>

std::string xml_escape(const std::string& data)
{

M tests/xmpp.cpp => tests/xmpp.cpp +1 -1
@@ 43,7 43,7 @@ TEST_CASE("Test basic XML parsing")

TEST_CASE("XML escape")
{
  const std::string unescaped = "'coucou'<cc>/&\"gaga\"";
  const std::string unescaped = R"('coucou'<cc>/&"gaga")";
  CHECK(xml_escape(unescaped) == "&apos;coucou&apos;&lt;cc&gt;/&amp;&quot;gaga&quot;");
}