FM / guidance

/srv/osrm/osrm-backend/include/guidance/

/srv/osrm/osrm-backend/include/guidance

Name	Size	Mode	Actions
constants.hpp	1265	0644	edit dl rm
driveway_handler.hpp	1540	0644	edit dl rm
files.hpp	1996	0644	edit dl rm
guidance_processing.hpp	2161	0644	edit dl rm
intersection.hpp	4933	0644	edit dl rm
intersection_handler.hpp	30075	0644	edit dl rm
is_through_street.hpp	2392	0644	edit dl rm
motorway_handler.hpp	2229	0644	edit dl rm
parsing_toolkit.hpp	3571	0644	edit dl rm
roundabout_handler.hpp	3374	0644	edit dl rm
roundabout_type.hpp	510	0644	edit dl rm
segregated_intersection_classification.hpp	677	0644	edit dl rm
serialization.hpp	1966	0644	edit dl rm
sliproad_handler.hpp	3683	0644	edit dl rm
statistics_handler.hpp	4235	0644	edit dl rm
suppress_mode_handler.hpp	1765	0644	edit dl rm
turn_analysis.hpp	2838	0644	edit dl rm
turn_bearing.hpp	777	0644	edit dl rm
turn_classification.hpp	535	0644	edit dl rm
turn_data_container.hpp	4326	0644	edit dl rm
turn_discovery.hpp	1509	0644	edit dl rm
turn_handler.hpp	4137	0644	edit dl rm
turn_instruction.hpp	16737	0644	edit dl rm
turn_lane_augmentation.hpp	507	0644	edit dl rm
turn_lane_data.hpp	1403	0644	edit dl rm
turn_lane_handler.hpp	6321	0644	edit dl rm
turn_lane_matcher.hpp	2047	0644	edit dl rm

Edit: /srv/osrm/osrm-backend/include/guidance/turn_handler.hpp (4137B)

#ifndef OSRM_GUIDANCE_TURN_HANDLER_HPP_
#define OSRM_GUIDANCE_TURN_HANDLER_HPP_

#include "extractor/name_table.hpp"
#include "extractor/query_node.hpp"

#include "guidance/intersection.hpp"
#include "guidance/intersection_handler.hpp"
#include "guidance/is_through_street.hpp"

#include "util/attributes.hpp"
#include "util/node_based_graph.hpp"

#include <boost/optional.hpp>

#include <cstddef>
#include <utility>
#include <vector>

namespace osrm::guidance
{

// Intersection handlers deal with all issues related to intersections.
class TurnHandler final : public IntersectionHandler
{
  public:
    TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                const extractor::EdgeBasedNodeDataContainer &node_data_container,
                const std::vector<util::Coordinate> &coordinates,
                const extractor::CompressedEdgeContainer &compressed_geometries,
                const extractor::RestrictionMap &node_restriction_map,
                const std::unordered_set<NodeID> &barrier_nodes,
                const extractor::TurnLanesIndexedArray &turn_lanes_data,
                const extractor::NameTable &name_table,
                const extractor::SuffixTable &street_name_suffix_table);

~TurnHandler() override final = default;

// check whether the handler can actually handle the intersection
    bool canProcess(const NodeID nid,
                    const EdgeID via_eid,
                    const Intersection &intersection) const override final;

// process the intersection
    Intersection operator()(const NodeID nid,
                            const EdgeID via_eid,
                            Intersection intersection) const override final;

private:
    struct Fork
    {
        const Intersection::iterator intersection_base;
        const Intersection::iterator begin;
        const Intersection::iterator end;
        const std::size_t size;
        Fork(const Intersection::iterator intersection_base,
             const Intersection::iterator begin,
             const Intersection::iterator end);
        ConnectedRoad &getRight() const;
        ConnectedRoad &getLeft() const;
        ConnectedRoad &getMiddle() const;
        ConnectedRoad &getRight();
        ConnectedRoad &getLeft();
        ConnectedRoad &getMiddle();
        std::size_t getRightIndex() const;
        std::size_t getLeftIndex() const;
    };

bool isObviousOfTwo(const EdgeID via_edge,
                        const ConnectedRoad &road,
                        const ConnectedRoad &other) const;

bool hasObvious(const EdgeID &via_edge, const Fork &fork) const;

boost::optional<Fork> findForkCandidatesByGeometry(Intersection &intersection) const;

bool isCompatibleByRoadClass(const Intersection &intersection, const Fork fork) const;

// Dead end.
    OSRM_ATTR_WARN_UNUSED
    Intersection handleOneWayTurn(Intersection intersection) const;

// Mode Changes, new names...
    OSRM_ATTR_WARN_UNUSED
    Intersection handleTwoWayTurn(const EdgeID via_edge, Intersection intersection) const;

// Forks, T intersections and similar
    OSRM_ATTR_WARN_UNUSED
    Intersection handleThreeWayTurn(const EdgeID via_edge, Intersection intersection) const;

// Handling of turns larger then degree three
    OSRM_ATTR_WARN_UNUSED
    Intersection handleComplexTurn(const EdgeID via_edge, Intersection intersection) const;

void
    handleDistinctConflict(const EdgeID via_edge, ConnectedRoad &left, ConnectedRoad &right) const;

// Classification
    boost::optional<Fork> findFork(const EdgeID via_edge, Intersection &intersection) const;

OSRM_ATTR_WARN_UNUSED
    Intersection assignLeftTurns(const EdgeID via_edge,
                                 Intersection intersection,
                                 const std::size_t starting_at) const;

OSRM_ATTR_WARN_UNUSED
    Intersection assignRightTurns(const EdgeID via_edge,
                                  Intersection intersection,
                                  const std::size_t up_to) const;
};

} // namespace osrm::guidance

#endif /*OSRM_GUIDANCE_TURN_HANDLER_HPP_*/

cmd: