FM / api

/srv/osrm/osrm-backend/include/engine/api/

/srv/osrm/osrm-backend/include/engine/api

Name	Size	Mode	Actions
flatbuffers/	-	0755	rm
base_api.hpp	6717	0644	edit dl rm
base_parameters.hpp	4992	0644	edit dl rm
base_result.hpp	373	0644	edit dl rm
json_factory.hpp	3906	0644	edit dl rm
match_api.hpp	10162	0644	edit dl rm
match_parameters.hpp	3341	0644	edit dl rm
match_parameters_tidy.hpp	6625	0644	edit dl rm
nearest_api.hpp	6224	0644	edit dl rm
nearest_parameters.hpp	2059	0644	edit dl rm
route_api.hpp	45924	0644	edit dl rm
route_parameters.hpp	8923	0644	edit dl rm
table_api.hpp	16316	0644	edit dl rm
table_parameters.hpp	6031	0644	edit dl rm
tile_parameters.hpp	2680	0644	edit dl rm
trip_api.hpp	6894	0644	edit dl rm
trip_parameters.hpp	2525	0644	edit dl rm

Edit: /srv/osrm/osrm-backend/include/engine/api/nearest_api.hpp (6224B)

#ifndef ENGINE_API_NEAREST_API_HPP
#define ENGINE_API_NEAREST_API_HPP

#include "engine/api/base_api.hpp"
#include "engine/api/base_result.hpp"
#include "engine/api/nearest_parameters.hpp"

#include "engine/api/json_factory.hpp"
#include "engine/phantom_node.hpp"

#include <boost/assert.hpp>

#include <vector>

namespace osrm::engine::api
{

class NearestAPI final : public BaseAPI
{
  public:
    NearestAPI(const datafacade::BaseDataFacade &facade_, const NearestParameters &parameters_)
        : BaseAPI(facade_, parameters_), parameters(parameters_)
    {
    }

void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
                      osrm::engine::api::ResultT &response) const
    {
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);

if (response.is<flatbuffers::FlatBufferBuilder>())
        {
            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
            MakeResponse(phantom_nodes, fb_result);
        }
        else
        {
            auto &json_result = response.get<util::json::Object>();
            MakeResponse(phantom_nodes, json_result);
        }
    }

void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
                      flatbuffers::FlatBufferBuilder &fb_result) const
    {
        auto data_timestamp = facade.GetTimestamp();
        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
        if (!data_timestamp.empty())
        {
            data_version_string = fb_result.CreateString(data_timestamp);
        }

flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
            waypoints_vector;
        if (!parameters.skip_waypoints)
        {
            std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
            waypoints.resize(phantom_nodes.front().size());
            std::transform(
                phantom_nodes.front().begin(),
                phantom_nodes.front().end(),
                waypoints.begin(),
                [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) {
                    auto &phantom_node = phantom_with_distance.phantom_node;

auto node_values = MakeNodes(phantom_node);
                    fbresult::Uint64Pair nodes{node_values.first, node_values.second};

auto waypoint = MakeWaypoint(&fb_result, {phantom_node});
                    waypoint->add_nodes(&nodes);
                    return waypoint->Finish();
                });

waypoints_vector = fb_result.CreateVector(waypoints);
        }

fbresult::FBResultBuilder response(fb_result);

response.add_waypoints(waypoints_vector);
        if (data_version_string)
        {
            response.add_data_version(*data_version_string);
        }
        fb_result.Finish(response.Finish());
    }
    void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
                      util::json::Object &response) const
    {
        if (!parameters.skip_waypoints)
        {
            util::json::Array waypoints;
            waypoints.values.resize(phantom_nodes.front().size());
            std::transform(phantom_nodes.front().begin(),
                           phantom_nodes.front().end(),
                           waypoints.values.begin(),
                           [this](const PhantomNodeWithDistance &phantom_with_distance) {
                               auto &phantom_node = phantom_with_distance.phantom_node;
                               auto waypoint = MakeWaypoint({phantom_node});

util::json::Array nodes;

auto node_values = MakeNodes(phantom_node);

nodes.values.push_back(node_values.first);
                               nodes.values.push_back(node_values.second);
                               waypoint.values["nodes"] = std::move(nodes);

return waypoint;
                           });
            response.values["waypoints"] = std::move(waypoints);
        }

response.values["code"] = "Ok";
        auto data_timestamp = facade.GetTimestamp();
        if (!data_timestamp.empty())
        {
            response.values["data_version"] = data_timestamp;
        }
    }

const NearestParameters &parameters;

protected:
    std::pair<uint64_t, uint64_t> MakeNodes(const PhantomNode &phantom_node) const
    {
        std::uint64_t from_node = 0;
        std::uint64_t to_node = 0;

datafacade::BaseDataFacade::NodeForwardRange forward_geometry;
        if (phantom_node.forward_segment_id.enabled)
        {
            auto segment_id = phantom_node.forward_segment_id.id;
            const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
            forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);

auto osm_node_id =
                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
            to_node = static_cast<std::uint64_t>(osm_node_id);
        }

if (phantom_node.reverse_segment_id.enabled)
        {
            auto segment_id = phantom_node.reverse_segment_id.id;
            const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
            const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
            auto osm_node_id =
                facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
            from_node = static_cast<std::uint64_t>(osm_node_id);
        }
        else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
        {
            // In the case of one way, rely on forward segment only
            auto osm_node_id =
                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
            from_node = static_cast<std::uint64_t>(osm_node_id);
        }

return std::make_pair(from_node, to_node);
    }
};

} // namespace osrm::engine::api

#endif

cmd: