mark more function args as const ref

Author: arashbm

src/components.cpp

@@ -26,14 +26,14 @@ struct declare_component_types {
            new (c) Component(size_hint);
        }, "size_hint"_a = 0,
            nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<Component>(),
+      .def(nb::init<const Component&>(),
           "component"_a,
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<std::vector<VertT>, std::size_t>(),
+      .def(nb::init<const std::vector<VertT>&, std::size_t>(),
           "vertices"_a, "size_hint"_a = 0,
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<std::unordered_set<
-            VertT, reticula::hash<VertT>>, std::size_t>(),
+      .def(nb::init<const std::unordered_set<
+            VertT, reticula::hash<VertT>>&, std::size_t>(),
           "vertices"_a, "size_hint"_a = 0,
           nb::call_guard<nb::gil_scoped_release>())
       .def("insert",

src/implicit_event_graphs.cpp

@@ -23,16 +23,16 @@ struct declare_implicit_event_graph_class {
         m, python_type_str<Net>().c_str())
       .def(nb::init<const Net&>(),
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<std::vector<EdgeT>, AdjT>(),
+      .def(nb::init<const std::vector<EdgeT>&, AdjT>(),
           "events"_a, "temporal_adjacency"_a,
           nb::call_guard<nb::gil_scoped_release>())
       .def(nb::init<
-            std::vector<EdgeT>,
-            std::vector<typename EdgeT::VertexType>,
-            AdjT>(),
+            const std::vector<EdgeT>&,
+            const std::vector<typename EdgeT::VertexType>&,
+            const AdjT&>(),
           "events"_a, "verts"_a, "temporal_adjacency"_a,
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<reticula::network<EdgeT>, AdjT>(),
+      .def(nb::init<const reticula::network<EdgeT>&, const AdjT&>(),
           "temporal_network"_a, "temporal_adjacency"_a,
           nb::call_guard<nb::gil_scoped_release>())
       .def("events_cause",

src/networks.cpp

@@ -24,12 +24,12 @@ struct declare_network_class {
       .def(nb::init<const Net&>(),
           "network"_a,
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<std::vector<EdgeT>>(),
+      .def(nb::init<const std::vector<EdgeT>&>(),
           "edges"_a,
           nb::call_guard<nb::gil_scoped_release>())
       .def(nb::init<
-            std::vector<EdgeT>,
-            std::vector<typename EdgeT::VertexType>>(),
+            const std::vector<EdgeT>&,
+            const std::vector<typename EdgeT::VertexType>&>(),
           "edges"_a, "verts"_a,
           nb::call_guard<nb::gil_scoped_release>())
       .def("vertices",

src/static_hyperedges.cpp

@@ -18,20 +18,20 @@ template <typename VertT>
 struct declare_static_hyperedges {
   void operator()(nb::module_ &m) {
     define_basic_edge_concept<reticula::undirected_hyperedge<VertT>>(m)
-      .def(nb::init<std::vector<VertT>>(),
+      .def(nb::init<const std::vector<VertT>&>(),
            "verts"_a, nb::call_guard<nb::gil_scoped_release>());
 
     nb::implicitly_convertible<
       std::vector<VertT>,
       reticula::undirected_hyperedge<VertT>>();
 
     define_basic_edge_concept<reticula::directed_hyperedge<VertT>>(m)
-      .def(nb::init<std::vector<VertT>, std::vector<VertT>>(),
+      .def(nb::init<const std::vector<VertT>&, const std::vector<VertT>&>(),
            "tails"_a, "heads"_a,
            nb::call_guard<nb::gil_scoped_release>())
       .def("__init__", [](
           reticula::directed_hyperedge<VertT>* edge,
-          std::tuple<std::vector<VertT>, std::vector<VertT>> t) {
+          const std::tuple<std::vector<VertT>, std::vector<VertT>>& t) {
         new (edge) reticula::directed_hyperedge<VertT>{
           std::get<0>(t), std::get<1>(t)};
       }, "tuple"_a, nb::call_guard<nb::gil_scoped_release>())

src/temporal_clusters.cpp

@@ -20,13 +20,13 @@ struct declare_temporal_cluster_types {
     using Cluster = reticula::temporal_cluster<EdgeT, AdjT>;
     nb::class_<Cluster>(
         m, python_type_str<Cluster>().c_str())
-      .def(nb::init<AdjT, std::size_t>(),
+      .def(nb::init<const AdjT&, std::size_t>(),
           "temporal_adjacency"_a, "size_hint"_a = 0,
           nb::call_guard<nb::gil_scoped_release>())
       .def(nb::init<const Cluster&>(),
           "temporal_cluester"_a,
           nb::call_guard<nb::gil_scoped_release>())
-      .def(nb::init<std::vector<EdgeT>, AdjT, std::size_t>(),
+      .def(nb::init<const std::vector<EdgeT>&, const AdjT&, std::size_t>(),
           "events"_a,
           "temporal_adjacency"_a,
           "size_hint"_a = 0,