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
#include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include <type_traits>
#include <vector>
@ -12,7 +11,7 @@ namespace osrm::engine::guidance
// Multiple possible reasons can result in unnecessary/confusing instructions
// Collapsing such turns into a single turn instruction, we give a clearer
// 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);
// 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.
// Collapsing such turns into a single turn instruction, we give a clearer
// 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);
// 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 "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include "util/bearing.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
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
inline std::vector<RouteStep> removeNoTurnInstructions(std::vector<RouteStep> steps)
{
// 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_
#define OSRM_ENGINE_GUIDANCE_LANE_PROCESSING_HPP_
#include <vector>
#include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#include <vector>
namespace osrm::engine::guidance
{
@ -14,7 +13,7 @@ namespace osrm::engine::guidance
// 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
// as separate maneuvers.
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
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/route_step.hpp"
#include "engine/phantom_node.hpp"
#include "util/attributes.hpp"
#include <vector>
@ -13,7 +12,7 @@ namespace osrm::engine::guidance
{
// 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);
// 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);
// assign relative locations to depart/arrive instructions
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
const LegGeometry &geometry,
const PhantomNode &source_node,
const PhantomNode &target_node);
// collapse suppressed instructions remaining into intersections array
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps);
// 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.
// If required, we can get both in sync again using this function.
// Move in LegGeometry for modification in place.
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
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_
#include "engine/guidance/route_step.hpp"
#include "util/attributes.hpp"
#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
// 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
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
} // namespace osrm::engine::guidance

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

@ -1,16 +1,15 @@
#ifndef 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/query_node.hpp"
#include "util/attributes.hpp"
#include "util/coordinate.hpp"
#include "util/node_based_graph.hpp"
#include <utility>
#include <vector>
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
* is unfortunate. See https://github.com/Project-OSRM/osrm-backend/issues/3470
*/
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
util::Coordinate GetCoordinateAlongRoad(const NodeID intersection_node,
const EdgeID turn_edge,
const bool traversed_in_reverse,
@ -36,7 +35,7 @@ class CoordinateExtractor
// Given a set of precomputed coordinates, select the representative coordinate along the road
// that best describes the turn
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
util::Coordinate
ExtractRepresentativeCoordinate(const NodeID intersection_node,
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
// road.
OSRM_ATTR_WARN_UNUSED std::vector<util::Coordinate>
[[nodiscard]] std::vector<util::Coordinate>
GetCoordinatesAlongRoad(const NodeID intersection_node,
const EdgeID turn_edge,
const bool traversed_in_reverse,
@ -55,7 +54,7 @@ class CoordinateExtractor
// wrapper in case of normal forward edges (traversed_in_reverse = false, to_node =
// node_based_graph.GetTarget(turn_edge)
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<util::Coordinate> GetForwardCoordinatesAlongRoad(const NodeID from,
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
// turn. This function will offer a bit more error potential but allow for much higher
// performance
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
util::Coordinate GetCoordinateCloseToTurn(const NodeID from_node,
const EdgeID turn_edge,
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
* coordinate index [0,d(0,1),...]
*/
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<util::Coordinate>
TrimCoordinatesToLength(std::vector<util::Coordinate> coordinates,
const double desired_length,
const std::vector<double> &length_cache = {}) const;
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<double> PrepareLengthCache(const std::vector<util::Coordinate> &coordinates,
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
* be interpolated
*/
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<util::Coordinate>
TrimCoordinatesByLengthFront(std::vector<util::Coordinate> coordinates,
const double desired_length) const;
@ -130,7 +129,7 @@ class CoordinateExtractor
*
* for fixpoint `b`, vector_base `d` and vector_head `e`
*/
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
util::Coordinate GetCorrectedCoordinate(const util::Coordinate fixpoint,
const util::Coordinate vector_base,
const util::Coordinate vector_head) const;
@ -143,7 +142,7 @@ class CoordinateExtractor
* Into:
* x -- x -- x -- x -- x - x
*/
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
std::vector<util::Coordinate>
SampleCoordinates(const std::vector<util::Coordinate> &coordinates,
const double length,

9
include/guidance/motorway_handler.hpp
View File

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

6
include/guidance/parsing_toolkit.hpp
View File

@ -7,8 +7,6 @@
#include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp>
#include "util/attributes.hpp"
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.
// This is in contrast to a situation with lanes:psv:forward=0 (or not set) where left|through|
// represents left|through|through
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
inline std::string
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
// vehicle:lanes=yes|yes|no|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)
{
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_handler.hpp"
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp"
#include <cstdint>
@ -47,12 +46,12 @@ class TurnAnalysis
/* Full Analysis Process for a single node/edge combination. Use with caution, as the process is
* relatively expensive */
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection operator()(const NodeID node_prior_to_intersection,
const EdgeID entering_via_edge) const;
// Select turn types based on the intersection shape
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection
AssignTurnTypes(const NodeID from_node,
const EdgeID via_eid,

13
include/guidance/turn_handler.hpp
View File

@ -8,7 +8,6 @@
#include "guidance/intersection_handler.hpp"
#include "guidance/is_through_street.hpp"
#include "util/attributes.hpp"
#include "util/node_based_graph.hpp"
#include <cstddef>
@ -76,19 +75,19 @@ class TurnHandler final : public IntersectionHandler
bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;
// Dead end.
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection handleOneWayTurn(Intersection intersection) const;
// Mode Changes, new names...
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection handleTwoWayTurn(const EdgeID via_edge, Intersection intersection) const;
// Forks, T intersections and similar
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection handleThreeWayTurn(const EdgeID via_edge, Intersection intersection) const;
// Handling of turns larger then degree three
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const;
void
@ -97,12 +96,12 @@ class TurnHandler final : public IntersectionHandler
// Classification
std::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection assignLeftTurns(const EdgeID via_edge,
Intersection intersection,
const std::size_t starting_at) const;
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection assignRightTurns(const EdgeID via_edge,
Intersection intersection,
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_
#include "guidance/roundabout_type.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp"
#include <algorithm>
@ -243,7 +242,7 @@ inline guidance::DirectionModifier::Enum getTurnDirection(const double angle)
}
// swaps left <-> right modifier types
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
inline guidance::DirectionModifier::Enum
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/turn_lane_data.hpp"
#include "util/attributes.hpp"
namespace osrm::guidance::lanes
{
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
LaneDataVector handleNoneValueAtSimpleTurn(LaneDataVector lane_data,
const Intersection &intersection);

3
include/guidance/turn_lane_data.hpp
View File

@ -2,7 +2,6 @@
#define OSRM_GUIDANCE_TURN_LANE_DATA_HPP_
#include "extractor/turn_lane_types.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp"
#include <vector>
@ -23,7 +22,7 @@ struct TurnLaneData
using LaneDataVector = std::vector<TurnLaneData>;
// 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);
// 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_lane_data.hpp"
#include "util/attributes.hpp"
#include "util/guidance/turn_lanes.hpp"
#include "util/node_based_graph.hpp"
#include "util/typedefs.hpp"
@ -68,7 +67,7 @@ class TurnLaneHandler
~TurnLaneHandler();
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection assignTurnLanes(const NodeID at, const EdgeID via_edge, Intersection intersection);
private:
@ -108,20 +107,20 @@ class TurnLaneHandler
const Intersection &intersection) const;
// in case of a simple intersection, assign the lane entries
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection simpleMatchTuplesToTurns(Intersection intersection,
const LaneDataVector &lane_data,
const LaneDescriptionID lane_string_id);
// 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(
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
// 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.
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection handleSliproadTurn(Intersection intersection,
const LaneDescriptionID lane_description_id,
LaneDataVector lane_data,

3
include/guidance/turn_lane_matcher.hpp
View File

@ -5,7 +5,6 @@
#include "guidance/turn_instruction.hpp"
#include "guidance/turn_lane_data.hpp"
#include "util/attributes.hpp"
#include "util/guidance/turn_lanes.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);
// perform a trivial match on the turn lanes
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
Intersection triviallyMatchLanesToTurns(Intersection intersection,
const LaneDataVector &lane_data,
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
#define OSRM_UTIL_ALIAS_HPP
#include <boost/numeric/conversion/cast.hpp>
#include <cstddef>
#include <functional>
#include <iostream>
#include <ostream>
#include <type_traits>
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/suffix_table.hpp"
#include "util/attributes.hpp"
#include "util/typedefs.hpp"
#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/predicate.hpp>
namespace osrm::util::guidance
{
// 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
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
RouteSteps collapseTurnInstructions(RouteSteps steps)
{
// 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
OSRM_ATTR_WARN_UNUSED
[[nodiscard]]
RouteSteps collapseSegregatedTurnInstructions(RouteSteps steps)
{
// make sure we can safely iterate over all steps (has depart/arrive with TurnType::NoTurn)