Move capacity-related attributes to Road class

Author: Grufoony

src/dsf/headers/Edge.hpp

@@ -12,8 +12,6 @@ namespace dsf {
     std::vector<std::pair<double, double>> m_geometry;
     Id m_id;
     std::pair<Id, Id> m_nodePair;
-    int m_capacity;
-    double m_transportCapacity;
     std::optional<double> m_weight;
     double m_angle;
 
@@ -24,24 +22,16 @@ namespace dsf {
     /// @brief Construct a new Edge object
     /// @param id The edge's id
     /// @param nodePair The edge's node pair (u, v) with the edge u -> v
-    /// @param capacity The edge's capacity, in number of agents, i.e. the maximum number of agents that can be on the
-    /// edge at the same time. Default is 1.
-    /// @param transportCapacity The edge's transport capacity, in number of agents, i.e. the maximum number of agents
-    /// that can be emitted by the same time. Default is 1.
     /// @param geometry The edge's geometry, a vector of pairs of doubles representing the coordinates of the edge's
     /// geometry. Default is an empty vector.
     Edge(Id id,
          std::pair<Id, Id> nodePair,
-         int capacity = 1,
-         double transportCapacity = 1.,
          std::vector<std::pair<double, double>> geometry = {});
     Edge(Edge&&) = default;
     Edge(const Edge&) = delete;
     virtual ~Edge() = default;
 
     void resetId(Id newId);
-    void setCapacity(int capacity);
-    void setTransportCapacity(double capacity);
     void setGeometry(std::vector<std::pair<double, double>> geometry);
     void setWeight(double const weight);
 
@@ -58,14 +48,10 @@ namespace dsf {
     /// @return std::pair<Id, Id> The edge's node pair, where the first element is the source node id and the second
     /// element is the target node id. The pair is (u, v) with the edge u -> v.
     std::pair<Id, Id> const& nodePair() const;
-
+    /// @brief Get the edge's geometry
+    /// @return std::vector<std::pair<double, double>> The edge's geometry, a vector of pairs of doubles representing the coordinates of the edge's geometry
     std::vector<std::pair<double, double>> const& geometry() const;
-    /// @brief Get the edge's capacity, in number of agents
-    /// @return int The edge's capacity, in number of agents
-    int capacity() const;
-    /// @brief Get the edge's transport capacity, in number of agents
-    /// @return int The edge's transport capacity, in number of agents
-    double transportCapacity() const;
+
     /// @brief Get the edge's angle, in radians, between the source and target nodes
     /// @return double The edge's angle, in radians
     double angle() const;

src/dsf/headers/Road.hpp

@@ -14,6 +14,8 @@ namespace dsf {
     double m_length;
     double m_maxSpeed;
     int m_nLanes;
+    int m_capacity;
+    double m_transportCapacity;
     std::string m_name;
     int m_priority;
     std::set<Id> m_forbiddenTurns;  // Stores the forbidden turns (road ids)
@@ -49,6 +51,14 @@ namespace dsf {
     /// @param speed The maximum speed
     /// @throws std::invalid_argument If the speed is less or equal to 0
     void setMaxSpeed(double speed);
+    /// @brief Set the capacity, in number of agents
+    /// @param capacity The capacity
+    /// @throws std::invalid_argument If the capacity is less or equal to 0
+    void setCapacity(int capacity);
+    /// @brief Set the transport capacity, in number of agents
+    /// @param transportCapacity The transport capacity
+    /// @throws std::invalid_argument If the transport capacity is less or equal to 0
+    void setTransportCapacity(double transportCapacity);
     /// @brief Set the road's priority
     /// @param priority The road's priority
     void setPriority(int priority);
@@ -68,6 +78,12 @@ namespace dsf {
     /// @brief Get the number of lanes
     /// @return int The number of lanes
     int nLanes() const;
+    /// @brief Get the road's capacity, in number of agents
+    /// @return int The road's capacity, in number of agents
+    int capacity() const;
+    /// @brief Get the road's transport capacity, in number of agents
+    /// @return double The road's transport capacity, in number of agents
+    double transportCapacity() const;
     /// @brief Get the name
     /// @return std::string The name
     std::string name() const;

src/dsf/sources/Edge.cpp

@@ -9,12 +9,8 @@
 namespace dsf {
   Edge::Edge(Id id,
              std::pair<Id, Id> nodePair,
-             int capacity,
-             double transportCapacity,
              std::vector<std::pair<double, double>> geometry)
       : m_geometry{std::move(geometry)}, m_id(id), m_nodePair(nodePair) {
-    setCapacity(capacity);
-    setTransportCapacity(transportCapacity);
     if (m_geometry.size() > 1) {
       m_setAngle(m_geometry[m_geometry.size() - 2], m_geometry.back());
     } else {
@@ -35,20 +31,6 @@ namespace dsf {
   }
 
   void Edge::resetId(Id newId) { m_id = newId; }
-  void Edge::setCapacity(int capacity) {
-    if (capacity < 1) {
-      throw std::invalid_argument(
-          std::format("{} capacity ({}) must be greater than 0.", *this, capacity));
-    }
-    m_capacity = capacity;
-  }
-  void Edge::setTransportCapacity(double capacity) {
-    if (capacity <= 0.) {
-      throw std::invalid_argument(std::format(
-          "{} edge transport capacity ({}) must be greater than 0.", *this, capacity));
-    }
-    m_transportCapacity = capacity;
-  }
 
   void Edge::setGeometry(std::vector<std::pair<double, double>> geometry) {
     m_geometry = std::move(geometry);
@@ -70,8 +52,6 @@ namespace dsf {
   Id Edge::source() const { return m_nodePair.first; }
   Id Edge::target() const { return m_nodePair.second; }
   std::pair<Id, Id> const& Edge::nodePair() const { return m_nodePair; }
-  int Edge::capacity() const { return m_capacity; }
-  double Edge::transportCapacity() const { return m_transportCapacity; }
   double Edge::angle() const { return m_angle; }
   double Edge::weight() const {
     return m_weight.has_value() ? *m_weight

src/dsf/sources/Road.cpp

@@ -18,11 +18,7 @@ namespace dsf {
              std::vector<std::pair<double, double>> geometry,
              std::optional<int> capacity,
              double transportCapacity)
-      : Edge(id,
-             std::move(nodePair),
-             capacity.value_or(std::ceil((length * nLanes) / m_meanVehicleLength)),
-             transportCapacity,
-             std::move(geometry)),
+      : Edge(id, std::move(nodePair), std::move(geometry)),
         m_length{length},
         m_maxSpeed{maxSpeed},
         m_nLanes{nLanes},
@@ -40,6 +36,17 @@ namespace dsf {
       throw std::invalid_argument(std::format(
           "The number of lanes of a road ({}) must be greater than 0.", nLanes));
     }
+    m_capacity = capacity.value_or(std::ceil((length * nLanes) / m_meanVehicleLength));
+    if (m_capacity < 1) {
+      throw std::invalid_argument(
+          std::format("The capacity of a road ({}) must be greater than 0.", m_capacity));
+    }
+    if (transportCapacity <= 0.) {
+      throw std::invalid_argument(
+          std::format("The transport capacity of a road ({}) must be greater than 0.",
+                      transportCapacity));
+    }
+    m_transportCapacity = transportCapacity;
   }
   void Road::setMeanVehicleLength(double meanVehicleLength) {
     if (!(meanVehicleLength > 0.)) {
@@ -62,6 +69,21 @@ namespace dsf {
     }
     m_maxSpeed = speed;
   }
+  void Road::setCapacity(int capacity) {
+    if (capacity < 1) {
+      throw std::invalid_argument(
+          std::format("The capacity of a road ({}) must be greater than 0.", capacity));
+    }
+    m_capacity = capacity;
+  }
+  void Road::setTransportCapacity(double transportCapacity) {
+    if (transportCapacity <= 0.) {
+      throw std::invalid_argument(
+          std::format("The transport capacity of a road ({}) must be greater than 0.",
+                      transportCapacity));
+    }
+    m_transportCapacity = transportCapacity;
+  }
   void Road::setPriority(int priority) {
     assert(priority >= 0);
     m_priority = priority;
@@ -83,6 +105,8 @@ namespace dsf {
   double Road::length() const { return m_length; }
   double Road::maxSpeed() const { return m_maxSpeed; }
   int Road::nLanes() const { return m_nLanes; }
+  int Road::capacity() const { return m_capacity; }
+  double Road::transportCapacity() const { return m_transportCapacity; }
   std::string Road::name() const { return m_name; }
   int Road::priority() const { return m_priority; }
   std::set<Id> const& Road::forbiddenTurns() const { return m_forbiddenTurns; }