~singpolyma/biboumi

af42073830087d97385e507f27f601e8769541b0 — louiz’ 6 years ago 305e01c
Style fix

Move all constructors at the top of classes
M louloulibs/config/config.hpp => louloulibs/config/config.hpp +7 -6
@@ 28,8 28,13 @@ typedef std::function<void()> t_config_changed_callback;
class Config
{
public:
  Config(){};
  ~Config(){};
  Config() = default;
  ~Config() = default;
  Config(const Config&) = delete;
  Config& operator=(const Config&) = delete;
  Config(Config&&) = delete;
  Config& operator=(Config&&) = delete;

  /**
   * returns a value from the config. If it doesn’t exist, use
   * the second argument as the default.


@@ 88,10 93,6 @@ private:
  std::map<std::string, std::string> values;
  std::vector<t_config_changed_callback> callbacks;

  Config(const Config&) = delete;
  Config& operator=(const Config&) = delete;
  Config(Config&&) = delete;
  Config& operator=(Config&&) = delete;
};

#endif // CONFIG_INCLUDED

M louloulibs/logger/logger.hpp => louloulibs/logger/logger.hpp +5 -3
@@ 67,10 67,12 @@ public:
  Logger(const int log_level, const std::string& log_file);
  Logger(const int log_level);

private:
  Logger(const Logger&);
  Logger& operator=(const Logger&);
  Logger(const Logger&) = delete;
  Logger& operator=(const Logger&) = delete;
  Logger(Logger&&) = delete;
  Logger& operator=(Logger&&) = delete;

private:
  const int log_level;
  std::ofstream ofstream;
  nullstream null_stream;

M louloulibs/network/credentials_manager.hpp => louloulibs/network/credentials_manager.hpp +6 -0
@@ 14,6 14,12 @@ class BasicCredentialsManager: public Botan::Credentials_Manager
{
public:
  BasicCredentialsManager(const TCPSocketHandler* const socket_handler);

  BasicCredentialsManager(BasicCredentialsManager&&) = delete;
  BasicCredentialsManager(const BasicCredentialsManager&) = delete;
  BasicCredentialsManager& operator=(const BasicCredentialsManager&) = delete;
  BasicCredentialsManager& operator=(BasicCredentialsManager&&) = delete;

  void verify_certificate_chain(const std::string& type,
                                const std::string& purported_hostname,
                                const std::vector<Botan::X509_Certificate>&) override final;

M louloulibs/network/dns_handler.cpp => louloulibs/network/dns_handler.cpp +3 -1
@@ 13,7 13,9 @@
DNSHandler DNSHandler::instance;

using namespace std::string_literals;
DNSHandler::DNSHandler()
DNSHandler::DNSHandler():
  socket_handlers{},
  channel{nullptr}
{
  int ares_error;
  if ((ares_error = ::ares_library_init(ARES_LIB_INIT_ALL)) != 0)

M louloulibs/network/dns_handler.hpp => louloulibs/network/dns_handler.hpp +5 -5
@@ 24,6 24,11 @@ class DNSHandler
public:
  DNSHandler();
  ~DNSHandler() = default;
  DNSHandler(const DNSHandler&) = delete;
  DNSHandler(DNSHandler&&) = delete;
  DNSHandler& operator=(const DNSHandler&) = delete;
  DNSHandler& operator=(DNSHandler&&) = delete;

  void gethostbyname(const std::string& name, ares_host_callback callback,
                     void* socket_handler, int family);
  /**


@@ 48,11 53,6 @@ private:
   */
  std::vector<std::unique_ptr<DNSSocketHandler>> socket_handlers;
  ares_channel channel;

  DNSHandler(const DNSHandler&) = delete;
  DNSHandler(DNSHandler&&) = delete;
  DNSHandler& operator=(const DNSHandler&) = delete;
  DNSHandler& operator=(DNSHandler&&) = delete;
};

#endif /* CARES_FOUND */

M louloulibs/network/dns_socket_handler.cpp => louloulibs/network/dns_socket_handler.cpp +0 -4
@@ 13,10 13,6 @@ DNSSocketHandler::DNSSocketHandler(std::shared_ptr<Poller> poller,
{
}

DNSSocketHandler::~DNSSocketHandler()
{
}

void DNSSocketHandler::connect()
{
}

M louloulibs/network/dns_socket_handler.hpp => louloulibs/network/dns_socket_handler.hpp +6 -5
@@ 18,7 18,12 @@ class DNSSocketHandler: public SocketHandler
{
public:
  explicit DNSSocketHandler(std::shared_ptr<Poller> poller, const socket_t socket);
  ~DNSSocketHandler();
  ~DNSSocketHandler() = default;
  DNSSocketHandler(const DNSSocketHandler&) = delete;
  DNSSocketHandler(DNSSocketHandler&&) = delete;
  DNSSocketHandler& operator=(const DNSSocketHandler&) = delete;
  DNSSocketHandler& operator=(DNSSocketHandler&&) = delete;

  /**
   * Just call dns_process_fd, c-ares will do its work of send()ing or
   * recv()ing the data it wants on that socket.


@@ 36,10 41,6 @@ public:
  bool is_connected() const override final;

private:
  DNSSocketHandler(const DNSSocketHandler&) = delete;
  DNSSocketHandler(DNSSocketHandler&&) = delete;
  DNSSocketHandler& operator=(const DNSSocketHandler&) = delete;
  DNSSocketHandler& operator=(DNSSocketHandler&&) = delete;
};

#endif // CARES_FOUND

M louloulibs/network/poller.hpp => louloulibs/network/poller.hpp +4 -5
@@ 38,6 38,10 @@ class Poller
public:
  explicit Poller();
  ~Poller();
  Poller(const Poller&) = delete;
  Poller(Poller&&) = delete;
  Poller& operator=(const Poller&) = delete;
  Poller& operator=(Poller&&) = delete;
  /**
   * Add a SocketHandler to be monitored by this Poller. All receive events
   * are always automatically watched.


@@ 85,11 89,6 @@ private:
#elif POLLER == EPOLL
  int epfd;
#endif

  Poller(const Poller&) = delete;
  Poller(Poller&&) = delete;
  Poller& operator=(const Poller&) = delete;
  Poller& operator=(Poller&&) = delete;
};

#endif // POLLER_INCLUDED

M louloulibs/network/resolver.hpp => louloulibs/network/resolver.hpp +4 -5
@@ 37,6 37,10 @@ public:

  Resolver();
  ~Resolver() = default;
  Resolver(const Resolver&) = delete;
  Resolver(Resolver&&) = delete;
  Resolver& operator=(const Resolver&) = delete;
  Resolver& operator=(Resolver&&) = delete;

  bool is_resolving() const
  {


@@ 117,11 121,6 @@ private:

  ErrorCallbackType error_cb;
  SuccessCallbackType success_cb;

  Resolver(const Resolver&) = delete;
  Resolver(Resolver&&) = delete;
  Resolver& operator=(const Resolver&) = delete;
  Resolver& operator=(Resolver&&) = delete;
};

std::string addr_to_string(const struct addrinfo* rp);

M louloulibs/network/socket_handler.hpp => louloulibs/network/socket_handler.hpp +5 -6
@@ 16,6 16,11 @@ public:
    socket(socket)
  {}
  virtual ~SocketHandler() {}
  SocketHandler(const SocketHandler&) = delete;
  SocketHandler(SocketHandler&&) = delete;
  SocketHandler& operator=(const SocketHandler&) = delete;
  SocketHandler& operator=(SocketHandler&&) = delete;

  virtual void on_recv() = 0;
  virtual void on_send() = 0;
  virtual void connect() = 0;


@@ 34,12 39,6 @@ protected:
   * The handled socket.
   */
  socket_t socket;

private:
  SocketHandler(const SocketHandler&) = delete;
  SocketHandler(SocketHandler&&) = delete;
  SocketHandler& operator=(const SocketHandler&) = delete;
  SocketHandler& operator=(SocketHandler&&) = delete;
};

#endif // SOCKET_HANDLER_HPP

M louloulibs/network/tcp_socket_handler.hpp => louloulibs/network/tcp_socket_handler.hpp +5 -6
@@ 28,9 28,13 @@ class TCPSocketHandler: public SocketHandler
{
protected:
  ~TCPSocketHandler();

public:
  explicit TCPSocketHandler(std::shared_ptr<Poller> poller);
  TCPSocketHandler(const TCPSocketHandler&) = delete;
  TCPSocketHandler(TCPSocketHandler&&) = delete;
  TCPSocketHandler& operator=(const TCPSocketHandler&) = delete;
  TCPSocketHandler& operator=(TCPSocketHandler&&) = delete;

  /**
   * Connect to the remote server, and call on_connected() if this
   * succeeds. If tls is true, we set use_tls to true and will also call


@@ 231,11 235,6 @@ protected:
  std::string bind_addr;

private:
  TCPSocketHandler(const TCPSocketHandler&) = delete;
  TCPSocketHandler(TCPSocketHandler&&) = delete;
  TCPSocketHandler& operator=(const TCPSocketHandler&) = delete;
  TCPSocketHandler& operator=(TCPSocketHandler&&) = delete;

  /**
   * Display the resolved IP, just for information purpose.
   */

M louloulibs/utils/scopeguard.hpp => louloulibs/utils/scopeguard.hpp +6 -4
@@ 40,6 40,12 @@ public:
  {
    this->add_callback(std::move(func));
  }

  ScopeGuard(const ScopeGuard&) = delete;
  ScopeGuard& operator=(ScopeGuard&&) = delete;
  ScopeGuard(ScopeGuard&&) = delete;
  ScopeGuard& operator=(const ScopeGuard&) = delete;

  /**
   * default constructor, the scope guard is enabled but empty, use
   * add_callback()


@@ 78,10 84,6 @@ private:
  bool enabled;
  std::vector<std::function<void()>> callbacks;

  ScopeGuard(const ScopeGuard&) = delete;
  ScopeGuard& operator=(ScopeGuard&&) = delete;
  ScopeGuard(ScopeGuard&&) = delete;
  ScopeGuard& operator=(const ScopeGuard&) = delete;
};

}

M louloulibs/utils/timed_events.cpp => louloulibs/utils/timed_events.cpp +0 -4
@@ 29,10 29,6 @@ TimedEvent::TimedEvent(TimedEvent&& other):
{
}

TimedEvent::~TimedEvent()
{
}

bool TimedEvent::is_after(const TimedEvent& other) const
{
  return this->is_after(other.time_point);

M louloulibs/utils/timed_events.hpp => louloulibs/utils/timed_events.hpp +14 -11
@@ 31,7 31,12 @@ public:
                      std::function<void()> callback, const std::string& name="");

  explicit TimedEvent(TimedEvent&&);
  ~TimedEvent();
  ~TimedEvent() = default;

  TimedEvent(const TimedEvent&) = delete;
  TimedEvent& operator=(const TimedEvent&) = delete;
  TimedEvent& operator=(TimedEvent&&) = delete;

  /**
   * Whether or not this event happens after the other one.
   */


@@ 70,10 75,6 @@ private:
   * unique.
   */
  const std::string name;

  TimedEvent(const TimedEvent&) = delete;
  TimedEvent& operator=(const TimedEvent&) = delete;
  TimedEvent& operator=(TimedEvent&&) = delete;
};

/**


@@ 84,7 85,13 @@ private:
class TimedEventsManager
{
public:
  ~TimedEventsManager();
  ~TimedEventsManager() = default;

  TimedEventsManager(const TimedEventsManager&) = delete;
  TimedEventsManager(TimedEventsManager&&) = delete;
  TimedEventsManager& operator=(const TimedEventsManager&) = delete;
  TimedEventsManager& operator=(TimedEventsManager&&) = delete;

  /**
   * Return the unique instance of this class
   */


@@ 121,12 128,8 @@ public:
  std::size_t size() const;

private:
  explicit TimedEventsManager();
  std::list<TimedEvent> events;
  TimedEventsManager(const TimedEventsManager&) = delete;
  TimedEventsManager(TimedEventsManager&&) = delete;
  TimedEventsManager& operator=(const TimedEventsManager&) = delete;
  TimedEventsManager& operator=(TimedEventsManager&&) = delete;
  explicit TimedEventsManager() = default;
};

#endif // TIMED_EVENTS_HPP

M louloulibs/utils/timed_events_manager.cpp => louloulibs/utils/timed_events_manager.cpp +0 -8
@@ 6,14 6,6 @@ TimedEventsManager& TimedEventsManager::instance()
  return inst;
}

TimedEventsManager::TimedEventsManager()
{
}

TimedEventsManager::~TimedEventsManager()
{
}

void TimedEventsManager::add_event(TimedEvent&& event)
{
  for (auto it = this->events.begin(); it != this->events.end(); ++it)

M louloulibs/xmpp/adhoc_commands_handler.hpp => louloulibs/xmpp/adhoc_commands_handler.hpp +6 -5
@@ 21,6 21,12 @@ public:
    commands{}
  { }
  ~AdhocCommandsHandler() = default;

  AdhocCommandsHandler(const AdhocCommandsHandler&) = delete;
  AdhocCommandsHandler(AdhocCommandsHandler&&) = delete;
  AdhocCommandsHandler& operator=(const AdhocCommandsHandler&) = delete;
  AdhocCommandsHandler& operator=(AdhocCommandsHandler&&) = delete;

  /**
   * Returns the list of available commands.
   */


@@ 63,11 69,6 @@ private:
   * Of the form: {{session_id, owner_jid}, session}.
   */
  std::map<std::pair<const std::string, const std::string>, AdhocSession> sessions;

  AdhocCommandsHandler(const AdhocCommandsHandler&) = delete;
  AdhocCommandsHandler(AdhocCommandsHandler&&) = delete;
  AdhocCommandsHandler& operator=(const AdhocCommandsHandler&) = delete;
  AdhocCommandsHandler& operator=(AdhocCommandsHandler&&) = delete;
};

#endif // ADHOC_COMMANDS_HANDLER_HPP

M louloulibs/xmpp/adhoc_session.hpp => louloulibs/xmpp/adhoc_session.hpp +6 -6
@@ 25,6 25,12 @@ public:
  explicit AdhocSession(const AdhocCommand& command, const std::string& owner_jid,
                        const std::string& to_jid);
  ~AdhocSession() = default;

  AdhocSession(const AdhocSession&) = delete;
  AdhocSession(AdhocSession&&) = delete;
  AdhocSession& operator=(const AdhocSession&) = delete;
  AdhocSession& operator=(AdhocSession&&) = delete;

  /**
   * Return the function to be executed, found in our AdhocCommand, for the
   * current_step. And increment the current_step.


@@ 80,12 86,6 @@ public:
   * any key in there.
   */
  std::map<std::string, std::string> vars;

private:
  AdhocSession(const AdhocSession&) = delete;
  AdhocSession(AdhocSession&&) = delete;
  AdhocSession& operator=(const AdhocSession&) = delete;
  AdhocSession& operator=(AdhocSession&&) = delete;
};

#endif // ADHOC_SESSION_HPP

M louloulibs/xmpp/jid.hpp => louloulibs/xmpp/jid.hpp +5 -6
@@ 11,6 11,11 @@ class Jid
public:
  explicit Jid(const std::string& jid);

  Jid(const Jid&) = delete;
  Jid(Jid&&) = delete;
  Jid& operator=(const Jid&) = delete;
  Jid& operator=(Jid&&) = delete;

  std::string domain;
  std::string local;
  std::string resource;


@@ 23,12 28,6 @@ public:
  {
    return this->local + "@" + this->domain + "/" + this->resource;
  }

private:
  Jid(const Jid&) = delete;
  Jid(Jid&&) = delete;
  Jid& operator=(const Jid&) = delete;
  Jid& operator=(Jid&&) = delete;
};

/**

M louloulibs/xmpp/xmpp_component.hpp => louloulibs/xmpp/xmpp_component.hpp +5 -5
@@ 38,6 38,11 @@ public:
  explicit XmppComponent(std::shared_ptr<Poller> poller, const std::string& hostname, const std::string& secret);
  virtual ~XmppComponent() = default;

  XmppComponent(const XmppComponent&) = delete;
  XmppComponent(XmppComponent&&) = delete;
  XmppComponent& operator=(const XmppComponent&) = delete;
  XmppComponent& operator=(XmppComponent&&) = delete;

  void on_connection_failed(const std::string& reason) override final;
  void on_connected() override final;
  void on_connection_close(const std::string& error) override final;


@@ 231,11 236,6 @@ protected:

  std::unordered_map<std::string, std::function<void(const Stanza&)>> stanza_handlers;
  AdhocCommandsHandler adhoc_commands_handler;

  XmppComponent(const XmppComponent&) = delete;
  XmppComponent(XmppComponent&&) = delete;
  XmppComponent& operator=(const XmppComponent&) = delete;
  XmppComponent& operator=(XmppComponent&&) = delete;
};

#endif // XMPP_COMPONENT_INCLUDED

M louloulibs/xmpp/xmpp_parser.cpp => louloulibs/xmpp/xmpp_parser.cpp +2 -2
@@ 118,7 118,7 @@ void XmppParser::end_element(const XML_Char*)
          this->stanza_event(*this->current_node);
          // Note: deleting all the children of our parent deletes ourself,
          // so current_node is an invalid pointer after this line
          this->current_node->get_parent()->delete_all_children();
          parent->delete_all_children();
        }
      this->current_node = parent;
    }


@@ 139,7 139,7 @@ void XmppParser::stanza_event(const Stanza& stanza) const
      try {
        callback(stanza);
      } catch (const std::exception& e) {
        log_debug("Unhandled exception: " << e.what());
        log_error("Unhandled exception: " << e.what());
      }
    }
}

M louloulibs/xmpp/xmpp_parser.hpp => louloulibs/xmpp/xmpp_parser.hpp +9 -7
@@ 32,13 32,13 @@ class XmppParser
public:
  explicit XmppParser();
  ~XmppParser();
  XmppParser(const XmppParser&) = delete;
  XmppParser& operator=(const XmppParser&) = delete;
  XmppParser(XmppParser&&) = delete;
  XmppParser& operator=(XmppParser&&) = delete;

public:
  /**
   * Init the XML parser and install the callbacks
   */
  void init_xml_parser();
  /**
   * Feed the parser with some XML data
   */
  int feed(const char* data, const int len, const bool is_final);


@@ 99,6 99,11 @@ public:

private:
  /**
   * Init the XML parser and install the callbacks
   */
  void init_xml_parser();

  /**
   * Expat structure.
   */
  XML_Parser parser;


@@ 123,9 128,6 @@ private:
  std::vector<std::function<void(const Stanza&)>> stanza_callbacks;
  std::vector<std::function<void(const XmlNode&)>> stream_open_callbacks;
  std::vector<std::function<void(const XmlNode&)>> stream_close_callbacks;

  XmppParser(const XmppParser&) = delete;
  XmppParser& operator=(const XmppParser&) = delete;
};

#endif // XMPP_PARSER_INCLUDED

M louloulibs/xmpp/xmpp_stanza.hpp => louloulibs/xmpp/xmpp_stanza.hpp +4 -4
@@ 25,7 25,6 @@ class XmlNode
public:
  explicit XmlNode(const std::string& name, XmlNode* parent);
  explicit XmlNode(const std::string& name);
  XmlNode(XmlNode&& node) = default;
  /**
   * The copy constructor does not copy the parent attribute. The children
   * nodes are all copied recursively.


@@ 42,6 41,10 @@ public:
      this->add_child(std::make_unique<XmlNode>(*child));
  }

  XmlNode(XmlNode&& node) = default;
  XmlNode& operator=(const XmlNode&) = delete;
  XmlNode& operator=(XmlNode&&) = delete;

  ~XmlNode() = default;

  void delete_all_children();


@@ 129,9 132,6 @@ private:
  std::vector<std::unique_ptr<XmlNode>> children;
  std::string inner;
  std::string tail;

  XmlNode& operator=(const XmlNode&) = delete;
  XmlNode& operator=(XmlNode&&) = delete;
};

std::ostream& operator<<(std::ostream& os, const XmlNode& node);

M src/bridge/bridge.cpp => src/bridge/bridge.cpp +0 -4
@@ 45,10 45,6 @@ Bridge::Bridge(const std::string& user_jid, BiboumiComponent& xmpp, std::shared_
{
}

Bridge::~Bridge()
{
}

/**
 * Return the role and affiliation, corresponding to the given irc mode */
static std::tuple<std::string, std::string> get_role_affiliation_from_irc_mode(const char mode)

M src/bridge/bridge.hpp => src/bridge/bridge.hpp +6 -6
@@ 34,7 34,12 @@ class Bridge
{
public:
  explicit Bridge(const std::string& user_jid, BiboumiComponent& xmpp, std::shared_ptr<Poller> poller);
  ~Bridge();
  ~Bridge() = default;

  Bridge(const Bridge&) = delete;
  Bridge(Bridge&& other) = delete;
  Bridge& operator=(const Bridge&) = delete;
  Bridge& operator=(Bridge&&) = delete;
  /**
   * QUIT all connected IRC servers.
   */


@@ 239,11 244,6 @@ private:
   * response iq.
   */
  std::list<irc_responder_callback_t> waiting_irc;

  Bridge(const Bridge&) = delete;
  Bridge(Bridge&& other) = delete;
  Bridge& operator=(const Bridge&) = delete;
  Bridge& operator=(Bridge&&) = delete;
};

struct IRCNotConnected: public std::exception

M src/database/database.hpp => src/database/database.hpp +5 -5
@@ 16,6 16,11 @@ public:
  Database() = default;
  ~Database() = default;

  Database(const Database&) = delete;
  Database(Database&&) = delete;
  Database& operator=(const Database&) = delete;
  Database& operator=(Database&&) = delete;

  static void set_verbose(const bool val);

  template<typename PersistentType>


@@ 42,11 47,6 @@ private:
  static std::unique_ptr<db::BibouDB> db;

  static db::BibouDB& get_db();

  Database(const Database&) = delete;
  Database(Database&&) = delete;
  Database& operator=(const Database&) = delete;
  Database& operator=(Database&&) = delete;
};
#endif /* USE_DATABASE */


M src/irc/iid.cpp => src/irc/iid.cpp +0 -8
@@ 51,14 51,6 @@ void Iid::init_with_fixed_server(const std::string& iid, const std::string& host
    }
}

Iid::Iid(const Iid& other):
  is_channel(other.is_channel),
  is_user(other.is_user),
  local(other.local),
  server(other.server)
{
}

Iid::Iid():
  is_channel(false),
  is_user(false)

M src/irc/iid.hpp => src/irc/iid.hpp +6 -6
@@ 43,8 43,12 @@ class Iid
{
public:
  Iid(const std::string& iid);
  explicit Iid(const Iid&);
  explicit Iid();
  Iid();
  Iid(const Iid&) = default;

  Iid(Iid&&) = delete;
  Iid& operator=(const Iid&) = delete;
  Iid& operator=(Iid&&) = delete;

  void set_local(const std::string& loc);
  void set_server(const std::string& serv);


@@ 63,10 67,6 @@ private:

  std::string local;
  std::string server;

  Iid(Iid&&) = delete;
  Iid& operator=(const Iid&) = delete;
  Iid& operator=(Iid&&) = delete;
};

namespace std {

M src/irc/irc_channel.hpp => src/irc/irc_channel.hpp +9 -11
@@ 16,6 16,11 @@ class IrcChannel
public:
  explicit IrcChannel();

  IrcChannel(const IrcChannel&) = delete;
  IrcChannel(IrcChannel&&) = delete;
  IrcChannel& operator=(const IrcChannel&) = delete;
  IrcChannel& operator=(IrcChannel&&) = delete;

  bool joined;
  std::string topic;
  std::string topic_author;


@@ 30,12 35,6 @@ public:
protected:
  std::unique_ptr<IrcUser> self;
  std::vector<std::unique_ptr<IrcUser>> users;

private:
  IrcChannel(const IrcChannel&) = delete;
  IrcChannel(IrcChannel&&) = delete;
  IrcChannel& operator=(const IrcChannel&) = delete;
  IrcChannel& operator=(IrcChannel&&) = delete;
};

/**


@@ 50,6 49,10 @@ class DummyIrcChannel: public IrcChannel
{
public:
  explicit DummyIrcChannel();
  DummyIrcChannel(const DummyIrcChannel&) = delete;
  DummyIrcChannel(DummyIrcChannel&&) = delete;
  DummyIrcChannel& operator=(const DummyIrcChannel&) = delete;
  DummyIrcChannel& operator=(DummyIrcChannel&&) = delete;

  /**
   * This flag is at true whenever the user wants to join this channel, but


@@ 60,11 63,6 @@ public:
   * the channel, we don’t use that flag, we just join it immediately.
   */
  bool joining;
private:
  DummyIrcChannel(const DummyIrcChannel&) = delete;
  DummyIrcChannel(DummyIrcChannel&&) = delete;
  DummyIrcChannel& operator=(const DummyIrcChannel&) = delete;
  DummyIrcChannel& operator=(DummyIrcChannel&&) = delete;
};

#endif // IRC_CHANNEL_INCLUDED

M src/irc/irc_client.hpp => src/irc/irc_client.hpp +6 -5
@@ 31,6 31,12 @@ public:
                     const std::string& realname, const std::string& user_hostname,
                     Bridge& bridge);
  ~IrcClient();

  IrcClient(const IrcClient&) = delete;
  IrcClient(IrcClient&&) = delete;
  IrcClient& operator=(const IrcClient&) = delete;
  IrcClient& operator=(IrcClient&&) = delete;

  /**
   * Connect to the IRC server
   */


@@ 360,11 366,6 @@ private:
   * the WebIRC protocole.
   */
  Resolver dns_resolver;

  IrcClient(const IrcClient&) = delete;
  IrcClient(IrcClient&&) = delete;
  IrcClient& operator=(const IrcClient&) = delete;
  IrcClient& operator=(IrcClient&&) = delete;
};

#endif // IRC_CLIENT_INCLUDED

M src/irc/irc_message.cpp => src/irc/irc_message.cpp +0 -4
@@ 47,10 47,6 @@ IrcMessage::IrcMessage(std::string&& command,
{
}

IrcMessage::~IrcMessage()
{
}

std::ostream& operator<<(std::ostream& os, const IrcMessage& message)
{
  os << "IrcMessage";

M src/irc/irc_message.hpp => src/irc/irc_message.hpp +5 -5
@@ 11,16 11,16 @@ public:
  IrcMessage(std::string&& line);
  IrcMessage(std::string&& prefix, std::string&& command, std::vector<std::string>&& args);
  IrcMessage(std::string&& command, std::vector<std::string>&& args);
  ~IrcMessage();

  std::string prefix;
  std::string command;
  std::vector<std::string> arguments;
  ~IrcMessage() = default;

  IrcMessage(const IrcMessage&) = delete;
  IrcMessage(IrcMessage&&) = delete;
  IrcMessage& operator=(const IrcMessage&) = delete;
  IrcMessage& operator=(IrcMessage&&) = delete;

  std::string prefix;
  std::string command;
  std::vector<std::string> arguments;
};

std::ostream& operator<<(std::ostream& os, const IrcMessage& message);

M src/irc/irc_user.hpp => src/irc/irc_user.hpp +7 -6
@@ 15,18 15,19 @@ public:
  explicit IrcUser(const std::string& name,
                   const std::map<char, char>& prefix_to_mode);
  explicit IrcUser(const std::string& name);

  IrcUser(const IrcUser&) = delete;
  IrcUser(IrcUser&&) = delete;
  IrcUser& operator=(const IrcUser&) = delete;
  IrcUser& operator=(IrcUser&&) = delete;

  void add_mode(const char mode);
  void remove_mode(const char mode);
  char get_most_significant_mode(const std::vector<char>& sorted_user_modes) const;

  std::string nick;
  std::string host;
  std::set<char> modes;

private:
  IrcUser(const IrcUser&) = delete;
  IrcUser(IrcUser&&) = delete;
  IrcUser& operator=(const IrcUser&) = delete;
  IrcUser& operator=(IrcUser&&) = delete;
};

#endif // IRC_USER_INCLUDED

M src/xmpp/biboumi_component.hpp => src/xmpp/biboumi_component.hpp +5 -5
@@ 26,6 26,11 @@ public:
  explicit BiboumiComponent(std::shared_ptr<Poller> poller, const std::string& hostname, const std::string& secret);
  ~BiboumiComponent() = default;

  BiboumiComponent(const BiboumiComponent&) = delete;
  BiboumiComponent(BiboumiComponent&&) = delete;
  BiboumiComponent& operator=(const BiboumiComponent&) = delete;
  BiboumiComponent& operator=(BiboumiComponent&&) = delete;

  /**
   * Returns the bridge for the given user. If it does not exist, return
   * nullptr.


@@ 99,11 104,6 @@ private:

  AdhocCommandsHandler irc_server_adhoc_commands_handler;
  AdhocCommandsHandler irc_channel_adhoc_commands_handler;

  BiboumiComponent(const BiboumiComponent&) = delete;
  BiboumiComponent(BiboumiComponent&&) = delete;
  BiboumiComponent& operator=(const BiboumiComponent&) = delete;
  BiboumiComponent& operator=(BiboumiComponent&&) = delete;
};

#endif // BIBOUMI_COMPONENT_INCLUDED