Method CalculateSubrouteLeapsOnlyMode

libs/routing/index_router.cpp:781–984

}  // namespace

RouterResultCode IndexRouter::CalculateSubrouteLeapsOnlyMode(Checkpoints const & checkpoints, size_t subrouteIdx,
                                                             IndexGraphStarter & starter,
                                                             RouterDelegate const & delegate,
                                                             shared_ptr<AStarProgress> const & progress,
                                                             vector<Segment> & subroute)
{
  using Vertex = LeapsGraph::Vertex;
  using Edge = LeapsGraph::Edge;
  using Weight = LeapsGraph::Weight;

  // Get cross-mwm routes-candidates.
  std::vector<RoutingResultT> candidates;
  std::vector<RouteWeight> candidateMidWeights;

  {
    LeapsGraph leapsGraph(starter, MwmHierarchyHandler(m_numMwmIds, m_countryParentNameGetterFn));

    AStarSubProgress leapsProgress(mercator::ToLatLon(checkpoints.GetPoint(subrouteIdx)),
                                   mercator::ToLatLon(checkpoints.GetPoint(subrouteIdx + 1)), kLeapsStageContribution);
    SCOPE_GUARD(progressGuard, [&progress]() { progress->PushAndDropLastSubProgress(); });
    progress->AppendSubProgress(leapsProgress);

    // No need to call CheckLength in cross-mwm routine, thus we avoid calling GetRoadGeometry().
    struct AlwaysTrue
    {
      bool operator()(Weight const &) const { return true; }
    };

    using Visitor = JunctionVisitor<LeapsGraph>;
    AStarAlgorithm<Vertex, Edge, Weight>::Params<Visitor, AlwaysTrue> params(
        leapsGraph, leapsGraph.GetStartSegment(), leapsGraph.GetFinishSegment(), delegate.GetCancellable(),
        Visitor(leapsGraph, delegate, kVisitPeriodForLeaps, progress), AlwaysTrue());

    params.m_badReducedWeight = [](Weight const &, Weight const &)
    {
      /// @see CrossMwmConnector::GetTransition comment.
      /// Unfortunately, reduced weight invariant in LeapsOnly mode doesn't work with the workaround above.
      return false;
    };

    // Use Feature's index as a key to avoid multiple vertices with the same feature but a bit different segment.
    using EdgeKeyT = std::array<uint32_t, 2>;
    vector<RoutingResultT> routes;
    set<EdgeKeyT> edges;
    set<uint32_t> keys[2];  // 0 - end vertex of the first edge; 1 - beg vertex of the last edge

    auto const getBegEnd = [](RoutingResultT const & r) -> EdgeKeyT
    {
      size_t const pathSize = r.m_path.size();
      ASSERT_GREATER(pathSize, 2, ());
      return {r.m_path[1].GetFeatureId(), r.m_path[pathSize - 2].GetFeatureId()};
    };

    /// @todo Looks like there is no big deal in this constant due to the bidirectional search.
    /// But still Zalau -> Tiburg lasts 2 minutes, so set some reasonable timeout.
    size_t constexpr kMaxVertices = 15;
    uint64_t constexpr kTimeoutMilliS = 30 * 1000;
    base::Timer timer;