6 files changed, 15 insertions(+), 24 deletions(-)

M louloulibs/network/tcp_socket_handler.hpp
M louloulibs/utils/timed_events.cpp
M louloulibs/utils/timed_events.hpp
M src/bridge/bridge.hpp
M src/xmpp/biboumi_component.cpp
M src/xmpp/biboumi_component.hpp

@@ 180,7 180,7 @@ private:
   /**
    * Where data is added, when we want to send something to the client.
    */
-  std::list<std::string> out_buf;
+  std::vector<std::string> out_buf;
   /**
    * DNS resolver
    */

@@ 20,15 20,6 @@ TimedEvent::TimedEvent(std::chrono::milliseconds&& duration,
 {
 }
 
-TimedEvent::TimedEvent(TimedEvent&& other):
-  time_point(std::move(other.time_point)),
-  callback(std::move(other.callback)),
-  repeat(other.repeat),
-  repeat_delay(std::move(other.repeat_delay)),
-  name(std::move(other.name))
-{
-}
-
 bool TimedEvent::is_after(const TimedEvent& other) const
 {
   return this->is_after(other.time_point);


@@ 47,7 38,7 @@ std::chrono::milliseconds TimedEvent::get_timeout() const
   return std::chrono::duration_cast<std::chrono::milliseconds>(this->time_point - now);
 }
 
-void TimedEvent::execute()
+void TimedEvent::execute() const
 {
   this->callback();
 }

@@ 4,7 4,7 @@
 #include <functional>
 #include <string>
 #include <chrono>
-#include <list>
+#include <vector>
 
 using namespace std::literals::chrono_literals;
 


@@ 30,12 30,12 @@ public:
   explicit TimedEvent(std::chrono::milliseconds&& duration,
                       std::function<void()> callback, const std::string& name="");
 
-  explicit TimedEvent(TimedEvent&&);
+  explicit TimedEvent(TimedEvent&&) = default;
+  TimedEvent& operator=(TimedEvent&&) = default;
   ~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.


@@ 48,7 48,7 @@ public:
    * returned value is 0 instead. The value cannot then be negative.
    */
   std::chrono::milliseconds get_timeout() const;
-  void execute();
+  void execute() const;
   const std::string& get_name() const;
 
 private:


@@ 59,22 59,22 @@ private:
   /**
    * The function to execute.
    */
-  const std::function<void()> callback;
+  std::function<void()> callback;
   /**
    * Whether or not this events repeats itself until it is destroyed.
    */
-  const bool repeat;
+  bool repeat;
   /**
    * This value is added to the time_point each time the event is executed,
    * if repeat is true. Otherwise it is ignored.
    */
-  const std::chrono::milliseconds repeat_delay;
+  std::chrono::milliseconds repeat_delay;
   /**
    * A name that is used to identify that event. If you want to find your
    * event (for example if you want to cancel it), the name should be
    * unique.
    */
-  const std::string name;
+  std::string name;
 };
 
 /**


@@ 128,7 128,7 @@ public:
   std::size_t size() const;
 
 private:
-  std::list<TimedEvent> events;
+  std::vector<TimedEvent> events;
   explicit TimedEventsManager() = default;
 };
 

@@ 250,7 250,7 @@ private:
    * request and we need a response from IRC to be able to provide the
    * response iq.
    */
-  std::list<irc_responder_callback_t> waiting_irc;
+  std::vector<irc_responder_callback_t> waiting_irc;
   /**
    * Keep track of which resource is in which channel.
    */

@@ 532,9 532,9 @@ Bridge* BiboumiComponent::find_user_bridge(const std::string& full_jid)
     }
 }
 
-std::list<Bridge*> BiboumiComponent::get_bridges() const
+std::vector<Bridge*> BiboumiComponent::get_bridges() const
 {
-  std::list<Bridge*> res;
+  std::vector<Bridge*> res;
   for (auto it = this->bridges.begin(); it != this->bridges.end(); ++it)
     res.push_back(it->second.get());
   return res;

@@ 39,7 39,7 @@ public:
   /**
    * Return a list of all the managed bridges.
    */
-  std::list<Bridge*> get_bridges() const;
+  std::vector<Bridge*> get_bridges() const;
 
   /**
    * Send a "close" message to all our connected peers.  That message