Make single argument constructor LinkInRoute::LinkInRoute(const Link*) explicit.

diff --git a/docs/source/Platform_cpp.rst b/docs/source/Platform_cpp.rst
index f3022b9..a7b8e93 100644 (file)
--- a/docs/source/Platform_cpp.rst
+++ b/docs/source/Platform_cpp.rst
@@ -171,7 +171,7 @@ Note that the leaves and loopback links are defined through callbacks, as follow
       const sg4::Host* gpu = host_zone->create_host(gpu_name, 1e12)->seal();
       /* connecting them */
       sg4::Link* link   = host_zone->create_link("link-" + cpu_name, 10e9)->set_latency(10e-9)->seal();
-      host_zone->add_route(cpu->get_netpoint(), gpu->get_netpoint(), nullptr, nullptr, std::vector<sg4::Link*>{link});
+      host_zone->add_route(cpu->get_netpoint(), gpu->get_netpoint(), nullptr, nullptr, {sg4::LinkInRoute(link)});
 
       host_zone->seal();
       /* cpu is the gateway for this host */

diff --git a/examples/cpp/clusters-multicpu/s4u-clusters-multicpu.cpp b/examples/cpp/clusters-multicpu/s4u-clusters-multicpu.cpp
index 9feae83..ec90b02 100644 (file)
--- a/examples/cpp/clusters-multicpu/s4u-clusters-multicpu.cpp
+++ b/examples/cpp/clusters-multicpu/s4u-clusters-multicpu.cpp
@@ -114,8 +114,8 @@ create_hostzone(const sg4::NetZone* zone, const std::vector<unsigned int>& /*coo
     sg4::SplitDuplexLink* link = host_zone->create_split_duplex_link("link-" + cpu_name, link_bw);
     link->set_latency(link_lat)->seal();
     /* connecting CPU to outer world */
-    host_zone->add_route(host->get_netpoint(), nullptr, nullptr, nullptr,
-                         std::vector<sg4::LinkInRoute>{{link, sg4::LinkInRoute::Direction::UP}}, true);
+    host_zone->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, {{link, sg4::LinkInRoute::Direction::UP}},
+                         true);
   }
   /* seal newly created netzone */
   host_zone->seal();

diff --git a/examples/cpp/comm-serialize/s4u-comm-serialize.cpp b/examples/cpp/comm-serialize/s4u-comm-serialize.cpp
index fa2d501..8691b45 100644 (file)
--- a/examples/cpp/comm-serialize/s4u-comm-serialize.cpp
+++ b/examples/cpp/comm-serialize/s4u-comm-serialize.cpp
@@ -109,7 +109,7 @@ int main(int argc, char* argv[])
 
   /* create routes between nodes */
   zone->add_route(sender->get_netpoint(), receiver->get_netpoint(), nullptr, nullptr,
-                  std::vector<sg4::LinkInRoute>{{link, sg4::LinkInRoute::Direction::UP}}, true);
+                  {{link, sg4::LinkInRoute::Direction::UP}}, true);
   zone->seal();
 
   /* create actors Sender/Receiver */

diff --git a/examples/cpp/network-factors/s4u-network-factors.cpp b/examples/cpp/network-factors/s4u-network-factors.cpp
index 922f0b4..3f8598e 100644 (file)
--- a/examples/cpp/network-factors/s4u-network-factors.cpp
+++ b/examples/cpp/network-factors/s4u-network-factors.cpp
@@ -78,12 +78,10 @@ static void load_platform()
     const sg4::Link* l = root->create_split_duplex_link(hostname, BW_REMOTE)->set_latency(LATENCY)->seal();
 
     /* add link UP/DOWN for communications from the host */
-    root->add_route(host->get_netpoint(), nullptr, nullptr, nullptr,
-                    std::vector<sg4::LinkInRoute>{{l, sg4::LinkInRoute::Direction::UP}}, true);
+    root->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, {{l, sg4::LinkInRoute::Direction::UP}}, true);
 
     const sg4::Link* loopback = root->create_link(hostname + "_loopback", BW_LOCAL)->set_latency(LATENCY)->seal();
-    root->add_route(host->get_netpoint(), host->get_netpoint(), nullptr, nullptr,
-                    std::vector<sg4::LinkInRoute>{loopback});
+    root->add_route(host->get_netpoint(), host->get_netpoint(), nullptr, nullptr, {sg4::LinkInRoute(loopback)});
   }
 
   root->seal();

diff --git a/examples/cpp/plugin-prodcons/s4u-plugin-prodcons.cpp b/examples/cpp/plugin-prodcons/s4u-plugin-prodcons.cpp
index 0ad772e..fc20568 100644 (file)
--- a/examples/cpp/plugin-prodcons/s4u-plugin-prodcons.cpp
+++ b/examples/cpp/plugin-prodcons/s4u-plugin-prodcons.cpp
@@ -65,8 +65,8 @@ int main(int argc, char* argv[])
     std::string linkname = std::string("cluster") + "_link_" + std::to_string(i);
     const auto* link     = cluster->create_split_duplex_link(linkname, "1Gbps");
 
-    cluster->add_route(host->get_netpoint(), nullptr, nullptr, nullptr,
-                       std::vector<sg4::LinkInRoute>{{link, sg4::LinkInRoute::Direction::UP}}, true);
+    cluster->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, {{link, sg4::LinkInRoute::Direction::UP}},
+                       true);
   }
 
   auto* router = cluster->create_router("cluster_router");

diff --git a/examples/platforms/griffon.cpp b/examples/platforms/griffon.cpp
index 4d04042..c50ec1b 100644 (file)
--- a/examples/platforms/griffon.cpp
+++ b/examples/platforms/griffon.cpp
@@ -28,6 +28,7 @@ create_cabinet(const sg4::NetZone* root, const std::string& name, const std::vec
 
   /* create the backbone link */
   const sg4::Link* l_bb = cluster->create_link("backbone-" + name, "1.25GBps")->seal();
+  sg4::LinkInRoute backbone(l_bb);
 
   /* create all hosts and connect them to outside world */
   for (const auto& id : radicals) {
@@ -39,7 +40,7 @@ create_cabinet(const sg4::NetZone* root, const std::string& name, const std::vec
 
     /* add link and backbone for communications from the host */
     cluster->add_route(host->get_netpoint(), nullptr, nullptr, nullptr,
-                       std::vector<sg4::LinkInRoute>{{link, sg4::LinkInRoute::Direction::UP}, l_bb}, true);
+                       {{link, sg4::LinkInRoute::Direction::UP}, backbone}, true);
   }
 
   /* create router */
@@ -77,7 +78,8 @@ void load_platform(const sg4::Engine& /*e*/)
   simgrid::kernel::routing::NetPoint* router;
 
   /* create top link */
-  const sg4::Link* link = root->create_link("backbone", "1.25GBps")->set_latency("24us")->seal();
+  const sg4::Link* l_bb = root->create_link("backbone", "1.25GBps")->set_latency("24us")->seal();
+  sg4::LinkInRoute backbone{l_bb};
 
   /* create cabinet1 */
   std::vector<int> rad(32);
@@ -86,19 +88,19 @@ void load_platform(const sg4::Engine& /*e*/)
   rad[rad.size() - 2]        = 59;
   rad[rad.size() - 3]        = 58;
   std::tie(cab_zone, router) = create_cabinet(root, "cabinet1", rad);
-  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {link});
+  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {backbone});
 
   /* create cabinet2 */
   rad.resize(28);
   std::iota(rad.begin(), rad.end(), 30); // 30-57
   std::tie(cab_zone, router) = create_cabinet(root, "cabinet2", rad);
-  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {link});
+  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {backbone});
 
   /* create cabinet3 */
   rad.resize(32);
   std::iota(rad.begin(), rad.end(), 61); // 61-92
   std::tie(cab_zone, router) = create_cabinet(root, "cabinet3", rad);
-  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {link});
+  root->add_route(cab_zone->get_netpoint(), nullptr, router, nullptr, {backbone});
 
   root->seal();
-}
\ No newline at end of file
+}

diff --git a/examples/platforms/routing_cluster.cpp b/examples/platforms/routing_cluster.cpp
index e5fc346..4bc6f25 100644 (file)
--- a/examples/platforms/routing_cluster.cpp
+++ b/examples/platforms/routing_cluster.cpp
@@ -38,13 +38,14 @@ static void create_cluster(const sg4::NetZone* root, const std::string& cluster_
     if (hostname != single_link_host) {
       l_down = cluster->create_link(hostname + "_down", std::vector<double>{1.25e8})->set_latency(0.0001)->seal();
     }
+    sg4::LinkInRoute backbone{l_bb};
+    sg4::LinkInRoute link_up{l_up};
+    sg4::LinkInRoute link_down{l_down};
 
     /* add link UP and backbone for communications from the host */
-    cluster->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, std::vector<sg4::LinkInRoute>{l_up, l_bb},
-                       false);
+    cluster->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, {link_up, backbone}, false);
     /* add backbone and link DOWN for communications to the host */
-    cluster->add_route(nullptr, host->get_netpoint(), nullptr, nullptr, std::vector<sg4::LinkInRoute>{l_bb, l_down},
-                       false);
+    cluster->add_route(nullptr, host->get_netpoint(), nullptr, nullptr, {backbone, link_down}, false);
   }
 
   /* create router */
@@ -82,9 +83,10 @@ void load_platform(const sg4::Engine& e)
   create_cluster(root, "2", {"host4", "host5", "host6"}, "host6");
 
   /* connect both cluster through their respective routers */
-  const sg4::Link* link = root->create_link("link1-2", std::vector<double>{2.25e9})->set_latency(5e-4)->seal();
+  const sg4::Link* l = root->create_link("link1-2", std::vector<double>{2.25e9})->set_latency(5e-4)->seal();
+  sg4::LinkInRoute link{l};
   root->add_route(e.netpoint_by_name_or_null("cluster1"), e.netpoint_by_name_or_null("cluster2"),
                   e.netpoint_by_name_or_null("router1"), e.netpoint_by_name_or_null("router2"), {link});
 
   root->seal();
-}
\ No newline at end of file
+}

diff --git a/include/simgrid/s4u/Link.hpp b/include/simgrid/s4u/Link.hpp
index 4f1075e..bcacca0 100644 (file)
--- a/include/simgrid/s4u/Link.hpp
+++ b/include/simgrid/s4u/Link.hpp
@@ -189,7 +189,7 @@ class XBT_PUBLIC LinkInRoute {
 public:
   enum class Direction { UP = 2, DOWN = 1, NONE = 0 };
 
-  LinkInRoute(const Link* link) : link_(link) {}
+  explicit LinkInRoute(const Link* link) : link_(link) {}
   LinkInRoute(const Link* link, Direction d) : link_(link), direction_(d) {}
 
   /** @brief Get direction of this link in the route: UP or DOWN */

diff --git a/src/bindings/lua/lua_platf.cpp b/src/bindings/lua/lua_platf.cpp
index f7edcdb..31f39b9 100644 (file)
--- a/src/bindings/lua/lua_platf.cpp
+++ b/src/bindings/lua/lua_platf.cpp
@@ -347,13 +347,12 @@ int console_add_route(lua_State *L) {
   boost::split(names, str, boost::is_any_of(", \t\r\n"));
   if (names.empty()) {
     /* unique name */
-    route.link_list.emplace_back(simgrid::s4u::LinkInRoute(simgrid::s4u::Link::by_name(lua_tostring(L, -1))));
+    route.link_list.emplace_back(simgrid::s4u::Link::by_name(lua_tostring(L, -1)));
   } else {
     // Several names separated by , \t\r\n
     for (auto const& name : names) {
       if (name.length() > 0) {
-        simgrid::s4u::LinkInRoute link(simgrid::s4u::Link::by_name(name));
-        route.link_list.emplace_back(link);
+        route.link_list.emplace_back(simgrid::s4u::Link::by_name(name));
       }
     }
   }
@@ -413,13 +412,12 @@ int console_add_ASroute(lua_State *L) {
   boost::split(names, str, boost::is_any_of(", \t\r\n"));
   if (names.empty()) {
     /* unique name with no comma */
-    ASroute.link_list.emplace_back(simgrid::s4u::LinkInRoute(simgrid::s4u::Link::by_name(lua_tostring(L, -1))));
+    ASroute.link_list.emplace_back(simgrid::s4u::Link::by_name(lua_tostring(L, -1)));
   } else {
     // Several names separated by , \t\r\n
     for (auto const& name : names) {
       if (name.length() > 0) {
-        simgrid::s4u::LinkInRoute link(simgrid::s4u::Link::by_name(name));
-        ASroute.link_list.emplace_back(link);
+        ASroute.link_list.emplace_back(simgrid::s4u::Link::by_name(name));
       }
     }
   }

diff --git a/src/kernel/routing/DijkstraZone_test.cpp b/src/kernel/routing/DijkstraZone_test.cpp
index e941407..6fbbd30 100644 (file)
--- a/src/kernel/routing/DijkstraZone_test.cpp
+++ b/src/kernel/routing/DijkstraZone_test.cpp
@@ -31,6 +31,6 @@ TEST_CASE("kernel::routing::DijkstraZone: mix new routes and hosts", "")
     std::string cpu_name          = "CPU" + std::to_string(i);
     const simgrid::s4u::Host* cpu = zone->create_host(cpu_name, 1e9)->seal();
     REQUIRE_NOTHROW(zone->add_route(cpu->get_netpoint(), nic->get_netpoint(), nullptr, nullptr,
-                                    std::vector<simgrid::s4u::LinkInRoute>{link}, true));
+                                    {simgrid::s4u::LinkInRoute(link)}, true));
   }
 }

diff --git a/src/kernel/routing/FloydZone_test.cpp b/src/kernel/routing/FloydZone_test.cpp
index b66397f..0d36328 100644 (file)
--- a/src/kernel/routing/FloydZone_test.cpp
+++ b/src/kernel/routing/FloydZone_test.cpp
@@ -30,6 +30,6 @@ TEST_CASE("kernel::routing::FloydZone: mix new routes and hosts", "")
     std::string cpu_name          = "CPU" + std::to_string(i);
     const simgrid::s4u::Host* cpu = zone->create_host(cpu_name, 1e9)->seal();
     REQUIRE_NOTHROW(zone->add_route(cpu->get_netpoint(), nic->get_netpoint(), nullptr, nullptr,
-                                    std::vector<simgrid::s4u::LinkInRoute>{link}, true));
+                                    {simgrid::s4u::LinkInRoute(link)}, true));
   }
 }

diff --git a/src/kernel/routing/FullZone_test.cpp b/src/kernel/routing/FullZone_test.cpp
index ba308a2..ef1407f 100644 (file)
--- a/src/kernel/routing/FullZone_test.cpp
+++ b/src/kernel/routing/FullZone_test.cpp
@@ -30,6 +30,6 @@ TEST_CASE("kernel::routing::FullZone: mix new routes and hosts", "[bug]")
     std::string cpu_name          = "CPU" + std::to_string(i);
     const simgrid::s4u::Host* cpu = zone->create_host(cpu_name, 1e9)->seal();
     REQUIRE_NOTHROW(zone->add_route(cpu->get_netpoint(), nic->get_netpoint(), nullptr, nullptr,
-                                    std::vector<simgrid::s4u::LinkInRoute>{link}, true));
+                                    {simgrid::s4u::LinkInRoute(link)}, true));
   }
 }

diff --git a/src/kernel/routing/StarZone_test.cpp b/src/kernel/routing/StarZone_test.cpp
index 934af82..afc79b6 100644 (file)
--- a/src/kernel/routing/StarZone_test.cpp
+++ b/src/kernel/routing/StarZone_test.cpp
@@ -287,7 +287,7 @@ TEST_CASE("kernel::routing::StarZone: mix new routes and hosts", "")
   for (int i = 0; i < 10; i++) {
     std::string cpu_name          = "CPU" + std::to_string(i);
     const simgrid::s4u::Host* cpu = zone->create_host(cpu_name, 1e9)->seal();
-    REQUIRE_NOTHROW(zone->add_route(cpu->get_netpoint(), nullptr, nullptr, nullptr,
-                                    std::vector<simgrid::s4u::LinkInRoute>{link}, true));
+    REQUIRE_NOTHROW(
+        zone->add_route(cpu->get_netpoint(), nullptr, nullptr, nullptr, {simgrid::s4u::LinkInRoute(link)}, true));
   }
 }

diff --git a/src/kernel/routing/VivaldiZone.cpp b/src/kernel/routing/VivaldiZone.cpp
index 8ac7639..e712e09 100644 (file)
--- a/src/kernel/routing/VivaldiZone.cpp
+++ b/src/kernel/routing/VivaldiZone.cpp
@@ -66,8 +66,8 @@ void VivaldiZone::set_peer_link(NetPoint* netpoint, double bw_in, double bw_out)
   std::string link_down      = "link_" + netpoint->get_name() + "_DOWN";
   const auto* linkUp         = create_link(link_up, std::vector<double>{bw_out})->seal();
   const auto* linkDown       = create_link(link_down, std::vector<double>{bw_in})->seal();
-  add_route(netpoint, nullptr, nullptr, nullptr, std::vector<s4u::LinkInRoute>{linkUp}, false);
-  add_route(nullptr, netpoint, nullptr, nullptr, std::vector<s4u::LinkInRoute>{linkDown}, false);
+  add_route(netpoint, nullptr, nullptr, nullptr, {s4u::LinkInRoute(linkUp)}, false);
+  add_route(nullptr, netpoint, nullptr, nullptr, {s4u::LinkInRoute(linkDown)}, false);
 }
 
 void VivaldiZone::get_local_route(const NetPoint* src, const NetPoint* dst, Route* route, double* lat)

diff --git a/src/surf/sg_platf.cpp b/src/surf/sg_platf.cpp
index 50c4892..0ded0be 100644 (file)
--- a/src/surf/sg_platf.cpp
+++ b/src/surf/sg_platf.cpp
@@ -294,7 +294,7 @@ static void sg_platf_new_cluster_flat(simgrid::kernel::routing::ClusterCreationA
                                  ->seal();
 
       zone->add_route(host->get_netpoint(), host->get_netpoint(), nullptr, nullptr,
-                      std::vector<simgrid::s4u::LinkInRoute>{loopback});
+                      {simgrid::s4u::LinkInRoute(loopback)});
     }
 
     // add a limiter link (shared link to account for maximal bandwidth of the node)
@@ -317,10 +317,10 @@ static void sg_platf_new_cluster_flat(simgrid::kernel::routing::ClusterCreationA
     /* adding routes */
     std::vector<simgrid::s4u::LinkInRoute> links;
     if (limiter)
-      links.push_back(limiter);
-    links.push_back(simgrid::s4u::LinkInRoute(link, simgrid::s4u::LinkInRoute::Direction::UP));
+      links.emplace_back(limiter);
+    links.emplace_back(link, simgrid::s4u::LinkInRoute::Direction::UP);
     if (backbone)
-      links.push_back(backbone);
+      links.emplace_back(backbone);
 
     zone->add_route(host->get_netpoint(), nullptr, nullptr, nullptr, links, true);
   }
@@ -358,12 +358,15 @@ static void sg_platf_cluster_set_hostlink(simgrid::kernel::routing::StarZone* zo
                                           const simgrid::s4u::Link* backbone)
 {
   XBT_DEBUG("Push Host_link for host '%s' to position %u", netpoint->get_cname(), netpoint->id());
+  simgrid::s4u::LinkInRoute linkUp{link_up};
+  simgrid::s4u::LinkInRoute linkDown{link_down};
   if (backbone) {
-    zone->add_route(netpoint, nullptr, nullptr, nullptr, {link_up, backbone}, false);
-    zone->add_route(nullptr, netpoint, nullptr, nullptr, {backbone, link_down}, false);
+    simgrid::s4u::LinkInRoute linkBB{backbone};
+    zone->add_route(netpoint, nullptr, nullptr, nullptr, {linkUp, linkBB}, false);
+    zone->add_route(nullptr, netpoint, nullptr, nullptr, {linkBB, linkDown}, false);
   } else {
-    zone->add_route(netpoint, nullptr, nullptr, nullptr, {link_up}, false);
-    zone->add_route(nullptr, netpoint, nullptr, nullptr, {link_down}, false);
+    zone->add_route(netpoint, nullptr, nullptr, nullptr, {linkUp}, false);
+    zone->add_route(nullptr, netpoint, nullptr, nullptr, {linkDown}, false);
   }
 }
 

diff --git a/src/surf/xml/surfxml_sax_cb.cpp b/src/surf/xml/surfxml_sax_cb.cpp
index 465b580..62947af 100644 (file)
--- a/src/surf/xml/surfxml_sax_cb.cpp
+++ b/src/surf/xml/surfxml_sax_cb.cpp
@@ -512,7 +512,7 @@ void STag_surfxml_link___ctn()
       dirname = "";
   }
   surf_parse_assert(link != nullptr, std::string("No such link: '") + A_surfxml_link___ctn_id + "'" + dirname);
-  parsed_link_list.emplace_back(simgrid::s4u::LinkInRoute(link, direction));
+  parsed_link_list.emplace_back(link, direction);
 }
 
 void ETag_surfxml_backbone()

diff --git a/teshsuite/s4u/seal-platform/seal-platform.cpp b/teshsuite/s4u/seal-platform/seal-platform.cpp
index bbc2fe8..f664448 100644 (file)
--- a/teshsuite/s4u/seal-platform/seal-platform.cpp
+++ b/teshsuite/s4u/seal-platform/seal-platform.cpp
@@ -70,7 +70,7 @@ static sg4::NetZone* create_zone(const sg4::NetZone* root, const std::string& id
     auto* host           = zone->create_host(hostname, 1e9);
     host->create_disk("disk-" + hostname, 1e9, 1e6);
     const auto* link = zone->create_link("link-" + hostname, 1e9);
-    zone->add_route(host->get_netpoint(), router, nullptr, nullptr, std::vector<sg4::LinkInRoute>{link});
+    zone->add_route(host->get_netpoint(), router, nullptr, nullptr, {sg4::LinkInRoute(link)});
   }
   return zone;
 }
@@ -87,7 +87,7 @@ int main(int argc, char* argv[])
   auto* zoneB = create_zone(root, "B");
   const auto* link = root->create_link("root-link", 1e10);
   root->add_route(zoneA->get_netpoint(), zoneB->get_netpoint(), e.netpoint_by_name("routerA"),
-                  e.netpoint_by_name("routerB"), std::vector<sg4::LinkInRoute>{link});
+                  e.netpoint_by_name("routerB"), {sg4::LinkInRoute(link)});
 
   std::vector<sg4::Host*> host_list = e.get_all_hosts();
   /* create the sender actor running on first host */