FM / extractor

/srv/osrm/osrm-backend/include/extractor/

/srv/osrm/osrm-backend/include/extractor

Name	Size	Mode	Actions
intersection/	-	0755	rm
class_data.hpp	981	0644	edit dl rm
compressed_edge_container.hpp	3336	0644	edit dl rm
compressed_node_based_graph_edge.hpp	418	0644	edit dl rm
conditional_turn_penalty.hpp	589	0644	edit dl rm
datasources.hpp	1207	0644	edit dl rm
edge_based_edge.hpp	3467	0644	edit dl rm
edge_based_graph_factory.hpp	7787	0644	edit dl rm
edge_based_node.hpp	383	0644	edit dl rm
edge_based_node_segment.hpp	2050	0644	edit dl rm
extraction_containers.hpp	3679	0644	edit dl rm
extraction_helper_functions.hpp	4827	0644	edit dl rm
extraction_node.hpp	459	0644	edit dl rm
extraction_relation.hpp	5949	0644	edit dl rm
extraction_segment.hpp	715	0644	edit dl rm
extraction_turn.hpp	4983	0644	edit dl rm
extraction_way.hpp	4268	0644	edit dl rm
extractor.hpp	5267	0644	edit dl rm
extractor_callbacks.hpp	3249	0644	edit dl rm
extractor_config.hpp	3040	0644	edit dl rm
files.hpp	24372	0644	edit dl rm
graph_compressor.hpp	1271	0644	edit dl rm
internal_extractor_edge.hpp	2642	0644	edit dl rm
intersection_bearings_container.hpp	4487	0644	edit dl rm
location_dependent_data.hpp	1797	0644	edit dl rm
maneuver_override.hpp	5456	0644	edit dl rm
maneuver_override_relation_parser.hpp	1785	0644	edit dl rm
name_table.hpp	3596	0644	edit dl rm
nbg_to_ebg.hpp	450	0644	edit dl rm
nodes_of_way.hpp	1411	0644	edit dl rm
node_based_edge.hpp	8024	0644	edit dl rm
node_based_graph_factory.hpp	5155	0644	edit dl rm
node_data_container.hpp	4558	0644	edit dl rm
node_restriction_map.hpp	2292	0644	edit dl rm
packed_osm_ids.hpp	520	0644	edit dl rm
profile_properties.hpp	5029	0644	edit dl rm
query_node.hpp	1411	0644	edit dl rm
raster_source.hpp	5002	0644	edit dl rm
restriction.hpp	1750	0644	edit dl rm
restriction_graph.hpp	4500	0644	edit dl rm
restriction_parser.hpp	1768	0644	edit dl rm
road_classification.hpp	8390	0644	edit dl rm
scripting_environment.hpp	2426	0644	edit dl rm
scripting_environment_lua.hpp	4253	0644	edit dl rm
segment_data_container.hpp	8032	0644	edit dl rm
serialization.hpp	8834	0644	edit dl rm
suffix_table.hpp	1407	0644	edit dl rm
traffic_lights.hpp	514	0644	edit dl rm
traffic_signals.hpp	656	0644	edit dl rm
travel_mode.hpp	3666	0644	edit dl rm
turn_lane_types.hpp	3754	0644	edit dl rm
turn_path.hpp	7483	0644	edit dl rm
turn_path_compressor.hpp	2220	0644	edit dl rm
turn_path_filter.hpp	669	0644	edit dl rm
way_restriction_map.hpp	3114	0644	edit dl rm

Edit: /srv/osrm/osrm-backend/include/extractor/maneuver_override.hpp (5456B)

#ifndef MANUEVER_OVERRIDE_HPP
#define MANUEVER_OVERRIDE_HPP

#include "guidance/turn_instruction.hpp"
#include "util/typedefs.hpp"

#include "storage/shared_memory_ownership.hpp"
#include "turn_path.hpp"
#include "util/integer_range.hpp"
#include "util/log.hpp"
#include "util/vector_view.hpp"
#include <algorithm>
#include <boost/functional/hash.hpp>
#include <mapbox/variant.hpp>

namespace osrm::extractor
{

// Data that is loaded from the OSM datafile directly
struct InputManeuverOverride
{
    InputTurnPath turn_path;
    OSMNodeID via_node;
    std::string maneuver;
    std::string direction;
};

// Object returned by the datafacade
struct ManeuverOverride
{
    std::vector<NodeID> node_sequence;
    NodeID instruction_node; // node-based node ID
    guidance::TurnType::Enum override_type;
    guidance::DirectionModifier::Enum direction;
};

// Object returned by the datafacade
struct StorageManeuverOverride
{
    std::uint32_t node_sequence_offset_begin;
    std::uint32_t node_sequence_offset_end;
    NodeID start_node;
    NodeID instruction_node; // node-based node ID
    guidance::TurnType::Enum override_type;
    guidance::DirectionModifier::Enum direction;
};

// Used to identify maneuver turns whilst generating edge-based graph
struct NodeBasedTurn
{
    NodeID from;
    NodeID via;
    NodeID to;

bool operator==(const NodeBasedTurn &other) const
    {
        return other.from == from && other.via == via && other.to == to;
    }
};

// Internal representation of maneuvers during graph extraction phase
struct UnresolvedManeuverOverride
{
    // The turn sequence that the maneuver override applies to.
    TurnPath turn_path;
    NodeID instruction_node; // node-based node ID
    guidance::TurnType::Enum override_type;
    guidance::DirectionModifier::Enum direction;

UnresolvedManeuverOverride()
    {
        turn_path = {ViaNodePath{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID}};
        instruction_node = SPECIAL_NODEID;
        override_type = guidance::TurnType::Invalid;
        direction = guidance::DirectionModifier::MaxDirectionModifier;
    }

// check if all parts of the restriction reference an actual node
    bool Valid() const
    {
        if ((direction == guidance::DirectionModifier::MaxDirectionModifier &&
             override_type == guidance::TurnType::Invalid) ||
            instruction_node == SPECIAL_NODEID || !turn_path.Valid())
        {
            return false;
        }

if (turn_path.Type() == TurnPathType::VIA_NODE_TURN_PATH)
        {
            const auto node_path = turn_path.AsViaNodePath();
            if (node_path.via != instruction_node)
            {
                util::Log(logDEBUG) << "Maneuver via-node " << node_path.via
                                    << " does not match instruction node " << instruction_node;
                return false;
            }
        }
        else
        {
            BOOST_ASSERT(turn_path.Type() == TurnPathType::VIA_WAY_TURN_PATH);
            const auto way_path = turn_path.AsViaWayPath();

if (std::find(way_path.via.begin(), way_path.via.end(), instruction_node) ==
                way_path.via.end())
            {
                util::Log(logDEBUG) << "Maneuver via-way path does not contain instruction node "
                                    << instruction_node;
                return false;
            }
        }
        return true;
    }

// Generate sequence of node-based-node turns. Used to identify the maneuver's edge-based-node
    // turns during graph expansion.
    std::vector<NodeBasedTurn> Turns() const
    {
        if (turn_path.Type() == TurnPathType::VIA_NODE_TURN_PATH)
        {
            const auto node_maneuver = turn_path.AsViaNodePath();
            return {{node_maneuver.from, node_maneuver.via, node_maneuver.to}};
        }

BOOST_ASSERT(turn_path.Type() == TurnPathType::VIA_WAY_TURN_PATH);
        std::vector<NodeBasedTurn> result;
        const auto way_maneuver = turn_path.AsViaWayPath();
        BOOST_ASSERT(way_maneuver.via.size() >= 2);
        result.push_back({way_maneuver.from, way_maneuver.via[0], way_maneuver.via[1]});

for (auto i : util::irange<size_t>(0, way_maneuver.via.size() - 2))
        {
            result.push_back(
                {way_maneuver.via[i], way_maneuver.via[i + 1], way_maneuver.via[i + 2]});
        }
        result.push_back({way_maneuver.via[way_maneuver.via.size() - 2],
                          way_maneuver.via.back(),
                          way_maneuver.to});

return result;
    }

static std::string Name() { return "maneuver override"; };
};
} // namespace osrm::extractor

// custom specialization of std::hash can be injected in namespace std
namespace std
{
template <> struct hash<osrm::extractor::NodeBasedTurn>

{
    using argument_type = osrm::extractor::NodeBasedTurn;
    using result_type = std::size_t;
    result_type operator()(argument_type const &s) const noexcept
    {

std::size_t seed = 0;
        boost::hash_combine(seed, s.from);
        boost::hash_combine(seed, s.via);
        boost::hash_combine(seed, s.to);

return seed;
    }
};
} // namespace std

#endif
/*
from=1
to=3
via=b

101      a      102      b        103
---------------+---------------+-------------- (way 1)
      99        \      98       \       97
             51  \ 2          50 \ 3
                  \               \
*/

cmd: