[sonar] Remove custom destructors for examples/s4u/.

diff --git a/examples/s4u/app-bittorrent/s4u-bittorrent.hpp b/examples/s4u/app-bittorrent/s4u-bittorrent.hpp
index 19551d0..b2113ca 100644 (file)
--- a/examples/s4u/app-bittorrent/s4u-bittorrent.hpp
+++ b/examples/s4u/app-bittorrent/s4u-bittorrent.hpp
@@ -75,11 +75,11 @@ public:
       , block_length(block_length){};
   Message(e_message_type type, int peer_id, simgrid::s4u::Mailbox* return_mailbox, int piece)
       : type(type), peer_id(peer_id), return_mailbox(return_mailbox), piece(piece){};
-  ~Message() = default;
 };
 
 class HostBittorrent {
-  RngStream stream_;
+  std::unique_ptr<std::remove_pointer<RngStream>::type, std::function<void(RngStream)>> stream_ = {
+      nullptr, [](RngStream stream) { RngStream_DeleteStream(&stream); }};
   simgrid::s4u::Host* host = nullptr;
 
 public:
@@ -88,14 +88,12 @@ public:
   explicit HostBittorrent(simgrid::s4u::Host* ptr) : host(ptr)
   {
     std::string descr = std::string("RngSream<") + host->get_cname() + ">";
-    stream_           = RngStream_CreateStream(descr.c_str());
+    stream_.reset(RngStream_CreateStream(descr.c_str()));
   }
   HostBittorrent(const HostBittorrent&) = delete;
   HostBittorrent& operator=(const HostBittorrent&) = delete;
 
-  ~HostBittorrent() { RngStream_DeleteStream(&stream_); };
-
-  RngStream getStream() { return stream_; };
+  RngStream getStream() { return stream_.get(); };
 };
 
 #endif /* BITTORRENT_BITTORRENT_HPP_ */

diff --git a/examples/s4u/app-bittorrent/s4u-peer.cpp b/examples/s4u/app-bittorrent/s4u-peer.cpp
index f28d40b..1f28b3e 100644 (file)
--- a/examples/s4u/app-bittorrent/s4u-peer.cpp
+++ b/examples/s4u/app-bittorrent/s4u-peer.cpp
@@ -50,18 +50,11 @@ Peer::Peer(std::vector<std::string> args)
     bitfield_       = (1U << FILE_PIECES) - 1U;
     bitfield_blocks = (1ULL << (FILE_PIECES * PIECES_BLOCKS)) - 1ULL;
   }
-  pieces_count = new short[FILE_PIECES]{0};
+  pieces_count.resize(FILE_PIECES);
 
   XBT_INFO("Hi, I'm joining the network with id %d", id);
 }
 
-Peer::~Peer()
-{
-  for (auto const& peer : connected_peers)
-    delete peer.second;
-  delete[] pieces_count;
-}
-
 /** Peer main function */
 void Peer::operator()()
 {
@@ -100,9 +93,9 @@ bool Peer::getPeersFromTracker()
   try {
     TrackerAnswer* answer = static_cast<TrackerAnswer*>(mailbox_->get(GET_PEERS_TIMEOUT));
     // Add the peers the tracker gave us to our peer list.
-    for (auto const& peer_id : *answer->getPeers())
+    for (auto const& peer_id : answer->getPeers())
       if (id != peer_id)
-        connected_peers[peer_id] = new Connection(peer_id);
+        connected_peers.emplace(peer_id, Connection(peer_id));
     delete answer;
   } catch (simgrid::TimeoutError& e) {
     XBT_DEBUG("Timeout expired when requesting peers to tracker");
@@ -114,10 +107,10 @@ bool Peer::getPeersFromTracker()
 void Peer::sendHandshakeToAllPeers()
 {
   for (auto const& kv : connected_peers) {
-    Connection* remote_peer = kv.second;
+    const Connection& remote_peer = kv.second;
     Message* handshake      = new Message(MESSAGE_HANDSHAKE, id, mailbox_);
-    remote_peer->mailbox_->put_init(handshake, MESSAGE_HANDSHAKE_SIZE)->detach();
-    XBT_DEBUG("Sending a HANDSHAKE to %d", remote_peer->id);
+    remote_peer.mailbox_->put_init(handshake, MESSAGE_HANDSHAKE_SIZE)->detach();
+    XBT_DEBUG("Sending a HANDSHAKE to %d", remote_peer.id);
   }
 }
 
@@ -148,8 +141,8 @@ void Peer::sendHaveToAllPeers(unsigned int piece)
 {
   XBT_DEBUG("Sending HAVE message to all my peers");
   for (auto const& kv : connected_peers) {
-    Connection* remote_peer = kv.second;
-    remote_peer->mailbox_->put_init(new Message(MESSAGE_HAVE, id, mailbox_, piece), MESSAGE_HAVE_SIZE)->detach();
+    const Connection& remote_peer = kv.second;
+    remote_peer.mailbox_->put_init(new Message(MESSAGE_HAVE, id, mailbox_, piece), MESSAGE_HAVE_SIZE)->detach();
   }
 }
 
@@ -217,7 +210,7 @@ int Peer::nbInterestedPeers()
 {
   int nb = 0;
   for (auto const& kv : connected_peers)
-    if (kv.second->interested)
+    if (kv.second.interested)
       nb++;
   return nb;
 }
@@ -298,7 +291,7 @@ void Peer::handleMessage()
   XBT_DEBUG("Received a %s message from %s", type_names[message->type], message->return_mailbox->get_cname());
 
   auto known_peer         = connected_peers.find(message->peer_id);
-  Connection* remote_peer = (known_peer == connected_peers.end()) ? nullptr : known_peer->second;
+  Connection* remote_peer = (known_peer == connected_peers.end()) ? nullptr : &known_peer->second;
   xbt_assert(remote_peer != nullptr || message->type == MESSAGE_HANDSHAKE,
              "The impossible did happened: A not-in-our-list peer sent us a message.");
 
@@ -307,7 +300,7 @@ void Peer::handleMessage()
       // Check if the peer is in our connection list.
       if (remote_peer == nullptr) {
         XBT_DEBUG("This peer %d was unknown, answer to its handshake", message->peer_id);
-        connected_peers[message->peer_id] = new Connection(message->peer_id);
+        connected_peers.emplace(message->peer_id, Connection(message->peer_id));
         sendMessage(message->return_mailbox, MESSAGE_HANDSHAKE, MESSAGE_HANDSHAKE_SIZE);
       }
       // Send our bitfield to the peer
@@ -551,13 +544,12 @@ void Peer::updateChokedPeers()
 
   /**If we are currently seeding, we unchoke the peer which has been unchoked the last time.*/
   if (hasFinished()) {
-    Connection* remote_peer;
     double unchoke_time = simgrid::s4u::Engine::get_clock() + 1;
-    for (auto const& kv : connected_peers) {
-      remote_peer = kv.second;
-      if (remote_peer->last_unchoke < unchoke_time && remote_peer->interested && remote_peer->choked_upload) {
-        unchoke_time = remote_peer->last_unchoke;
-        chosen_peer  = remote_peer;
+    for (auto& kv : connected_peers) {
+      Connection& remote_peer = kv.second;
+      if (remote_peer.last_unchoke < unchoke_time && remote_peer.interested && remote_peer.choked_upload) {
+        unchoke_time = remote_peer.last_unchoke;
+        chosen_peer  = &remote_peer;
       }
     }
   } else {
@@ -566,12 +558,10 @@ void Peer::updateChokedPeers()
       int j = 0;
       do {
         // We choose a random peer to unchoke.
-        std::unordered_map<int, Connection*>::iterator chosen_peer_it = connected_peers.begin();
+        std::unordered_map<int, Connection>::iterator chosen_peer_it = connected_peers.begin();
         std::advance(chosen_peer_it, RngStream_RandInt(stream, 0, connected_peers.size() - 1));
-        chosen_peer = chosen_peer_it->second;
-        if (chosen_peer == nullptr)
-          THROWF(unknown_error, 0, "A peer should have be selected at this point");
-        else if (not chosen_peer->interested || not chosen_peer->choked_upload)
+        chosen_peer = &chosen_peer_it->second;
+        if (not chosen_peer->interested || not chosen_peer->choked_upload)
           chosen_peer = nullptr;
         else
           XBT_DEBUG("Nothing to do, keep going");
@@ -580,11 +570,11 @@ void Peer::updateChokedPeers()
     } else {
       // Use the "fastest download" policy.
       double fastest_speed = 0.0;
-      for (auto const& kv : connected_peers) {
-        Connection* remote_peer = kv.second;
-        if (remote_peer->peer_speed > fastest_speed && remote_peer->choked_upload && remote_peer->interested) {
-          chosen_peer   = remote_peer;
-          fastest_speed = remote_peer->peer_speed;
+      for (auto& kv : connected_peers) {
+        Connection& remote_peer = kv.second;
+        if (remote_peer.peer_speed > fastest_speed && remote_peer.choked_upload && remote_peer.interested) {
+          fastest_speed = remote_peer.peer_speed;
+          chosen_peer   = &remote_peer;
         }
       }
     }
@@ -617,20 +607,20 @@ void Peer::updateChokedPeers()
 /** @brief Update "interested" state of peers: send "not interested" to peers that don't have any more pieces we want.*/
 void Peer::updateInterestedAfterReceive()
 {
-  for (auto const& kv : connected_peers) {
-    Connection* remote_peer = kv.second;
-    if (remote_peer->am_interested) {
+  for (auto& kv : connected_peers) {
+    Connection& remote_peer = kv.second;
+    if (remote_peer.am_interested) {
       bool interested = false;
       // Check if the peer still has a piece we want.
       for (unsigned int i = 0; i < FILE_PIECES; i++)
-        if (hasNotPiece(i) && remote_peer->hasPiece(i)) {
+        if (hasNotPiece(i) && remote_peer.hasPiece(i)) {
           interested = true;
           break;
         }
 
       if (not interested) { // no more piece to download from connection
-        remote_peer->am_interested = false;
-        sendMessage(remote_peer->mailbox_, MESSAGE_NOTINTERESTED, MESSAGE_NOTINTERESTED_SIZE);
+        remote_peer.am_interested = false;
+        sendMessage(remote_peer.mailbox_, MESSAGE_NOTINTERESTED, MESSAGE_NOTINTERESTED_SIZE);
       }
     }
   }

diff --git a/examples/s4u/app-bittorrent/s4u-peer.hpp b/examples/s4u/app-bittorrent/s4u-peer.hpp
index 2737649..fa0418d 100644 (file)
--- a/examples/s4u/app-bittorrent/s4u-peer.hpp
+++ b/examples/s4u/app-bittorrent/s4u-peer.hpp
@@ -24,7 +24,6 @@ public:
   bool choked_download = true;  // Indicates if the peer has choked the current peer
 
   explicit Connection(int id) : id(id), mailbox_(simgrid::s4u::Mailbox::by_name(std::to_string(id))){};
-  ~Connection() = default;
   void addSpeedValue(double speed) { peer_speed = peer_speed * 0.6 + speed * 0.4; }
   bool hasPiece(unsigned int piece) { return bitfield & 1U << piece; }
 };
@@ -34,12 +33,12 @@ class Peer {
   double deadline;
   RngStream stream;
   simgrid::s4u::Mailbox* mailbox_;
-  std::unordered_map<int, Connection*> connected_peers;
+  std::unordered_map<int, Connection> connected_peers;
   std::set<Connection*> active_peers; // active peers list
 
   unsigned int bitfield_             = 0;       // list of pieces the peer has.
   unsigned long long bitfield_blocks = 0;       // list of blocks the peer has.
-  short* pieces_count                = nullptr; // number of peers that have each piece.
+  std::vector<short> pieces_count;              // number of peers that have each piece.
   unsigned int current_pieces        = 0;       // current pieces the peer is downloading
   double begin_receive_time = 0; // time when the receiving communication has begun, useful for calculating host speed.
   int round_                = 0; // current round for the chocking algorithm.
@@ -50,7 +49,6 @@ public:
   explicit Peer(std::vector<std::string> args);
   Peer(const Peer&) = delete;
   Peer& operator=(const Peer&) = delete;
-  ~Peer();
   void operator()();
 
   std::string getStatus();

diff --git a/examples/s4u/app-bittorrent/s4u-tracker.cpp b/examples/s4u/app-bittorrent/s4u-tracker.cpp
index 4e41ae8..f51e55d 100644 (file)
--- a/examples/s4u/app-bittorrent/s4u-tracker.cpp
+++ b/examples/s4u/app-bittorrent/s4u-tracker.cpp
@@ -56,7 +56,7 @@ void Tracker::operator()()
         do {
           next_peer = known_peers.begin();
           std::advance(next_peer, RngStream_RandInt(stream, 0, nb_known_peers - 1));
-        } while (ta->getPeers()->find(*next_peer) != ta->getPeers()->end());
+        } while (ta->getPeers().find(*next_peer) != ta->getPeers().end());
         ta->addPeer(*next_peer);
         tried++;
       }

diff --git a/examples/s4u/app-bittorrent/s4u-tracker.hpp b/examples/s4u/app-bittorrent/s4u-tracker.hpp
index 4755919..d4af5d6 100644 (file)
--- a/examples/s4u/app-bittorrent/s4u-tracker.hpp
+++ b/examples/s4u/app-bittorrent/s4u-tracker.hpp
@@ -17,21 +17,17 @@ class TrackerQuery {
 public:
   explicit TrackerQuery(int peer_id, simgrid::s4u::Mailbox* return_mailbox)
       : peer_id(peer_id), return_mailbox(return_mailbox){};
-  ~TrackerQuery() = default;
   int getPeerId() { return peer_id; }
   simgrid::s4u::Mailbox* getReturnMailbox() { return return_mailbox; }
 };
 
 class TrackerAnswer {
   // int interval; // how often the peer should contact the tracker (unused for now)
-  std::set<int>* peers; // the peer list the peer has asked for.
+  std::set<int> peers; // the peer list the peer has asked for.
 public:
-  explicit TrackerAnswer(int /*interval*/) /*: interval(interval)*/ { peers = new std::set<int>; }
-  TrackerAnswer(const TrackerAnswer&)                                       = delete;
-  TrackerAnswer& operator=(const TrackerAnswer&) = delete;
-  ~TrackerAnswer() { delete peers; };
-  void addPeer(int peer) { peers->insert(peer); }
-  std::set<int>* getPeers() { return peers; }
+  explicit TrackerAnswer(int /*interval*/) /*: interval(interval)*/ {}
+  void addPeer(int peer) { peers.insert(peer); }
+  const std::set<int>& getPeers() { return peers; }
 };
 
 class Tracker {

diff --git a/examples/s4u/dht-chord/s4u-dht-chord-node.cpp b/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
index f69461b..833f3eb 100644 (file)
--- a/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
+++ b/examples/s4u/dht-chord/s4u-dht-chord-node.cpp
@@ -55,11 +55,7 @@ Node::Node(std::vector<std::string> args)
   stream             = simgrid::s4u::this_actor::get_host()->extension<HostChord>()->getStream();
   mailbox_           = simgrid::s4u::Mailbox::by_name(std::to_string(id_));
   next_finger_to_fix = 0;
-  fingers_           = new int[nb_bits];
-
-  for (int i = 0; i < nb_bits; i++) {
-    fingers_[i] = id_;
-  }
+  fingers_.resize(nb_bits, id_);
 
   if (args.size() == 3) { // first ring
     deadline_   = std::stod(args[2]);
@@ -74,10 +70,6 @@ Node::Node(std::vector<std::string> args)
   }
 }
 
-Node::~Node()
-{
-  delete[] fingers_;
-}
 /* Makes the current node join the ring, knowing the id of a node already in the ring
  *
  * @param known_id id of a node already in the ring

diff --git a/examples/s4u/dht-chord/s4u-dht-chord.hpp b/examples/s4u/dht-chord/s4u-dht-chord.hpp
index ba0ac1f..12b6921 100644 (file)
--- a/examples/s4u/dht-chord/s4u-dht-chord.hpp
+++ b/examples/s4u/dht-chord/s4u-dht-chord.hpp
@@ -22,7 +22,8 @@ extern int nb_keys;
 extern int timeout;
 
 class HostChord {
-  RngStream stream_;
+  std::unique_ptr<std::remove_pointer<RngStream>::type, std::function<void(RngStream)>> stream_ = {
+      nullptr, [](RngStream stream) { RngStream_DeleteStream(&stream); }};
   simgrid::s4u::Host* host = nullptr;
 
 public:
@@ -31,14 +32,12 @@ public:
   explicit HostChord(simgrid::s4u::Host* ptr) : host(ptr)
   {
     std::string descr = std::string("RngSream<") + host->get_cname() + ">";
-    stream_           = RngStream_CreateStream(descr.c_str());
+    stream_.reset(RngStream_CreateStream(descr.c_str()));
   }
   HostChord(const HostChord&) = delete;
   HostChord& operator=(const HostChord&) = delete;
 
-  ~HostChord() { RngStream_DeleteStream(&stream_); };
-
-  RngStream getStream() { return stream_; };
+  RngStream getStream() { return stream_.get(); };
 };
 
 /* Types of tasks exchanged between nodes. */
@@ -68,8 +67,6 @@ public:
   {
   }
 
-  ~ChordMessage() = default;
-
   static void destroy(void* message);
 };
 
@@ -81,7 +78,7 @@ class Node {
   int id_;                           // my id
   int pred_id_ = -1;                 // predecessor id
   simgrid::s4u::Mailbox* mailbox_;   // my mailbox
-  int* fingers_;                     // finger table,(fingers[0] is my successor)
+  std::vector<int> fingers_;         // finger table,(fingers[0] is my successor)
   int next_finger_to_fix;            // index of the next finger to fix in fix_fingers()
   RngStream stream;
 
@@ -89,7 +86,6 @@ public:
   explicit Node(std::vector<std::string> args);
   Node(const Node&) = delete;
   Node& operator=(const Node&) = delete;
-  ~Node();
   void join(int known_id);
   void leave();
   void notifyAndQuit();