Remove useless inlines

sbaldu · sbaldu · commit 94ae4d7c8b47 · 2024-11-13T10:27:38.000+01:00
diff --git a/src/dsm/headers/Graph.hpp b/src/dsm/headers/Graph.hpp
@@ -51,10 +51,10 @@ namespace dsm {
     /// @brief Reassign the street ids using the max node id
     /// @details The street ids are reassigned using the max node id, i.e.
     /// newStreetId = srcId * n + dstId, where n is the max node id.
-    inline void m_reassignIds();
+    void m_reassignIds();
     /// @brief If every node has coordinates, set the street angles
     /// @details The street angles are set using the node's coordinates.
-    inline void m_setStreetAngles();
+    void m_setStreetAngles();
 
   public:
     Graph();
@@ -65,7 +65,7 @@ namespace dsm {
     /// @param streetSet A map of streets representing the graph's streets
     Graph(const std::unordered_map<Id, std::unique_ptr<Street>>& streetSet);
 
-    inline Graph(const Graph& other) {
+    Graph(const Graph& other) {
       std::for_each(other.m_nodes.begin(), other.m_nodes.end(), [this](const auto& pair) {
         this->m_nodes.emplace(pair.first, pair.second.get());
       });
@@ -77,7 +77,7 @@ namespace dsm {
       m_adjacency = other.m_adjacency;
     }
 
-    inline Graph& operator=(const Graph& other) {
+    Graph& operator=(const Graph& other) {
       std::for_each(other.m_nodes.begin(), other.m_nodes.end(), [this](const auto& pair) {
         this->m_nodes.insert_or_assign(pair.first,
                                        std::unique_ptr<Node>(pair.second.get()));
@@ -93,8 +93,8 @@ namespace dsm {
       return *this;
     }
 
-    inline Graph(Graph&&) = default;
-    inline Graph& operator=(Graph&&) = default;
+    Graph(Graph&&) = default;
+    Graph& operator=(Graph&&) = default;
 
     /// @brief Build the graph's adjacency matrix and computes max capacity
     /// @details The adjacency matrix is built using the graph's streets and nodes. N.B.: The street ids
@@ -191,23 +191,23 @@ namespace dsm {
 
     /// @brief Get the graph's adjacency matrix
     /// @return A std::shared_ptr to the graph's adjacency matrix
-    inline const SparseMatrix<bool>& adjMatrix() const { return m_adjacency; }
+    const SparseMatrix<bool>& adjMatrix() const { return m_adjacency; }
     /// @brief Get the graph's node map
     /// @return A std::unordered_map containing the graph's nodes
-    inline const std::unordered_map<Id, std::unique_ptr<Node>>& nodeSet() const {
+    const std::unordered_map<Id, std::unique_ptr<Node>>& nodeSet() const {
       return m_nodes;
     }
     /// @brief Get the graph's node map
     /// @return A std::unordered_map containing the graph's nodes
-    inline std::unordered_map<Id, std::unique_ptr<Node>>& nodeSet() { return m_nodes; }
+    std::unordered_map<Id, std::unique_ptr<Node>>& nodeSet() { return m_nodes; }
     /// @brief Get the graph's street map
     /// @return A std::unordered_map containing the graph's streets
-    inline const std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() const {
+    const std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() const {
       return m_streets;
     }
     /// @brief Get the graph's street map
     /// @return A std::unordered_map containing the graph's streets
-    inline std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() {
+    std::unordered_map<Id, std::unique_ptr<Street>>& streetSet() {
       return m_streets;
     }
     /// @brief Get a street from the graph
diff --git a/src/dsm/headers/Node.hpp b/src/dsm/headers/Node.hpp
@@ -49,40 +49,40 @@ namespace dsm {
 
     /// @brief Set the node's id
     /// @param id The node's id
-    inline void setId(Id id) { m_id = id; }
+    void setId(Id id) { m_id = id; }
     /// @brief Set the node's coordinates
     /// @param coords A std::pair containing the node's coordinates (lat, lon)
-    inline void setCoords(std::pair<double, double> coords) {
+    void setCoords(std::pair<double, double> coords) {
       m_coords = std::move(coords);
     }
     /// @brief Set the node's capacity
     /// @param capacity The node's capacity
-    inline virtual void setCapacity(Size capacity) { m_capacity = capacity; }
+    virtual void setCapacity(Size capacity) { m_capacity = capacity; }
     /// @brief Set the node's transport capacity
     /// @param capacity The node's transport capacity
-    inline virtual void setTransportCapacity(Size capacity) {
+    virtual void setTransportCapacity(Size capacity) {
       m_transportCapacity = capacity;
     }
     /// @brief Get the node's id
     /// @return Id The node's id
-    inline Id id() const { return m_id; }
+    Id id() const { return m_id; }
     /// @brief Get the node's coordinates
     /// @return std::optional<std::pair<double, double>> A std::pair containing the node's coordinates
-    inline const std::optional<std::pair<double, double>>& coords() const {
+    const std::optional<std::pair<double, double>>& coords() const {
       return m_coords;
     }
     /// @brief Get the node's capacity
     /// @return Size The node's capacity
-    inline Size capacity() const { return m_capacity; }
+    Size capacity() const { return m_capacity; }
     /// @brief Get the node's transport capacity
     /// @return Size The node's transport capacity
-    inline Size transportCapacity() const { return m_transportCapacity; }
+    Size transportCapacity() const { return m_transportCapacity; }
 
-    inline virtual bool isFull() const = 0;
+    virtual bool isFull() const = 0;
 
-    inline virtual bool isIntersection() const noexcept { return false; }
-    inline virtual bool isTrafficLight() const noexcept { return false; }
-    inline virtual bool isRoundabout() const noexcept { return false; }
+    virtual bool isIntersection() const noexcept { return false; }
+    virtual bool isTrafficLight() const noexcept { return false; }
+    virtual bool isRoundabout() const noexcept { return false; }
   };
 
   /// @brief The Intersection class represents a node in the network.
@@ -130,35 +130,35 @@ namespace dsm {
     void removeAgent(Id agentId);
     /// @brief Set the node streets with priority
     /// @param streetPriorities A std::set containing the node's street priorities
-    inline void setStreetPriorities(std::set<Id> streetPriorities) {
+    void setStreetPriorities(std::set<Id> streetPriorities) {
       m_streetPriorities = std::move(streetPriorities);
     }
     /// @brief Add a street to the node street priorities
     /// @param streetId The street's id
-    inline void addStreetPriority(Id streetId) { m_streetPriorities.emplace(streetId); }
+    void addStreetPriority(Id streetId) { m_streetPriorities.emplace(streetId); }
 
     /// @brief Returns true if the node is full
     /// @return bool True if the node is full
-    inline bool isFull() const override { return m_agents.size() == this->m_capacity; }
+    bool isFull() const override { return m_agents.size() == this->m_capacity; }
 
     /// @brief Get the node's street priorities
     /// @details This function returns a std::set containing the node's street priorities.
     ///        If a street has priority, it means that the agents that are on that street
     ///        have priority over the agents that are on the other streets.
     /// @return std::set<Id> A std::set containing the node's street priorities
-    inline virtual const std::set<Id>& streetPriorities() const {
+    virtual const std::set<Id>& streetPriorities() const {
       return m_streetPriorities;
     };
     /// @brief Get the node's agent ids
     /// @return std::set<Id> A std::set containing the node's agent ids
-    inline const std::multimap<int16_t, Id>& agents() { return m_agents; };
+    const std::multimap<int16_t, Id>& agents() { return m_agents; };
     /// @brief Returns the number of agents that have passed through the node
     /// @return Size The number of agents that have passed through the node
     /// @details This function returns the number of agents that have passed through the node
     ///          since the last time this function was called. It also resets the counter.
     Size agentCounter();
 
-    inline virtual bool isIntersection() const noexcept override final { return true; }
+    virtual bool isIntersection() const noexcept override final { return true; }
   };
 
   template <typename Delay>
@@ -208,12 +208,12 @@ namespace dsm {
     /// @brief Set the node's left turn ratio
     /// @param first The first component of the left turn ratio
     /// @param second The second component of the left turn ratio
-    inline void setLeftTurnRatio(double const first, double const second) {
+    void setLeftTurnRatio(double const first, double const second) {
       setLeftTurnRatio(std::make_pair(first, second));
     }
     /// @brief Set the node's left turn ratio as std::pair(ratio, ratio)
     /// @param ratio The left turn ratio
-    inline void setLeftTurnRatio(double const ratio) {
+    void setLeftTurnRatio(double const ratio) {
       setLeftTurnRatio(std::make_pair(ratio, ratio));
     }
     /// @brief Increase the node's counter
@@ -233,7 +233,7 @@ namespace dsm {
     Delay counter() const { return m_counter; }
     /// @brief Get the node's left turn ratio
     /// @return std::optional<std::pair<double, double>> The node's left turn ratio
-    inline std::optional<std::pair<double, double>> leftTurnRatio() const {
+    std::optional<std::pair<double, double>> leftTurnRatio() const {
       return m_leftTurnRatio;
     }
     /// @brief Returns true if the traffic light is green
@@ -389,14 +389,14 @@ namespace dsm {
     dsm::queue<Id> m_agents;
 
   public:
-    inline Roundabout() = default;
+    Roundabout() = default;
     /// @brief Construct a new Roundabout object
     /// @param id The node's id
-    inline explicit Roundabout(Id id) : Node{id} {};
+    explicit Roundabout(Id id) : Node{id} {};
     /// @brief Construct a new Roundabout object
     /// @param id The node's id
     /// @param coords A std::pair containing the node's coordinates
-    inline Roundabout(Id id, std::pair<double, double> coords) : Node{id, coords} {};
+    Roundabout(Id id, std::pair<double, double> coords) : Node{id, coords} {};
     /// @brief Construct a new Roundabout object
     /// @param node An Intersection object
     Roundabout(const Node& node);
@@ -412,14 +412,14 @@ namespace dsm {
     Id dequeue();
     /// @brief Get the node's queue
     /// @return dsm::queue<Id> The node's queue
-    inline const dsm::queue<Id>& agents() const { return m_agents; }
+    const dsm::queue<Id>& agents() const { return m_agents; }
 
     /// @brief Returns true if the node is full
     /// @return bool True if the node is full
-    inline bool isFull() const override { return m_agents.size() == this->m_capacity; }
+    bool isFull() const override { return m_agents.size() == this->m_capacity; }
     /// @brief Returns true if the node is a roundabout
     /// @return bool True if the node is a roundabout
-    inline bool isRoundabout() const noexcept override { return true; }
+    bool isRoundabout() const noexcept override { return true; }
   };
 
 };  // namespace dsm
diff --git a/src/dsm/headers/Street.hpp b/src/dsm/headers/Street.hpp
@@ -104,24 +104,24 @@ namespace dsm {
     void setLength(double len);
     /// @brief Set the street's queue
     /// @param queue The street's queue
-    inline void setQueue(dsm::queue<Size> queue, size_t index) {
+    void setQueue(dsm::queue<Size> queue, size_t index) {
       m_exitQueues[index] = std::move(queue);
     }
     /// @brief Set the street's node pair
     /// @param node1 The source node of the street
     /// @param node2 The destination node of the street
-    inline void setNodePair(Id node1, Id node2) {
+    void setNodePair(Id node1, Id node2) {
       m_nodePair = std::make_pair(node1, node2);
     }
     /// @brief Set the street's node pair
     /// @param node1 The source node of the street
     /// @param node2 The destination node of the street
-    inline void setNodePair(const Node& node1, const Node& node2) {
+    void setNodePair(const Node& node1, const Node& node2) {
       m_nodePair = std::make_pair(node1.id(), node2.id());
     }
     /// @brief Set the street's node pair
     /// @param pair The street's node pair
-    inline void setNodePair(std::pair<Id, Id> pair) { m_nodePair = std::move(pair); }
+    void setNodePair(std::pair<Id, Id> pair) { m_nodePair = std::move(pair); }
     /// @brief Set the street's speed limit
     /// @param speed The street's speed limit
     /// @throw std::invalid_argument, If the speed is negative
@@ -141,57 +141,57 @@ namespace dsm {
 
     /// @brief Get the street's id
     /// @return Id, The street's id
-    inline Id id() const { return m_id; }
+    Id id() const { return m_id; }
     /// @brief Get the street's capacity
     /// @return Size, The street's capacity
-    inline Size capacity() const { return m_capacity; }
+    Size capacity() const { return m_capacity; }
     /// @brief Get the street's transport capacity
     /// @details The transport capacity is the maximum number of agents that can traverse the street
     ///          in a time step.
     /// @return Size, The street's transport capacity
-    inline int16_t transportCapacity() const { return m_transportCapacity; }
+    int16_t transportCapacity() const { return m_transportCapacity; }
     /// @brief Get the street's length
     /// @return double, The street's length
-    inline double length() const { return m_len; }
+    double length() const { return m_len; }
     /// @brief Get the street's waiting agents
     /// @return std::set<Id>, The street's waiting agents
-    inline const std::set<Id>& waitingAgents() const { return m_waitingAgents; }
+    const std::set<Id>& waitingAgents() const { return m_waitingAgents; }
     /// @brief Get the street's queue
     /// @return dsm::queue<Size>, The street's queue
-    inline const dsm::queue<Size>& queue(size_t index) const {
+    const dsm::queue<Size>& queue(size_t index) const {
       return m_exitQueues[index];
     }
     /// @brief Get the street's queues
     /// @return std::vector<dsm::queue<Size>> The street's queues
-    inline const std::vector<dsm::queue<Size>>& exitQueues() const {
+    const std::vector<dsm::queue<Size>>& exitQueues() const {
       return m_exitQueues;
     }
     /// @brief Get the street's node pair
     /// @return std::pair<Id, Id>, The street's node pair
-    inline const std::pair<Id, Id>& nodePair() const { return m_nodePair; }
+    const std::pair<Id, Id>& nodePair() const { return m_nodePair; }
     /// @brief  Get the number of agents on the street
     /// @return Size, The number of agents on the street
     Size nAgents() const;
     /// @brief Get the street's density in \f$m^{-1}\f$
     /// @return double, The street's density
-    inline double density() const { return nAgents() / (m_len * m_nLanes); }
+    double density() const { return nAgents() / (m_len * m_nLanes); }
     /// @brief Get the street's normalized density
     /// @return double, The street's normalized density
-    inline double normDensity() const {
+    double normDensity() const {
       return nAgents() / static_cast<double>(m_capacity);
     }
     /// @brief Check if the street is full
     /// @return bool, True if the street is full, false otherwise
     bool isFull() const { return nAgents() == m_capacity; }
     /// @brief Get the street's speed limit
     /// @return double, The street's speed limit
-    inline double maxSpeed() const { return m_maxSpeed; }
+    double maxSpeed() const { return m_maxSpeed; }
     /// @brief Get the street's angle
     /// @return double The street's angle
-    inline double angle() const { return m_angle; }
+    double angle() const { return m_angle; }
     /// @brief Get the street's number of lanes
     /// @return int16_t The street's number of lanes
-    inline int16_t nLanes() const { return m_nLanes; }
+    int16_t nLanes() const { return m_nLanes; }
     /// @brief Get the number of agents on all queues
     /// @return Size The number of agents on all queues
     Size nExitingAgents() const;
@@ -209,7 +209,7 @@ namespace dsm {
     virtual std::optional<Id> dequeue(size_t index);
     /// @brief Check if the street is a spire
     /// @return bool True if the street is a spire, false otherwise
-    inline virtual bool isSpire() const { return false; };
+    virtual bool isSpire() const { return false; };
   };
 
   /// @brief The SpireStreet class represents a street which is able to count agent flows in both input and output.
@@ -264,7 +264,7 @@ namespace dsm {
     std::optional<Id> dequeue(size_t index) override;
     /// @brief Check if the street is a spire
     /// @return bool True if the street is a spire, false otherwise
-    inline bool isSpire() const final { return true; };
+    bool isSpire() const final { return true; };
   };
 
 };  // namespace dsm
