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

Browse Source
This commit is contained in:
Dennis 2024-05-24 18:44:23 +02:00
parent 21607e0cb2
commit 76e0364c32
No known key found for this signature in database
GPG Key ID: 6937EAEA33A3FA5D
19 changed files with 52 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
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,7 +11,7 @@ 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
@ -20,7 +19,7 @@ std::vector<RouteStep> collapseTurnInstructions(std::vector<RouteStep> steps);
// 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> collapseSegregatedTurnInstructions(std::vector<RouteStep> steps); std::vector<RouteStep> 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

3
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,7 +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.

7
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,7 +13,7 @@ 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> anticipateLaneChange(std::vector<RouteStep> steps, std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
const double min_distance_needed_for_lane_change = 200); const double min_distance_needed_for_lane_change = 200);

9
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,7 +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.
@ -24,14 +23,14 @@ 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
@ -39,7 +38,7 @@ std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
// 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, const std::vector<RouteStep> &steps); LegGeometry resyncGeometry(LegGeometry leg_geometry, const std::vector<RouteStep> &steps);
/** /**

3
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,7 +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

27
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,7 +26,7 @@ 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 GetCoordinateAlongRoad(const NodeID intersection_node, util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node,
const EdgeID turn_edge, const EdgeID turn_edge,
const bool traversed_in_reverse, const bool traversed_in_reverse,
@ -36,7 +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,
@ -47,7 +46,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,7 +54,7 @@ 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> GetForwardCoordinatesAlongRoad(const NodeID from, std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from,
const EdgeID turn_edge) const; const EdgeID turn_edge) const;
@ -64,7 +63,7 @@ class CoordinateExtractor
// 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,
@ -90,13 +89,13 @@ 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> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates, std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates,
const double limit) const; const double limit) const;
@ -104,7 +103,7 @@ class CoordinateExtractor
* 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,7 +129,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,7 +142,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,

9
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,17 +41,17 @@ 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;
}; };

6
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,7 +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)
{ {
@ -68,7 +66,7 @@ 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, const std::string &access_tokens) inline std::string applyAccessTokens(std::string lane_string, const std::string &access_tokens)
{ {
using tokenizer = boost::tokenizer<boost::char_separator<char>>; using tokenizer = boost::tokenizer<boost::char_separator<char>>;

5
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,12 +46,12 @@ 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,

13
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,19 +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 intersection) const; Intersection handleTwoWayTurn(const EdgeID via_edge, 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 intersection) const; Intersection handleThreeWayTurn(const EdgeID via_edge, 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 intersection) const; Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const;
void void
@ -97,12 +96,12 @@ 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;

3
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,7 +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)
{ {

3
include/guidance/turn_lane_augmentation.hpp
View File

@ -3,12 +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);

3
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,7 +22,7 @@ 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 laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description); LaneDataVector 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)

9
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,7 +67,7 @@ class TurnLaneHandler
~TurnLaneHandler(); ~TurnLaneHandler();
OSRM_ATTR_WARN_UNUSED [[nodiscard]]
Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection); Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);
private: private:
@ -108,20 +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> partitionLaneData( std::pair<TurnLaneHandler::LaneDataVector, TurnLaneHandler::LaneDataVector> partitionLaneData(
const NodeID at, LaneDataVector turn_lane_data, const Intersection &intersection) const; const NodeID at, 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,

3
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,7 +33,7 @@ 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 triviallyMatchLanesToTurns(Intersection 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,

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

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

@ -433,7 +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)
@ -589,7 +589,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)