fix: use bool return type for std::equal_to specializations, apply style of removing redundant braces

Author: pageldev

include/RoutingGraph.h

@@ -47,7 +47,7 @@ struct hash<odr::RoutingGraphEdge>
 template<>
 struct equal_to<odr::RoutingGraphEdge>
 {
-    size_t operator()(const odr::RoutingGraphEdge& lhs, const odr::RoutingGraphEdge& rhs) const
+    bool operator()(const odr::RoutingGraphEdge& lhs, const odr::RoutingGraphEdge& rhs) const
     {
         return equal_to<odr::LaneKey>{}(lhs.from, rhs.from) && equal_to<odr::LaneKey>{}(lhs.to, rhs.to) && equal_to<double>{}(lhs.weight, rhs.weight);
     }
@@ -65,7 +65,7 @@ struct hash<odr::WeightedLaneKey>
 template<>
 struct equal_to<odr::WeightedLaneKey>
 {
-    size_t operator()(const odr::WeightedLaneKey& lhs, const odr::WeightedLaneKey& rhs) const
+    bool operator()(const odr::WeightedLaneKey& lhs, const odr::WeightedLaneKey& rhs) const
     {
         return equal_to<odr::LaneKey>{}(lhs, rhs) && equal_to<double>{}(lhs.weight, rhs.weight);
     }
@@ -76,9 +76,7 @@ struct greater<odr::WeightedLaneKey>
     bool operator()(const odr::WeightedLaneKey& lhs, const odr::WeightedLaneKey& rhs) const
     {
         if (lhs.weight != rhs.weight)
-        {
             return lhs.weight > rhs.weight; // Compare by weight first
-        }
         // Tie-breaker: use LaneKey's natural ordering
         return less<odr::LaneKey>{}(lhs, rhs); // Assuming LaneKey has a std::less specialization
     }

src/RoutingGraph.cpp

@@ -41,9 +41,7 @@ std::vector<LaneKey> RoutingGraph::get_lane_predecessors(const LaneKey& lane_key
 RoutingPath RoutingGraph::shortest_path(const LaneKey& from, const LaneKey& to) const
 {
     if (from == to)
-    {
         return {from};
-    }
 
     // Priority queue to maintain open set
     std::priority_queue<WeightedLaneKey, std::vector<WeightedLaneKey>, std::greater<odr::WeightedLaneKey>> open_set;
@@ -65,9 +63,7 @@ RoutingPath RoutingGraph::shortest_path(const LaneKey& from, const LaneKey& to)
         // Skip stale entries
         auto current_cost_itr = cost_from_start.find(current);
         if (current_cost_itr == cost_from_start.end() || current_weighted.weight > current_cost_itr->second)
-        {
             continue;
-        }
 
         // If the goal is reached, reconstruct the path
         if (current == to)
@@ -79,9 +75,7 @@ RoutingPath RoutingGraph::shortest_path(const LaneKey& from, const LaneKey& to)
                 path.push_back(at);
                 auto it = came_from.find(at);
                 if (it == came_from.end())
-                {
                     break;
-                }
                 at = it->second;
             }
             std::reverse(path.begin(), path.end());
@@ -91,9 +85,7 @@ RoutingPath RoutingGraph::shortest_path(const LaneKey& from, const LaneKey& to)
         // Get successors of the current node
         auto succ_itr = lane_key_to_successors.find(current);
         if (succ_itr == lane_key_to_successors.end())
-        {
             continue;
-        }
 
         for (const auto& weighted_successor : succ_itr->second)
         {
@@ -110,24 +102,16 @@ RoutingPath RoutingGraph::shortest_path(const LaneKey& from, const LaneKey& to)
             {
                 // Update cost_from_start
                 if (neighbor_cost_itr == cost_from_start.end())
-                {
                     cost_from_start.emplace(neighbor, alternative_path_cost);
-                }
                 else
-                {
                     neighbor_cost_itr->second = alternative_path_cost;
-                }
 
                 // Update came_from
                 auto came_from_itr = came_from.find(neighbor);
                 if (came_from_itr == came_from.end())
-                {
                     came_from.emplace(neighbor, current);
-                }
                 else
-                {
                     came_from_itr->second = current;
-                }
 
                 // Add the neighbor to the open set
                 open_set.emplace(neighbor, alternative_path_cost);