Method ProcessWay

src/extractor/extractor_callbacks.cpp:86–479

* Takes the geometry contained in the ```input_way``` and the tags computed * by the lua profile inside ```parsed_way``` and computes all edge segments. * * Depending on the forward/backwards weights the edges are split into forward * and backward edges. * * warning: caller needs to take care of synchronization! */

 * warning: caller needs to take care of synchronization!
 */
void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const ExtractionWay &parsed_way)
{
    if ((parsed_way.forward_travel_mode == extractor::TRAVEL_MODE_INACCESSIBLE ||
         parsed_way.forward_speed <= 0) &&
        (parsed_way.backward_travel_mode == extractor::TRAVEL_MODE_INACCESSIBLE ||
         parsed_way.backward_speed <= 0) &&
        parsed_way.duration <= 0)
    { // Only true if the way is assigned a valid speed/duration
        return;
    }

    if (!fallback_to_duration &&
        (parsed_way.forward_travel_mode == extractor::TRAVEL_MODE_INACCESSIBLE ||
         parsed_way.forward_rate <= 0) &&
        (parsed_way.backward_travel_mode == extractor::TRAVEL_MODE_INACCESSIBLE ||
         parsed_way.backward_rate <= 0) &&
        parsed_way.weight <= 0)
    { // Only true if the way is assigned a valid rate/weight and there is no duration fallback
        return;
    }

    const auto &nodes = input_way.nodes();
    if (nodes.size() <= 1)
    { // safe-guard against broken data
        return;
    }

    if (std::numeric_limits<decltype(input_way.id())>::max() == input_way.id())
    {
        util::Log(logDEBUG) << "found bogus way with id: " << input_way.id() << " of size "
                            << nodes.size();
        return;
    }

    InternalExtractorEdge::DurationData forward_duration_data;
    InternalExtractorEdge::DurationData backward_duration_data;
    InternalExtractorEdge::WeightData forward_weight_data;
    InternalExtractorEdge::WeightData backward_weight_data;

    const auto toValueByEdgeOrByMeter = [&nodes](const double by_way, const double by_meter)
    {
        using Value = detail::ByEdgeOrByMeterValue;
        // get value by weight per edge
        if (by_way >= 0)
        {
            // FIXME We divide by the number of edges here, but should rather consider
            // the length of each segment. We would either have to compute the length
            // of the whole way here (we can't: no node coordinates) or push that back
            // to the container and keep a reference to the way.
            const std::size_t num_edges = (nodes.size() - 1);
            return Value(Value::by_edge, by_way / num_edges);
        }
        else
        {
            // get value by deriving weight from speed per edge
            return Value(Value::by_meter, by_meter);
        }
    };