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/profile_properties.hpp (5029B)

#ifndef PROFILE_PROPERTIES_HPP
#define PROFILE_PROPERTIES_HPP

#include "extractor/class_data.hpp"

#include "util/typedefs.hpp"

#include <boost/assert.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <boost/optional.hpp>

#include <algorithm>
#include <array>
#include <cstdint>

namespace osrm::extractor
{

const constexpr auto DEFAULT_MAX_SPEED = 180 / 3.6; // 180kmph -> m/s

struct ProfileProperties
{
    static constexpr int MAX_WEIGHT_NAME_LENGTH = 255;
    static constexpr int MAX_CLASS_NAME_LENGTH = 255;

ProfileProperties()
        : traffic_signal_penalty(0), u_turn_penalty(0),
          max_speed_for_map_matching(DEFAULT_MAX_SPEED), continue_straight_at_waypoint(true),
          use_turn_restrictions(false), left_hand_driving(false), fallback_to_duration(true),
          weight_name{"duration"}, class_names{{}}, excludable_classes{{}},
          call_tagless_node_function(true)
    {
        std::fill(excludable_classes.begin(), excludable_classes.end(), INAVLID_CLASS_DATA);
        BOOST_ASSERT(weight_name[MAX_WEIGHT_NAME_LENGTH] == '\0');
    }

double GetUturnPenalty() const { return u_turn_penalty / 10.; }

void SetUturnPenalty(const double u_turn_penalty_)
    {
        u_turn_penalty = boost::numeric_cast<int>(u_turn_penalty_ * 10.);
    }

double GetTrafficSignalPenalty() const { return traffic_signal_penalty / 10.; }

void SetTrafficSignalPenalty(const double traffic_signal_penalty_)
    {
        traffic_signal_penalty = boost::numeric_cast<int>(traffic_signal_penalty_ * 10.);
    }

double GetMaxSpeedForMapMatching() const { return max_speed_for_map_matching; }

void SetMaxSpeedForMapMatching(const double max_speed_for_map_matching_)
    {
        max_speed_for_map_matching = max_speed_for_map_matching_;
    }

void SetWeightName(const std::string &name)
    {
        auto count = std::min<std::size_t>(name.length(), MAX_WEIGHT_NAME_LENGTH) + 1;
        std::copy_n(name.c_str(), count, weight_name);
        // Make sure this is always zero terminated
        BOOST_ASSERT(weight_name[count - 1] == '\0');
        BOOST_ASSERT(weight_name[MAX_WEIGHT_NAME_LENGTH] == '\0');
        // Set lazy fallback flag
        fallback_to_duration = name == "duration";
    }

std::string GetWeightName() const
    {
        // Make sure this is always zero terminated
        BOOST_ASSERT(weight_name[MAX_WEIGHT_NAME_LENGTH] == '\0');
        return std::string(weight_name);
    }

// Mark this combination of classes as excludable
    void SetExcludableClasses(std::size_t index, ClassData classes)
    {
        excludable_classes[index] = classes;
    }

// Check if this classes are excludable
    boost::optional<std::size_t> ClassesAreExcludable(ClassData classes) const
    {
        auto iter = std::find(excludable_classes.begin(), excludable_classes.end(), classes);
        if (iter != excludable_classes.end())
        {
            return std::distance(excludable_classes.begin(), iter);
        }

return {};
    }

void SetClassName(std::size_t index, const std::string &name)
    {
        char *name_ptr = class_names[index];
        auto count = std::min<std::size_t>(name.length(), MAX_CLASS_NAME_LENGTH) + 1;
        std::copy_n(name.c_str(), count, name_ptr);
        // Make sure this is always zero terminated
        BOOST_ASSERT(class_names[index][count - 1] == '\0');
        BOOST_ASSERT(class_names[index][MAX_CLASS_NAME_LENGTH] == '\0');
    }

std::string GetClassName(std::size_t index) const
    {
        BOOST_ASSERT(index <= MAX_CLASS_INDEX);
        const auto &name_it = std::begin(class_names) + index;
        return std::string(*name_it);
    }

double GetWeightMultiplier() const { return std::pow(10., weight_precision); }

double GetMaxTurnWeight() const
    {
        return from_alias<double>(MAXIMAL_TURN_PENALTY) / GetWeightMultiplier();
    }

//! penalty to cross a traffic light in deci-seconds
    std::int32_t traffic_signal_penalty;
    //! penalty to do a uturn in deci-seconds
    std::int32_t u_turn_penalty;
    double max_speed_for_map_matching;
    //! depending on the profile, force the routing to always continue in the same direction
    bool continue_straight_at_waypoint;
    //! flag used for restriction parser (e.g. used for the walk profile)
    bool use_turn_restrictions;
    bool left_hand_driving; // DEPRECATED: property value is local to edges from API version 2
    bool fallback_to_duration;
    //! stores the name of the weight (e.g. 'duration', 'distance', 'safety')
    char weight_name[MAX_WEIGHT_NAME_LENGTH + 1];
    //! stores the names of each class
    std::array<char[MAX_CLASS_NAME_LENGTH + 1], MAX_CLASS_INDEX + 1> class_names;
    //! stores the masks of excludable class combinations
    std::array<ClassData, MAX_EXCLUDABLE_CLASSES> excludable_classes;
    unsigned weight_precision = 1;
    bool force_split_edges = false;
    bool call_tagless_node_function = true;
};
} // namespace osrm::extractor

#endif

cmd: