Review fixes.

5 files changed, 56 insertions, 25 deletions

diff --git a/routing/async_router.cpp b/routing/async_router.cpp
index f147f01098..072a79d0ac 100644
--- a/routing/async_router.cpp
+++ b/routing/async_router.cpp
@@ -37,7 +37,7 @@ string ToString(IRouter::ResultCode code)
   case IRouter::NeedMoreMaps: return "NeedMoreMaps";
   case IRouter::FileTooOld: return "FileTooOld";
   case IRouter::IntermediatePointNotFound: return "IntermediatePointNotFound";
-  case IRouter::TransitRouteNotFoundNoNetwork: return "RouteNotFoundNoTransitNetwork";
+  case IRouter::TransitRouteNotFoundNoNetwork: return "TransitRouteNotFoundNoNetwork";
   case IRouter::TransitRouteNotFoundTooLongPedestrian: return "TransitRouteNotFoundTooLongPedestrian";
   case IRouter::RouteNotFoundRedressRouteError: return "RouteNotFoundRedressRouteError";
   }
diff --git a/routing/index_graph_starter.cpp b/routing/index_graph_starter.cpp
index 0050851ec2..22221bdf46 100644
--- a/routing/index_graph_starter.cpp
+++ b/routing/index_graph_starter.cpp
@@ -17,6 +17,12 @@ Segment GetReverseSegment(Segment const & segment)
   return Segment(segment.GetMwmId(), segment.GetFeatureId(), segment.GetSegmentIdx(),
                  !segment.IsForward());
 }
+
+void FillNumMwmIds(set<Segment> const & segments, set<NumMwmId> & mwms)
+{
+  for (auto const & s : segments)
+    mwms.insert(s.GetMwmId());
+}
 }  // namespace
 
 namespace routing
@@ -121,11 +127,22 @@ m2::PointD const & IndexGraphStarter::GetPoint(Segment const & segment, bool fro
 set<NumMwmId> IndexGraphStarter::GetMwms() const
 {
   set<NumMwmId> mwms;
-  for (auto const & s : m_start.m_real)
-    mwms.insert(s.GetMwmId());
-  for (auto const & s : m_finish.m_real)
-    mwms.insert(s.GetMwmId());
+  FillNumMwmIds(m_start.m_real, mwms);
+  FillNumMwmIds(m_finish.m_real, mwms);
+  return mwms;
+}
 
+set<NumMwmId> IndexGraphStarter::GetStartMwms() const
+{
+  set<NumMwmId> mwms;
+  FillNumMwmIds(m_start.m_real, mwms);
+  return mwms;
+}
+
+set<NumMwmId> IndexGraphStarter::GetFinishMwms() const
+{
+  set<NumMwmId> mwms;
+  FillNumMwmIds(m_finish.m_real, mwms);
   return mwms;
 }
 
diff --git a/routing/index_graph_starter.hpp b/routing/index_graph_starter.hpp
index e817e057dd..db0afe1a64 100644
--- a/routing/index_graph_starter.hpp
+++ b/routing/index_graph_starter.hpp
@@ -74,6 +74,8 @@ public:
   }
 
   std::set<NumMwmId> GetMwms() const;
+  std::set<NumMwmId> GetStartMwms() const;
+  std::set<NumMwmId> GetFinishMwms() const;
 
   // Checks whether |weight| meets non-pass-through crossing restrictions according to placement of
   // start and finish in pass-through/non-pass-through area and number of non-pass-through crosses.
diff --git a/routing/index_router.cpp b/routing/index_router.cpp
index 2bc4644e77..76bbf9d931 100644
--- a/routing/index_router.cpp
+++ b/routing/index_router.cpp
@@ -449,8 +449,7 @@ IRouter::ResultCode IndexRouter::DoCalculateRoute(Checkpoints const & checkpoint
                                       isStartSegmentStrictForward, *graph);
 
     vector<Segment> subroute;
-    auto const result =
-        CalculateSubroute(checkpoints, i, startSegment, finishSegment, delegate, subrouteStarter, subroute);
+    auto const result = CalculateSubroute(checkpoints, i, delegate, subrouteStarter, subroute);
 
     if (result != IRouter::NoError)
       return result;
@@ -491,8 +490,7 @@ IRouter::ResultCode IndexRouter::DoCalculateRoute(Checkpoints const & checkpoint
 }
 
 IRouter::ResultCode IndexRouter::CalculateSubroute(Checkpoints const & checkpoints,
-                                                   size_t subrouteIdx, Segment const & startSegment,
-                                                   Segment const & finishSegment,
+                                                   size_t subrouteIdx,
                                                    RouterDelegate const & delegate,
                                                    IndexGraphStarter & starter,
                                                    vector<Segment> & subroute)
@@ -549,8 +547,9 @@ IRouter::ResultCode IndexRouter::CalculateSubroute(Checkpoints const & checkpoin
   AStarAlgorithm<IndexGraphStarter>::Params params(
       starter, starter.GetStartSegment(), starter.GetFinishSegment(), nullptr /* prevRoute */,
       delegate, onVisitJunction, checkLength);
-  IRouter::ResultCode const result = FindPath<IndexGraphStarter>(params, startSegment.GetMwmId(),
-                                                                 finishSegment.GetMwmId(), routingResult);
+
+  set<NumMwmId> const mwmIds = starter.GetMwms();
+  IRouter::ResultCode const result = FindPath<IndexGraphStarter>(params, mwmIds, routingResult);
   if (result != IRouter::NoError)
     return result;
 
@@ -782,7 +781,19 @@ IRouter::ResultCode IndexRouter::ProcessLeaps(vector<Segment> const & input,
       AStarAlgorithm<IndexGraphStarter>::Params params(
           starter, current, next, nullptr /* prevRoute */, delegate,
           {} /* onVisitedVertexCallback */, checkLength);
-      result = FindPath<IndexGraphStarter>(params, current.GetMwmId(), next.GetMwmId(), routingResult);
+      set<NumMwmId> mwmIds;
+      if (i == 1)
+      {
+        mwmIds = starter.GetStartMwms();
+        mwmIds.insert(next.GetMwmId());
+      }
+      if (i + 1 == input.size())
+      {
+        mwmIds = starter.GetFinishMwms();
+        mwmIds.insert(current.GetMwmId());
+      }
+
+      result = FindPath<IndexGraphStarter>(params, mwmIds, routingResult);
     }
     else
     {
@@ -799,7 +810,8 @@ IRouter::ResultCode IndexRouter::ProcessLeaps(vector<Segment> const & input,
       AStarAlgorithm<WorldGraph>::Params params(worldGraph, current, next, nullptr /* prevRoute */,
                                                 delegate, {} /* onVisitedVertexCallback */,
                                                 checkLength);
-      result = FindPath<WorldGraph>(params, current.GetMwmId(), next.GetMwmId(), routingResult);
+      set<NumMwmId> const mwmIds = {current.GetMwmId(), next.GetMwmId()};
+      result = FindPath<WorldGraph>(params, mwmIds, routingResult);
     }
 
     if (result != IRouter::NoError)
@@ -888,17 +900,19 @@ bool IndexRouter::DoesTransitSectionExist(NumMwmId numMwmId) const
   return mwmValue.m_cont.IsExist(TRANSIT_FILE_TAG);
 }
 
-IRouter::ResultCode IndexRouter::ConvertTransitResult(NumMwmId startMwmId, NumMwmId finalMwmId,
+IRouter::ResultCode IndexRouter::ConvertTransitResult(set<NumMwmId> const & mwmIds,
                                                       IRouter::ResultCode resultCode) const
 {
   if (m_vehicleType != VehicleType::Transit || resultCode != IRouter::ResultCode::RouteNotFound)
     return resultCode;
 
-  CHECK_NOT_EQUAL(startMwmId, kFakeNumMwmId, ());
-  CHECK_NOT_EQUAL(finalMwmId, kFakeNumMwmId, ());
+  for (auto const mwmId : mwmIds)
+  {
+    CHECK_NOT_EQUAL(mwmId, kFakeNumMwmId, ());
+    if (!DoesTransitSectionExist(mwmId))
+      return IRouter::TransitRouteNotFoundNoNetwork;
+  }
 
-  return (DoesTransitSectionExist(startMwmId) && DoesTransitSectionExist(finalMwmId))
-         ? IRouter::TransitRouteNotFoundTooLongPedestrian
-         : IRouter::TransitRouteNotFoundNoNetwork;
+  return IRouter::TransitRouteNotFoundTooLongPedestrian;
 }
 }  // namespace routing
diff --git a/routing/index_router.hpp b/routing/index_router.hpp
index 520a65b4f1..a96105d15c 100644
--- a/routing/index_router.hpp
+++ b/routing/index_router.hpp
@@ -80,7 +80,6 @@ private:
                                        m2::PointD const & startDirection,
                                        RouterDelegate const & delegate, Route & route);
   IRouter::ResultCode CalculateSubroute(Checkpoints const & checkpoints, size_t subrouteIdx,
-                                        Segment const & startSegment, Segment const & finishSegment,
                                         RouterDelegate const & delegate, IndexGraphStarter & graph,
                                         std::vector<Segment> & subroute);
 
@@ -114,7 +113,7 @@ private:
 
   bool AreMwmsNear(std::set<NumMwmId> const & mwmIds) const;
   bool DoesTransitSectionExist(NumMwmId numMwmId) const;
-  IRouter::ResultCode ConvertTransitResult(NumMwmId startMwmId, NumMwmId finalMwmId,
+  IRouter::ResultCode ConvertTransitResult(std::set<NumMwmId> const & mwmIds,
                                            IRouter::ResultCode resultCode) const;
 
   template <typename Graph>
@@ -130,18 +129,17 @@ private:
 
   template <typename Graph>
   IRouter::ResultCode FindPath(
-      typename AStarAlgorithm<Graph>::Params & params, NumMwmId startMwmId, NumMwmId finalMwmId,
+      typename AStarAlgorithm<Graph>::Params & params, std::set<NumMwmId> const & mwmIds,
       RoutingResult<typename Graph::Vertex, typename Graph::Weight> & routingResult) const
   {
     AStarAlgorithm<Graph> algorithm;
     if (params.m_graph.GetMode() == WorldGraph::Mode::LeapsOnly)
     {
-      return ConvertTransitResult(startMwmId, finalMwmId,
+      return ConvertTransitResult(mwmIds,
                                   ConvertResult<Graph>(algorithm.FindPath(params, routingResult)));
     }
     return ConvertTransitResult(
-        startMwmId, finalMwmId,
-        ConvertResult<Graph>(algorithm.FindPathBidirectional(params, routingResult)));
+        mwmIds, ConvertResult<Graph>(algorithm.FindPathBidirectional(params, routingResult)));
   }
 
   VehicleType m_vehicleType;