Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Replace GCC-specific attribute with [[nodiscard]] attribute (#6899)

Browse Source
This commit is contained in:
Dennis Luxen 2024-05-24 20:34:04 +02:00 committed by GitHub
parent 21607e0cb2
commit babdced52f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 98 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/engine/guidance/collapse_turns.hpp
View File

@ -1,7 +1,6 @@
#ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP #ifndef OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP
#include "engine/guidance/route_step.hpp" #include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
@ -12,16 +11,15 @@ namespace osrm::engine::guidance
// Multiple possible reasons can result in unnecessary/confusing instructions // Multiple possible reasons can result in unnecessary/confusing instructions
// Collapsing such turns into a single turn instruction, we give a clearer // Collapsing such turns into a single turn instruction, we give a clearer
// set of instructions that is not cluttered by unnecessary turns/name changes. // set of instructions that is not cluttered by unnecessary turns/name changes.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
// Multiple possible reasons can result in unnecessary/confusing instructions // Multiple possible reasons can result in unnecessary/confusing instructions
// A prime example would be a segregated intersection. Turning around at this // A prime example would be a segregated intersection. Turning around at this
// intersection would result in two instructions to turn left. // intersection would result in two instructions to turn left.
// Collapsing such turns into a single turn instruction, we give a clearer // Collapsing such turns into a single turn instruction, we give a clearer
// set of instructions that is not cluttered by unnecessary turns/name changes. // set of instructions that is not cluttered by unnecessary turns/name changes.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep>
std::vector<RouteStep> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps); collapseSegregatedTurnInstructions(std::vector<RouteStep> steps);
// A combined turn is a set of two instructions that actually form a single turn, as far as we // A combined turn is a set of two instructions that actually form a single turn, as far as we
// perceive it. A u-turn consisting of two left turns is one such example. But there are also lots // perceive it. A u-turn consisting of two left turns is one such example. But there are also lots

4
include/engine/guidance/collapsing_utility.hpp
View File

@ -3,7 +3,6 @@
#include "guidance/turn_instruction.hpp" #include "guidance/turn_instruction.hpp"
#include "engine/guidance/route_step.hpp" #include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include "util/bearing.hpp" #include "util/bearing.hpp"
#include "util/guidance/name_announcements.hpp" #include "util/guidance/name_announcements.hpp"
@ -166,8 +165,7 @@ inline bool areSameSide(const RouteStep &lhs, const RouteStep &rhs)
} }
// do this after invalidating any steps to compress the step array again // do this after invalidating any steps to compress the step array again
OSRM_ATTR_WARN_UNUSED [[nodiscard]] inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
{ {
// finally clean up the post-processed instructions. // finally clean up the post-processed instructions.
// Remove all invalid instructions from the set of instructions. // Remove all invalid instructions from the set of instructions.

9
include/engine/guidance/lane_processing.hpp
View File

@ -1,10 +1,9 @@
#ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_ #ifndef OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
#define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_ #define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
#include <vector>
#include "engine/guidance/route_step.hpp" #include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include <vector>
namespace osrm::engine::guidance namespace osrm::engine::guidance
{ {
@ -14,8 +13,8 @@ namespace osrm::engine::guidance
// we anticipate lane changes emitting only matching lanes early on. // we anticipate lane changes emitting only matching lanes early on.
// the second parameter describes the duration that we feel two segments need to be apart to count // the second parameter describes the duration that we feel two segments need to be apart to count
// as separate maneuvers. // as separate maneuvers.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep>
std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps, anticipateLaneChange(std::vector<RouteStep> steps,
const double min_distance_needed_for_lane_change = 200); const double min_distance_needed_for_lane_change = 200);
} // namespace osrm::engine::guidance } // namespace osrm::engine::guidance

14
include/engine/guidance/post_processing.hpp
View File

@ -5,7 +5,6 @@
#include "engine/guidance/leg_geometry.hpp" #include "engine/guidance/leg_geometry.hpp"
#include "engine/guidance/route_step.hpp" #include "engine/guidance/route_step.hpp"
#include "engine/phantom_node.hpp" #include "engine/phantom_node.hpp"
#include "util/attributes.hpp"
#include <vector> #include <vector>
@ -13,8 +12,7 @@ namespace osrm::engine::guidance
{ {
// passed as none-reference to modify in-place and move out again // passed as none-reference to modify in-place and move out again
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
// trim initial/final segment of very short length. // trim initial/final segment of very short length.
// This function uses in/out parameter passing to modify both steps and geometry in place. // This function uses in/out parameter passing to modify both steps and geometry in place.
@ -24,23 +22,21 @@ std::vector<RouteStep> handleRoundabouts(std::vector<RouteStep> steps);
void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry); void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry);
// assign relative locations to depart/arrive instructions // assign relative locations to depart/arrive instructions
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
const LegGeometry &geometry, const LegGeometry &geometry,
const PhantomNode &source_node, const PhantomNode &source_node,
const PhantomNode &target_node); const PhantomNode &target_node);
// collapse suppressed instructions remaining into intersections array // collapse suppressed instructions remaining into intersections array
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
// postProcess will break the connection between the leg geometry // postProcess will break the connection between the leg geometry
// for which a segment is supposed to represent exactly the coordinates // for which a segment is supposed to represent exactly the coordinates
// between routing maneuvers and the route steps itself. // between routing maneuvers and the route steps itself.
// If required, we can get both in sync again using this function. // If required, we can get both in sync again using this function.
// Move in LegGeometry for modification in place. // Move in LegGeometry for modification in place.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] LegGeometry resyncGeometry(LegGeometry leg_geometry,
LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps); const std::vector<RouteStep> &steps);
/** /**
* Apply maneuver override relations to the selected route. * Apply maneuver override relations to the selected route.

4
include/engine/guidance/verbosity_reduction.hpp
View File

@ -2,7 +2,6 @@
#define OSRM_ENGINE_GUIDANCE_VERBOSITY_REDUCTION_HPP_ #define OSRM_ENGINE_GUIDANCE_VERBOSITY_REDUCTION_HPP_
#include "engine/guidance/route_step.hpp" #include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include <vector> #include <vector>
@ -13,8 +12,7 @@ namespace osrm::engine::guidance
// to announce them. All these that are not collapsed into a single turn (think segregated // to announce them. All these that are not collapsed into a single turn (think segregated
// intersection) have to be checked for the length they are active in. If they are active for a // intersection) have to be checked for the length they are active in. If they are active for a
// short distance only, we don't announce them // short distance only, we don't announce them
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
} // namespace osrm::engine::guidance } // namespace osrm::engine::guidance

41
include/extractor/intersection/coordinate_extractor.hpp
View File

@ -1,16 +1,15 @@
#ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_ #ifndef OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
#define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_ #define OSRM_EXTRACTOR_INTERSECTION_COORDINATE_EXTRACTOR_HPP_
#include <utility>
#include <vector>
#include "extractor/compressed_edge_container.hpp" #include "extractor/compressed_edge_container.hpp"
#include "extractor/query_node.hpp" #include "extractor/query_node.hpp"
#include "util/attributes.hpp"
#include "util/coordinate.hpp" #include "util/coordinate.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
#include <utility>
#include <vector>
namespace osrm::extractor::intersection namespace osrm::extractor::intersection
{ {
@ -27,8 +26,8 @@ class CoordinateExtractor
* Note: The segment between intersection and turn coordinate can be zero, if the OSM modelling * Note: The segment between intersection and turn coordinate can be zero, if the OSM modelling
* is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470 * is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470
*/ */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] util::Coordinate
util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node, GetCoordinateAlongRoad(const NodeID intersection_node,
const EdgeID turn_edge, const EdgeID turn_edge,
const bool traversed_in_reverse, const bool traversed_in_reverse,
const NodeID to_node, const NodeID to_node,
@ -36,8 +35,7 @@ class CoordinateExtractor
// Given a set of precomputed coordinates, select the representative coordinate along the road // Given a set of precomputed coordinates, select the representative coordinate along the road
// that best describes the turn // that best describes the turn
OSRM_ATTR_WARN_UNUSED [[nodiscard]] util::Coordinate
util::Coordinate
ExtractRepresentativeCoordinate(const NodeID intersection_node, ExtractRepresentativeCoordinate(const NodeID intersection_node,
const EdgeID turn_edge, const EdgeID turn_edge,
const bool traversed_in_reverse, const bool traversed_in_reverse,
@ -47,7 +45,7 @@ class CoordinateExtractor
// instead of finding only a single coordinate, we can also list all coordinates along a // instead of finding only a single coordinate, we can also list all coordinates along a
// road. // road.
OSRM_ATTR_WARN_UNUSED std::vector<util::Coordinate> [[nodiscard]] std::vector<util::Coordinate>
GetCoordinatesAlongRoad(const NodeID intersection_node, GetCoordinatesAlongRoad(const NodeID intersection_node,
const EdgeID turn_edge, const EdgeID turn_edge,
const bool traversed_in_reverse, const bool traversed_in_reverse,
@ -55,17 +53,15 @@ class CoordinateExtractor
// wrapper in case of normal forward edges (traversed_in_reverse = false, to_node = // wrapper in case of normal forward edges (traversed_in_reverse = false, to_node =
// node_based_graph.GetTarget(turn_edge) // node_based_graph.GetTarget(turn_edge)
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<util::Coordinate>
std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from, GetForwardCoordinatesAlongRoad(const NodeID from, const EdgeID turn_edge) const;
const EdgeID turn_edge) const;
// a less precise way to compute coordinates along a route. Due to the heavy interaction of // a less precise way to compute coordinates along a route. Due to the heavy interaction of
// graph traversal and turn instructions, we often don't care for high precision. We only want // graph traversal and turn instructions, we often don't care for high precision. We only want
// to check for available connections in order, or find (with room for error) the straightmost // to check for available connections in order, or find (with room for error) the straightmost
// turn. This function will offer a bit more error potential but allow for much higher // turn. This function will offer a bit more error potential but allow for much higher
// performance // performance
OSRM_ATTR_WARN_UNUSED [[nodiscard]] util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
const EdgeID turn_edge, const EdgeID turn_edge,
const bool traversed_in_reverse, const bool traversed_in_reverse,
const NodeID to_node) const; const NodeID to_node) const;
@ -90,22 +86,19 @@ class CoordinateExtractor
* The optional length cache needs to store the accumulated distance up to the respective * The optional length cache needs to store the accumulated distance up to the respective
* coordinate index [0,d(0,1),...] * coordinate index [0,d(0,1),...]
*/ */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<util::Coordinate>
std::vector<util::Coordinate>
TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates, TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates,
const double desired_length, const double desired_length,
const std::vector<double> &length_cache = {}) const; const std::vector<double> &length_cache = {}) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<double>
std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, const double limit) const;
const double limit) const;
/* when looking at a set of coordinates, this function allows trimming the vector to a smaller, /* when looking at a set of coordinates, this function allows trimming the vector to a smaller,
* only containing coordinates up to a given distance along the path. The last coordinate might * only containing coordinates up to a given distance along the path. The last coordinate might
* be interpolated * be interpolated
*/ */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<util::Coordinate>
std::vector<util::Coordinate>
TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates, TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates,
const double desired_length) const; const double desired_length) const;
@ -130,8 +123,7 @@ class CoordinateExtractor
* *
* for fixpoint `b`, vector_base `d` and vector_head `e` * for fixpoint `b`, vector_base `d` and vector_head `e`
*/ */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
const util::Coordinate vector_base, const util::Coordinate vector_base,
const util::Coordinate vector_head) const; const util::Coordinate vector_head) const;
@ -143,8 +135,7 @@ class CoordinateExtractor
* Into: * Into:
* x -- x -- x -- x -- x - x * x -- x -- x -- x -- x - x
*/ */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::vector<util::Coordinate>
std::vector<util::Coordinate>
SampleCoordinates(const std::vector<util::Coordinate> &coordinates, SampleCoordinates(const std::vector<util::Coordinate> &coordinates,
const double length, const double length,
const double rate) const; const double rate) const;

13
include/guidance/motorway_handler.hpp
View File

@ -7,7 +7,6 @@
#include "guidance/intersection_handler.hpp" #include "guidance/intersection_handler.hpp"
#include "guidance/is_through_street.hpp" #include "guidance/is_through_street.hpp"
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
#include <vector> #include <vector>
@ -42,18 +41,14 @@ class MotorwayHandler final : public IntersectionHandler
Intersection intersection) const override final; Intersection intersection) const override final;
private: private:
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleSliproads(const NodeID intersection_node_id,
Intersection handleSliproads(const NodeID intersection_node_id,
Intersection intersection) const; Intersection intersection) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;
Intersection fromMotorway(const EdgeID via_edge, Intersection intersection) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;
Intersection fromRamp(const EdgeID via_edge, Intersection intersection) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection fallback(Intersection intersection) const;
Intersection fallback(Intersection intersection) const;
}; };
} // namespace osrm::guidance } // namespace osrm::guidance

9
include/guidance/parsing_toolkit.hpp
View File

@ -7,8 +7,6 @@
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp> #include <boost/tokenizer.hpp>
#include "util/attributes.hpp"
namespace osrm::extractor::guidance namespace osrm::extractor::guidance
{ {
@ -21,8 +19,7 @@ namespace osrm::extractor::guidance
// will be corrected to left|throught, since the final lane is not drivable. // will be corrected to left|throught, since the final lane is not drivable.
// This is in contrast to a situation with lanes:psv:forward=0 (or not set) where left|through| // This is in contrast to a situation with lanes:psv:forward=0 (or not set) where left|through|
// represents left|through|through // represents left|through|through
OSRM_ATTR_WARN_UNUSED [[nodiscard]] inline std::string
inline std::string
trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right) trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t count_right)
{ {
if (count_left) if (count_left)
@ -68,8 +65,8 @@ trimLaneString(std::string lane_string, std::int32_t count_left, std::int32_t co
// turn:lanes=left|through|through|right // turn:lanes=left|through|through|right
// vehicle:lanes=yes|yes|no|yes // vehicle:lanes=yes|yes|no|yes
// bicycle:lanes=yes|no|designated|yes // bicycle:lanes=yes|no|designated|yes
OSRM_ATTR_WARN_UNUSED [[nodiscard]] inline std::string applyAccessTokens(std::string lane_string,
inline std::string applyAccessTokens(std::string lane_string, const std::string &access_tokens) const std::string &access_tokens)
{ {
using tokenizer = boost::tokenizer<boost::char_separator<char>>; using tokenizer = boost::tokenizer<boost::char_separator<char>>;
boost::char_separator<char> sep("|", "", boost::keep_empty_tokens); boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);

7
include/guidance/turn_analysis.hpp
View File

@ -17,7 +17,6 @@
#include "guidance/turn_classification.hpp" #include "guidance/turn_classification.hpp"
#include "guidance/turn_handler.hpp" #include "guidance/turn_handler.hpp"
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
#include <cstdint> #include <cstdint>
@ -47,13 +46,11 @@ class TurnAnalysis
/* Full Analysis Process for a single node/edge combination. Use with caution, as the process is /* Full Analysis Process for a single node/edge combination. Use with caution, as the process is
* relatively expensive */ * relatively expensive */
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection operator()(const NodeID node_prior_to_intersection,
Intersection operator()(const NodeID node_prior_to_intersection,
const EdgeID entering_via_edge) const; const EdgeID entering_via_edge) const;
// Select turn types based on the intersection shape // Select turn types based on the intersection shape
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection
Intersection
AssignTurnTypes(const NodeID from_node, AssignTurnTypes(const NodeID from_node,
const EdgeID via_eid, const EdgeID via_eid,
const extractor::intersection::IntersectionView &intersection) const; const extractor::intersection::IntersectionView &intersection) const;

22
include/guidance/turn_handler.hpp
View File

@ -8,7 +8,6 @@
#include "guidance/intersection_handler.hpp" #include "guidance/intersection_handler.hpp"
#include "guidance/is_through_street.hpp" #include "guidance/is_through_street.hpp"
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
#include <cstddef> #include <cstddef>
@ -76,20 +75,19 @@ class TurnHandler final : public IntersectionHandler
bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const; bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
// Dead end. // Dead end.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleOneWayTurn(Intersection intersection) const;
Intersection handleOneWayTurn(Intersection intersection) const;
// Mode Changes, new names... // Mode Changes, new names...
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleTwoWayTurn(const EdgeID via_edge,
Intersection handleTwoWayTurn(const EdgeID via_edge, Intersection intersection) const; Intersection intersection) const;
// Forks, T intersections and similar // Forks, T intersections and similar
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleThreeWayTurn(const EdgeID via_edge,
Intersection handleThreeWayTurn(const EdgeID via_edge, Intersection intersection) const; Intersection intersection) const;
// Handling of turns larger then degree three // Handling of turns larger then degree three
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleComplexTurn(const EdgeID via_edge,
Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const; Intersection intersection) const;
void void
handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const; handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;
@ -97,13 +95,11 @@ class TurnHandler final : public IntersectionHandler
// Classification // Classification
std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const; std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection assignLeftTurns(const EdgeID via_edge,
Intersection assignLeftTurns(const EdgeID via_edge,
Intersection intersection, Intersection intersection,
const std::size_t starting_at) const; const std::size_t starting_at) const;
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection assignRightTurns(const EdgeID via_edge,
Intersection assignRightTurns(const EdgeID via_edge,
Intersection intersection, Intersection intersection,
const std::size_t up_to) const; const std::size_t up_to) const;
}; };

4
include/guidance/turn_instruction.hpp
View File

@ -2,7 +2,6 @@
#define OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_ #define OSRM_GUIDANCE_TURN_INSTRUCTION_HPP_
#include "guidance/roundabout_type.hpp" #include "guidance/roundabout_type.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"
#include <algorithm> #include <algorithm>
@ -243,8 +242,7 @@ inline guidance::DirectionModifier::Enum getTurnDirection(const double angle)
} }
// swaps left <-> right modifier types // swaps left <-> right modifier types
OSRM_ATTR_WARN_UNUSED [[nodiscard]] inline guidance::DirectionModifier::Enum
inline guidance::DirectionModifier::Enum
mirrorDirectionModifier(const guidance::DirectionModifier::Enum modifier) mirrorDirectionModifier(const guidance::DirectionModifier::Enum modifier)
{ {
const constexpr guidance::DirectionModifier::Enum results[] = { const constexpr guidance::DirectionModifier::Enum results[] = {

4
include/guidance/turn_lane_augmentation.hpp
View File

@ -3,13 +3,11 @@
#include "guidance/intersection.hpp" #include "guidance/intersection.hpp"
#include "guidance/turn_lane_data.hpp" #include "guidance/turn_lane_data.hpp"
#include "util/attributes.hpp"
namespace osrm::guidance::lanes namespace osrm::guidance::lanes
{ {
OSRM_ATTR_WARN_UNUSED [[nodiscard]] LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
const Intersection &intersection); const Intersection &intersection);
} // namespace osrm::guidance::lanes } // namespace osrm::guidance::lanes

5
include/guidance/turn_lane_data.hpp
View File

@ -2,7 +2,6 @@
#define OSRM_GUIDANCE_TURN_LANE_DATA_HPP_ #define OSRM_GUIDANCE_TURN_LANE_DATA_HPP_
#include "extractor/turn_lane_types.hpp" #include "extractor/turn_lane_types.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"
#include <vector> #include <vector>
@ -23,8 +22,8 @@ struct TurnLaneData
using LaneDataVector = std::vector<TurnLaneData>; using LaneDataVector = std::vector<TurnLaneData>;
// convertes a string given in the OSM format into a TurnLaneData vector // convertes a string given in the OSM format into a TurnLaneData vector
OSRM_ATTR_WARN_UNUSED [[nodiscard]] LaneDataVector
LaneDataVector laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description); laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);
// Locate A Tag in a lane data vector (if multiple tags are set, the first one found is returned) // Locate A Tag in a lane data vector (if multiple tags are set, the first one found is returned)
LaneDataVector::const_iterator findTag(const extractor::TurnLaneType::Mask tag, LaneDataVector::const_iterator findTag(const extractor::TurnLaneType::Mask tag,

18
include/guidance/turn_lane_handler.hpp
View File

@ -9,7 +9,6 @@
#include "guidance/turn_analysis.hpp" #include "guidance/turn_analysis.hpp"
#include "guidance/turn_lane_data.hpp" #include "guidance/turn_lane_data.hpp"
#include "util/attributes.hpp"
#include "util/guidance/turn_lanes.hpp" #include "util/guidance/turn_lanes.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"
@ -68,8 +67,8 @@ class TurnLaneHandler
~TurnLaneHandler(); ~TurnLaneHandler();
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection
Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection); assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);
private: private:
mutable std::atomic<std::size_t> count_handled; mutable std::atomic<std::size_t> count_handled;
@ -108,21 +107,20 @@ class TurnLaneHandler
const Intersection &intersection) const; const Intersection &intersection) const;
// in case of a simple intersection, assign the lane entries // in case of a simple intersection, assign the lane entries
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection simpleMatchTuplesToTurns(Intersection intersection,
Intersection simpleMatchTuplesToTurns(Intersection intersection,
const LaneDataVector &lane_data, const LaneDataVector &lane_data,
const LaneDescriptionID lane_string_id); const LaneDescriptionID lane_string_id);
// partition lane data into lane data relevant at current turn and at next turn // partition lane data into lane data relevant at current turn and at next turn
OSRM_ATTR_WARN_UNUSED [[nodiscard]] std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector>
std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector> partitionLaneData( partitionLaneData(const NodeID at,
const NodeID at, LaneDataVector turn_lane_data, const Intersection &intersection) const; LaneDataVector turn_lane_data,
const Intersection &intersection) const;
// Sliproad turns have a separated lane to the right/left of other depicted lanes. These lanes // Sliproad turns have a separated lane to the right/left of other depicted lanes. These lanes
// are not necessarily separated clearly from the rest of the way. As a result, we combine both // are not necessarily separated clearly from the rest of the way. As a result, we combine both
// lane entries for our output, while performing the matching with the separated lanes only. // lane entries for our output, while performing the matching with the separated lanes only.
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection handleSliproadTurn(Intersection intersection,
Intersection handleSliproadTurn(Intersection intersection,
const LaneDescriptionID lane_description_id, const LaneDescriptionID lane_description_id,
LaneDataVector lane_data, LaneDataVector lane_data,
const Intersection &previous_intersection); const Intersection &previous_intersection);

5
include/guidance/turn_lane_matcher.hpp
View File

@ -5,7 +5,6 @@
#include "guidance/turn_instruction.hpp" #include "guidance/turn_instruction.hpp"
#include "guidance/turn_lane_data.hpp" #include "guidance/turn_lane_data.hpp"
#include "util/attributes.hpp"
#include "util/guidance/turn_lanes.hpp" #include "util/guidance/turn_lanes.hpp"
#include "util/node_based_graph.hpp" #include "util/node_based_graph.hpp"
@ -34,8 +33,8 @@ findBestMatchForReverse(const extractor::TurnLaneType::Mask leftmost_tag,
bool canMatchTrivially(const Intersection &intersection, const LaneDataVector &lane_data); bool canMatchTrivially(const Intersection &intersection, const LaneDataVector &lane_data);
// perform a trivial match on the turn lanes // perform a trivial match on the turn lanes
OSRM_ATTR_WARN_UNUSED [[nodiscard]] Intersection
Intersection triviallyMatchLanesToTurns(Intersection intersection, triviallyMatchLanesToTurns(Intersection intersection,
const LaneDataVector &lane_data, const LaneDataVector &lane_data,
const util::NodeBasedDynamicGraph &node_based_graph, const util::NodeBasedDynamicGraph &node_based_graph,
const LaneDescriptionID lane_string_id, const LaneDescriptionID lane_string_id,

4
include/util/alias.hpp
View File

@ -28,9 +28,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef OSRM_UTIL_ALIAS_HPP #ifndef OSRM_UTIL_ALIAS_HPP
#define OSRM_UTIL_ALIAS_HPP #define OSRM_UTIL_ALIAS_HPP
#include <boost/numeric/conversion/cast.hpp> #include <cstddef>
#include <functional> #include <functional>
#include <iostream> #include <ostream>
#include <type_traits> #include <type_traits>
namespace osrm namespace osrm

13
include/util/attributes.hpp
View File

@ -1,13 +0,0 @@
#ifndef OSRM_ATTRIBUTES_HPP_
#define OSRM_ATTRIBUTES_HPP_
// OSRM_ATTR_WARN_UNUSED - caller has to use function's return value
// https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html
#if defined(__GNUC__) && (__GNUC__ >= 4)
#define OSRM_ATTR_WARN_UNUSED __attribute__((warn_unused_result))
#else
#define OSRM_ATTR_WARN_UNUSED
#endif
#endif

6
include/util/guidance/name_announcements.hpp
View File

@ -6,18 +6,16 @@
#include "extractor/name_table.hpp" #include "extractor/name_table.hpp"
#include "extractor/suffix_table.hpp" #include "extractor/suffix_table.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp" #include "util/typedefs.hpp"
#include <boost/algorithm/string.hpp>
#include <algorithm> #include <algorithm>
#include <string> #include <string>
#include <tuple> #include <tuple>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/predicate.hpp>
namespace osrm::util::guidance namespace osrm::util::guidance
{ {
// Name Change Logic // Name Change Logic

1
src/benchmarks/alias.cpp
View File

@ -5,6 +5,7 @@
#include <algorithm> #include <algorithm>
#include <iomanip> #include <iomanip>
#include <iostream>
#include <numeric> #include <numeric>
#include <random> #include <random>
#include <string> #include <string>

6
src/engine/guidance/collapse_turns.cpp
View File

@ -433,8 +433,7 @@ void suppressStep(RouteStep &step_at_turn_location, RouteStep &step_after_turn_l
} }
// OTHER IMPLEMENTATIONS // OTHER IMPLEMENTATIONS
OSRM_ATTR_WARN_UNUSED [[nodiscard]] RouteSteps collapseTurnInstructions(RouteSteps steps)
RouteSteps collapseTurnInstructions(RouteSteps steps)
{ {
// make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn) // make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn)
BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back())); BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back()));
@ -589,8 +588,7 @@ RouteSteps collapseTurnInstructions(RouteSteps steps)
} }
// OTHER IMPLEMENTATIONS // OTHER IMPLEMENTATIONS
OSRM_ATTR_WARN_UNUSED [[nodiscard]] RouteSteps collapseSegregatedTurnInstructions(RouteSteps steps)
RouteSteps collapseSegregatedTurnInstructions(RouteSteps steps)
{ {
// make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn) // make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn)
BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back())); BOOST_ASSERT(!hasTurnType(steps.front()) && !hasTurnType(steps.back()));