diff --git a/map/routing_manager.cpp b/map/routing_manager.cpp index ae436bbec3..5d3d61a5d4 100644 --- a/map/routing_manager.cpp +++ b/map/routing_manager.cpp @@ -532,9 +532,12 @@ void RoutingManager::BuildRoute(uint32_t timeoutSec) m_routingSession.SetUserCurrentPosition(routePoints.front().m_position); - //TODO: build using all points. - m_routingSession.BuildRoute(routePoints.front().m_position, - routePoints.back().m_position, timeoutSec); + std::vector points; + points.reserve(routePoints.size()); + for (auto const & point : routePoints) + points.push_back(point.m_position); + + m_routingSession.BuildRoute(Checkpoints(std::move(points)), timeoutSec); } void RoutingManager::SetUserCurrentPosition(m2::PointD const & position) diff --git a/routing/CMakeLists.txt b/routing/CMakeLists.txt index 27957371bb..5554ee69e9 100644 --- a/routing/CMakeLists.txt +++ b/routing/CMakeLists.txt @@ -16,6 +16,7 @@ set( base/followed_polyline.hpp bicycle_directions.cpp bicycle_directions.hpp + checkpoints.hpp coding.hpp cross_mwm_connector.cpp cross_mwm_connector.hpp diff --git a/routing/async_router.cpp b/routing/async_router.cpp index 3a7bb737b3..2d5d2c87b5 100644 --- a/routing/async_router.cpp +++ b/routing/async_router.cpp @@ -146,17 +146,15 @@ void AsyncRouter::SetRouter(unique_ptr && router, unique_ptr ul(m_guard); - m_startPoint = startPoint; + m_checkpoints = checkpoints; m_startDirection = direction; - m_finalPoint = finalPoint; m_adjustToPrevRoute = adjustToPrevRoute; ResetDelegate(); @@ -258,7 +256,8 @@ void AsyncRouter::ThreadFunc() void AsyncRouter::CalculateRoute() { shared_ptr delegate; - m2::PointD startPoint, finalPoint, startDirection; + Checkpoints checkpoints; + m2::PointD startDirection; bool adjustToPrevRoute = false; shared_ptr absentFetcher; shared_ptr router; @@ -275,8 +274,7 @@ void AsyncRouter::CalculateRoute() if (!m_delegate) return; - startPoint = m_startPoint; - finalPoint = m_finalPoint; + checkpoints = m_checkpoints; startDirection = m_startDirection; adjustToPrevRoute = m_adjustToPrevRoute; delegate = m_delegate; @@ -292,14 +290,18 @@ void AsyncRouter::CalculateRoute() try { - LOG(LDEBUG, ("Calculating the route from", startPoint, "to", finalPoint, "startDirection", startDirection)); + LOG(LDEBUG, ("Calculating the route from", checkpoints.GetStart(), "to", + checkpoints.GetFinish(), "startDirection", startDirection)); if (absentFetcher) - absentFetcher->GenerateRequest(startPoint, finalPoint); + absentFetcher->GenerateRequest(checkpoints.GetStart(), checkpoints.GetFinish()); // Run basic request. - code = router->CalculateRoute(startPoint, startDirection, finalPoint, adjustToPrevRoute, - delegate->GetDelegate(), route); + code = router->CalculateRoute(checkpoints, + startDirection, + adjustToPrevRoute, + delegate->GetDelegate(), + route); elapsedSec = timer.ElapsedSeconds(); // routing time LogCode(code, elapsedSec); @@ -308,12 +310,13 @@ void AsyncRouter::CalculateRoute() { code = IRouter::InternalError; LOG(LERROR, ("Exception happened while calculating route:", e.Msg())); - SendStatistics(startPoint, startDirection, finalPoint, e.Msg()); + SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), e.Msg()); delegate->OnReady(route, code); return; } - SendStatistics(startPoint, startDirection, finalPoint, code, route, elapsedSec); + SendStatistics(checkpoints.GetStart(), startDirection, checkpoints.GetFinish(), code, route, + elapsedSec); // Draw route without waiting network latency. if (code == IRouter::NoError) diff --git a/routing/async_router.hpp b/routing/async_router.hpp index 769db545bf..7f90868706 100644 --- a/routing/async_router.hpp +++ b/routing/async_router.hpp @@ -1,5 +1,6 @@ #pragma once +#include "routing/checkpoints.hpp" #include "routing/online_absent_fetcher.hpp" #include "routing/route.hpp" #include "routing/router.hpp" @@ -40,16 +41,14 @@ public: /// Main method to calulate new route from startPt to finalPt with start direction /// Processed result will be passed to callback. Callback will called at GUI thread. /// - /// @param startPoint point to start routing + /// @param checkpoints start, finish and intermadiate points /// @param direction start direction for routers with high cost of the turnarounds - /// @param finalPoint target point for route /// @param adjustToPrevRoute adjust route to the previous one if possible /// @param readyCallback function to return routing result /// @param progressCallback function to update the router progress /// @param timeoutSec timeout to cancel routing. 0 is infinity. - void CalculateRoute(m2::PointD const & startPoint, m2::PointD const & direction, - m2::PointD const & finalPoint, bool adjustToPrevRoute, - TReadyCallback const & readyCallback, + void CalculateRoute(Checkpoints const & checkpoints, m2::PointD const & direction, + bool adjustToPrevRoute, TReadyCallback const & readyCallback, RouterDelegate::TProgressCallback const & progressCallback, uint32_t timeoutSec); @@ -113,8 +112,7 @@ private: /// Current request parameters bool m_clearState = false; - m2::PointD m_startPoint = m2::PointD::Zero(); - m2::PointD m_finalPoint = m2::PointD::Zero(); + Checkpoints m_checkpoints; m2::PointD m_startDirection = m2::PointD::Zero(); bool m_adjustToPrevRoute = false; shared_ptr m_delegate; diff --git a/routing/checkpoints.hpp b/routing/checkpoints.hpp new file mode 100644 index 0000000000..10794e792a --- /dev/null +++ b/routing/checkpoints.hpp @@ -0,0 +1,53 @@ +#pragma once + +#include "geometry/point2d.hpp" + +#include "base/assert.hpp" + +#include +#include + +namespace routing +{ +class Checkpoints final +{ +public: + Checkpoints() = default; + + Checkpoints(m2::PointD const & start, m2::PointD const & finish) : m_points({start, finish}) {} + + Checkpoints(std::vector && points) : m_points(std::move(points)) { CheckValid(); } + + m2::PointD const & GetStart() const + { + CheckValid(); + return m_points.front(); + } + + m2::PointD const & GetFinish() const + { + CheckValid(); + return m_points.back(); + } + + void SetStart(m2::PointD const & start) + { + CheckValid(); + m_points.front() = start; + } + + std::vector const & GetPoints() const + { + CheckValid(); + return m_points; + } + + void CheckValid() const + { + CHECK_GREATER_OR_EQUAL(m_points.size(), 2, ("Checkpoints should contain start and finish")); + } + +private: + std::vector m_points; +}; +} // namespace routing diff --git a/routing/index_router.cpp b/routing/index_router.cpp index d7432e8527..21f50edb0c 100644 --- a/routing/index_router.cpp +++ b/routing/index_router.cpp @@ -142,30 +142,26 @@ IndexRouter::IndexRouter(string const & name, TCountryFileFn const & countryFile CHECK(m_directionsEngine, ()); } -IRouter::ResultCode IndexRouter::CalculateRoute(m2::PointD const & startPoint, +IRouter::ResultCode IndexRouter::CalculateRoute(Checkpoints const & checkpoints, m2::PointD const & startDirection, - m2::PointD const & finalPoint, bool adjustToPrevRoute, RouterDelegate const & delegate, Route & route) { if (!AllMwmsHaveRoutingIndex(m_index, route)) return IRouter::ResultCode::FileTooOld; - string const startCountry = m_countryFileFn(startPoint); - string const finishCountry = m_countryFileFn(finalPoint); + auto const & startPoint = checkpoints.GetStart(); + auto const & finalPoint = checkpoints.GetFinish(); try { - auto const startFile = platform::CountryFile(startCountry); - auto const finishFile = platform::CountryFile(finishCountry); - if (adjustToPrevRoute && m_lastRoute && finalPoint == m_lastRoute->GetFinish()) { double const distanceToRoute = m_lastRoute->CalcDistance(startPoint); double const distanceToFinish = MercatorBounds::DistanceOnEarth(startPoint, finalPoint); if (distanceToRoute <= kAdjustRangeM && distanceToFinish >= kMinDistanceToFinishM) { - auto code = AdjustRoute(startFile, startPoint, startDirection, finalPoint, delegate, route); + auto code = AdjustRoute(startPoint, startDirection, finalPoint, delegate, route); if (code != IRouter::RouteNotFound) return code; @@ -176,8 +172,7 @@ IRouter::ResultCode IndexRouter::CalculateRoute(m2::PointD const & startPoint, } } - return DoCalculateRoute(startFile, finishFile, false /* forSingleMwm */, startPoint, - startDirection, finalPoint, delegate, route); + return DoCalculateRoute(false /* forSingleMwm */, checkpoints, startDirection, delegate, route); } catch (RootException const & e) { @@ -187,15 +182,18 @@ IRouter::ResultCode IndexRouter::CalculateRoute(m2::PointD const & startPoint, } } -IRouter::ResultCode IndexRouter::DoCalculateRoute(platform::CountryFile const & startCountry, - platform::CountryFile const & finishCountry, - bool forSingleMwm, m2::PointD const & startPoint, +IRouter::ResultCode IndexRouter::DoCalculateRoute(bool forSingleMwm, + Checkpoints const & checkpoints, m2::PointD const & /* startDirection */, - m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route) { m_lastRoute.reset(); + auto const & startPoint = checkpoints.GetStart(); + auto const & finalPoint = checkpoints.GetFinish(); + auto const startCountry = platform::CountryFile(m_countryFileFn(startPoint)); + auto const finishCountry = platform::CountryFile(m_countryFileFn(finalPoint)); + TrafficStash::Guard guard(*m_trafficStash); WorldGraph graph = MakeWorldGraph(); @@ -277,12 +275,13 @@ IRouter::ResultCode IndexRouter::DoCalculateRoute(platform::CountryFile const & return IRouter::NoError; } -IRouter::ResultCode IndexRouter::AdjustRoute(platform::CountryFile const & startCountry, - m2::PointD const & startPoint, +IRouter::ResultCode IndexRouter::AdjustRoute(m2::PointD const & startPoint, m2::PointD const & startDirection, m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route) { + auto const startCountry = platform::CountryFile(m_countryFileFn(startPoint)); + my::Timer timer; TrafficStash::Guard guard(*m_trafficStash); WorldGraph graph = MakeWorldGraph(); diff --git a/routing/index_router.hpp b/routing/index_router.hpp index 8d4c1a2d8f..7483c5f2f4 100644 --- a/routing/index_router.hpp +++ b/routing/index_router.hpp @@ -39,11 +39,9 @@ public: // IRouter overrides: virtual string GetName() const override { return m_name; } - virtual IRouter::ResultCode CalculateRoute(m2::PointD const & startPoint, - m2::PointD const & startDirection, - m2::PointD const & finalPoint, bool adjustToPrevRoute, - RouterDelegate const & delegate, - Route & route) override; + virtual ResultCode CalculateRoute(Checkpoints const & checkpoints, + m2::PointD const & startDirection, bool adjustToPrevRoute, + RouterDelegate const & delegate, Route & route) override; /// \note |numMwmIds| should not be null. static unique_ptr CreateCarRouter(TCountryFileFn const & countryFileFn, @@ -54,14 +52,10 @@ public: Index & index); private: - IRouter::ResultCode DoCalculateRoute(platform::CountryFile const & startCountry, - platform::CountryFile const & finishCountry, - bool forSingleMwm, m2::PointD const & startPoint, + IRouter::ResultCode DoCalculateRoute(bool forSingleMwm, Checkpoints const &checkpoints, m2::PointD const & startDirection, - m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route); - IRouter::ResultCode AdjustRoute(platform::CountryFile const & startCountry, - m2::PointD const & startPoint, m2::PointD const & startDirection, + IRouter::ResultCode AdjustRoute(m2::PointD const & startPoint, m2::PointD const & startDirection, m2::PointD const & finalPoint, RouterDelegate const & delegate, Route & route); diff --git a/routing/road_graph_router.cpp b/routing/road_graph_router.cpp index a8e5448274..863391449c 100644 --- a/routing/road_graph_router.cpp +++ b/routing/road_graph_router.cpp @@ -144,12 +144,15 @@ bool RoadGraphRouter::CheckMapExistence(m2::PointD const & point, Route & route) return true; } -IRouter::ResultCode RoadGraphRouter::CalculateRoute(m2::PointD const & startPoint, - m2::PointD const & /* startDirection */, - m2::PointD const & finalPoint, - bool /* adjust */, - RouterDelegate const & delegate, Route & route) +IRouter::ResultCode RoadGraphRouter::CalculateRoute(Checkpoints const &checkpoints, + m2::PointD const &, + bool, + RouterDelegate const &delegate, + Route &route) { + auto const & startPoint = checkpoints.GetStart(); + auto const & finalPoint = checkpoints.GetFinish(); + if (!CheckMapExistence(startPoint, route) || !CheckMapExistence(finalPoint, route)) return IRouter::RouteFileNotExist; diff --git a/routing/road_graph_router.hpp b/routing/road_graph_router.hpp index f790246305..cfb59e38e3 100644 --- a/routing/road_graph_router.hpp +++ b/routing/road_graph_router.hpp @@ -34,9 +34,9 @@ public: // IRouter overrides: string GetName() const override { return m_name; } void ClearState() override; - ResultCode CalculateRoute(m2::PointD const & startPoint, m2::PointD const & startDirection, - m2::PointD const & finalPoint, bool adjustToPrevRoute, - RouterDelegate const & delegate, Route & route) override; + ResultCode CalculateRoute(Checkpoints const & checkpoints, m2::PointD const & startDirection, + bool adjustToPrevRoute, RouterDelegate const & delegate, + Route & route) override; private: /// Checks existance and add absent maps to route. diff --git a/routing/router.hpp b/routing/router.hpp index 9ce12a91af..fc25e67697 100644 --- a/routing/router.hpp +++ b/routing/router.hpp @@ -1,5 +1,6 @@ #pragma once +#include "routing/checkpoints.hpp" #include "routing/route.hpp" #include "routing/router_delegate.hpp" @@ -77,9 +78,8 @@ public: /// @param route result route /// @return ResultCode error code or NoError if route was initialised /// @see Cancellable - virtual ResultCode CalculateRoute(m2::PointD const & startPoint, - m2::PointD const & startDirection, - m2::PointD const & finalPoint, bool adjust, + virtual ResultCode CalculateRoute(Checkpoints const & checkpoints, + m2::PointD const & startDirection, bool adjust, RouterDelegate const & delegate, Route & route) = 0; }; diff --git a/routing/routing.pro b/routing/routing.pro index e5b813a1ef..1c0b5f9d1f 100644 --- a/routing/routing.pro +++ b/routing/routing.pro @@ -72,6 +72,7 @@ HEADERS += \ base/astar_algorithm.hpp \ base/followed_polyline.hpp \ bicycle_directions.hpp \ + checkpoints.hpp \ coding.hpp \ cross_mwm_connector.hpp \ cross_mwm_connector_serialization.hpp \ diff --git a/routing/routing_integration_tests/routing_test_tools.cpp b/routing/routing_integration_tests/routing_test_tools.cpp index da74756a90..e6aba71422 100644 --- a/routing/routing_integration_tests/routing_test_tools.cpp +++ b/routing/routing_integration_tests/routing_test_tools.cpp @@ -243,8 +243,9 @@ namespace integration IRouter * router = routerComponents.GetRouter(); ASSERT(router, ()); shared_ptr route(new Route("mapsme")); - IRouter::ResultCode result = router->CalculateRoute(startPoint, startDirection, finalPoint, - false /* adjust */, delegate, *route.get()); + IRouter::ResultCode result = + router->CalculateRoute(Checkpoints(startPoint, finalPoint), startDirection, + false /* adjust */, delegate, *route.get()); ASSERT(route, ()); return TRouteResult(route, result); } diff --git a/routing/routing_session.cpp b/routing/routing_session.cpp index 718ce0e212..fdfcd9172c 100644 --- a/routing/routing_session.cpp +++ b/routing/routing_session.cpp @@ -54,7 +54,6 @@ RoutingSession::RoutingSession() , m_route(make_shared(string())) , m_state(RoutingNotActive) , m_isFollowing(false) - , m_endPoint(m2::PointD::Zero()) , m_lastWarnedSpeedCameraIndex(0) , m_lastCheckedSpeedCameraIndex(0) , m_speedWarningSignal(false) @@ -70,16 +69,16 @@ void RoutingSession::Init(TRoutingStatisticsCallback const & routingStatisticsFn m_router.reset(new AsyncRouter(routingStatisticsFn, pointCheckCallback)); } -void RoutingSession::BuildRoute(m2::PointD const & startPoint, m2::PointD const & endPoint, +void RoutingSession::BuildRoute(Checkpoints const & checkpoints, uint32_t timeoutSec) { ASSERT(m_router != nullptr, ()); - m_lastGoodPosition = startPoint; - m_endPoint = endPoint; + m_checkpoints = checkpoints; m_router->ClearState(); m_isFollowing = false; m_routingRebuildCount = -1; // -1 for the first rebuild. - RebuildRoute(startPoint, m_buildReadyCallback, timeoutSec, RouteBuilding, false /* adjust */); + RebuildRoute(checkpoints.GetStart(), m_buildReadyCallback, timeoutSec, RouteBuilding, + false /* adjust */); } void RoutingSession::RebuildRoute(m2::PointD const & startPoint, @@ -87,15 +86,16 @@ void RoutingSession::RebuildRoute(m2::PointD const & startPoint, State routeRebuildingState, bool adjustToPrevRoute) { ASSERT(m_router != nullptr, ()); - ASSERT_NOT_EQUAL(m_endPoint, m2::PointD::Zero(), ("End point was not set")); + m_checkpoints.CheckValid(); RemoveRoute(); SetState(routeRebuildingState); m_routingRebuildCount++; m_lastCompletionPercent = 0; + m_checkpoints.SetStart(startPoint); // Use old-style callback construction, because lambda constructs buggy function on Android // (callback param isn't captured by value). - m_router->CalculateRoute(startPoint, startPoint - m_lastGoodPosition, m_endPoint, adjustToPrevRoute, + m_router->CalculateRoute(m_checkpoints, startPoint - m_lastGoodPosition, adjustToPrevRoute, DoReadyCallback(*this, readyCallback, m_routingSessionMutex), m_progressCallback, timeoutSec); } diff --git a/routing/routing_session.hpp b/routing/routing_session.hpp index 04abd78480..372319fc41 100644 --- a/routing/routing_session.hpp +++ b/routing/routing_session.hpp @@ -85,14 +85,14 @@ public: void SetRouter(unique_ptr && router, unique_ptr && fetcher); - /// @param[in] startPoint and endPoint in mercator + /// @param[in] checkpoints in mercator /// @param[in] timeoutSec timeout in seconds, if zero then there is no timeout - void BuildRoute(m2::PointD const & startPoint, m2::PointD const & endPoint, + void BuildRoute(Checkpoints const & checkpoints, uint32_t timeoutSec); void RebuildRoute(m2::PointD const & startPoint, TReadyCallback const & readyCallback, uint32_t timeoutSec, State routeRebuildingState, bool adjustToPrevRoute); - m2::PointD GetEndPoint() const { return m_endPoint; } + m2::PointD GetEndPoint() const { return m_checkpoints.GetFinish(); } bool IsActive() const { return (m_state != RoutingNotActive); } bool IsNavigable() const { return (m_state == RouteNotStarted || m_state == OnRoute || m_state == RouteFinished); } bool IsBuilt() const { return (IsNavigable() || m_state == RouteNeedRebuild); } @@ -203,7 +203,7 @@ private: shared_ptr m_route; atomic m_state; atomic m_isFollowing; - m2::PointD m_endPoint; + Checkpoints m_checkpoints; size_t m_lastWarnedSpeedCameraIndex; SpeedCameraRestriction m_lastFoundCamera; // Index of a last point on a route checked for a speed camera. diff --git a/routing/routing_tests/async_router_test.cpp b/routing/routing_tests/async_router_test.cpp index 5063463751..2df9de4b4a 100644 --- a/routing/routing_tests/async_router_test.cpp +++ b/routing/routing_tests/async_router_test.cpp @@ -29,12 +29,11 @@ public: // IRouter overrides: string GetName() const override { return "Dummy"; } - ResultCode CalculateRoute(m2::PointD const & startPoint, m2::PointD const & startDirection, - m2::PointD const & finalPoint, bool adjustToPrevRoute, - RouterDelegate const & delegate, Route & route) override + ResultCode CalculateRoute(Checkpoints const & checkpoints, m2::PointD const & startDirection, + bool adjustToPrevRoute, RouterDelegate const & delegate, + Route & route) override { - vector points({startPoint, finalPoint}); - route = Route("dummy", points.begin(), points.end()); + route = Route("dummy", checkpoints.GetPoints().cbegin(), checkpoints.GetPoints().cend()); for (auto const & absent : m_absent) route.AddAbsentCountry(absent); @@ -97,9 +96,7 @@ UNIT_TEST(NeedMoreMapsSignalTest) DummyResultCallback resultCallback(2 /* expectedCalls */); AsyncRouter async(DummyStatisticsCallback, nullptr /* pointCheckCallback */); async.SetRouter(move(router), move(fetcher)); - async.CalculateRoute({1, 2}, {3, 4}, {5, 6}, false /* adjustToPrevRoute */, - bind(ref(resultCallback), _1, _2), nullptr /* progressCallback */, - 0 /* timeoutSec */); + async.CalculateRoute(Checkpoints({1, 2}, {5, 6}), {3, 4}, false, bind(ref(resultCallback), _1, _2), nullptr, 0); resultCallback.WaitFinish(); @@ -119,9 +116,7 @@ UNIT_TEST(StandartAsyncFogTest) DummyResultCallback resultCallback(1 /* expectedCalls */); AsyncRouter async(DummyStatisticsCallback, nullptr /* pointCheckCallback */); async.SetRouter(move(router), move(fetcher)); - async.CalculateRoute({1, 2}, {3, 4}, {5, 6}, false /* adjustToPrevRoute */, - bind(ref(resultCallback), _1, _2), nullptr /* progressCallback */, - 0 /* timeoutSec */); + async.CalculateRoute(Checkpoints({1, 2}, {5, 6}), {3, 4}, false, bind(ref(resultCallback), _1, _2), nullptr, 0); resultCallback.WaitFinish(); diff --git a/routing/routing_tests/routing_session_test.cpp b/routing/routing_tests/routing_session_test.cpp index df5dba265a..6869dca6a1 100644 --- a/routing/routing_tests/routing_session_test.cpp +++ b/routing/routing_tests/routing_session_test.cpp @@ -30,10 +30,11 @@ public: } string GetName() const override { return "dummy"; } void ClearState() override {} - ResultCode CalculateRoute(m2::PointD const & /* startPoint */, - m2::PointD const & /* startDirection */, - m2::PointD const & /* finalPoint */, bool adjust, - RouterDelegate const & /* delegate */, Route & route) override + ResultCode CalculateRoute(Checkpoints const &, + m2::PointD const &, + bool adjust, + RouterDelegate const &, + Route &route) override { ++m_buildCount; route = m_route; @@ -88,7 +89,7 @@ UNIT_TEST(TestRouteBuilding) }, nullptr ); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); // Manual check of the routeBuilded mutex to avoid spurious results. auto const time = steady_clock::now() + kRouteBuildingMaxDuration; TEST(timedSignal.WaitUntil(time), ("Route was not built.")); @@ -111,7 +112,7 @@ UNIT_TEST(TestRouteRebuilding) session.SetReadyCallbacks( [&alongTimedSignal](Route const &, IRouter::ResultCode) { alongTimedSignal.Signal(); }, nullptr); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); // Manual check of the routeBuilded mutex to avoid spurious results. auto time = steady_clock::now() + kRouteBuildingMaxDuration; TEST(alongTimedSignal.WaitUntil(time), ("Route was not built.")); @@ -137,7 +138,7 @@ UNIT_TEST(TestRouteRebuilding) session.SetReadyCallbacks( [&oppositeTimedSignal](Route const &, IRouter::ResultCode) { oppositeTimedSignal.Signal(); }, nullptr); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); TEST(oppositeTimedSignal.WaitUntil(time), ("Route was not built.")); info.m_longitude = 0.; @@ -166,7 +167,7 @@ UNIT_TEST(TestFollowRouteFlagPersistence) session.SetReadyCallbacks( [&alongTimedSignal](Route const &, IRouter::ResultCode) { alongTimedSignal.Signal(); }, nullptr); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); // Manual check of the routeBuilded mutex to avoid spurious results. auto time = steady_clock::now() + kRouteBuildingMaxDuration; TEST(alongTimedSignal.WaitUntil(time), ("Route was not built.")); @@ -197,7 +198,7 @@ UNIT_TEST(TestFollowRouteFlagPersistence) session.SetReadyCallbacks( [&oppositeTimedSignal](Route const &, IRouter::ResultCode) { oppositeTimedSignal.Signal(); }, nullptr); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); TEST(oppositeTimedSignal.WaitUntil(time), ("Route was not built.")); // Manual route building resets the following flag. @@ -241,7 +242,7 @@ UNIT_TEST(TestFollowRoutePercentTest) session.SetReadyCallbacks( [&alongTimedSignal](Route const &, IRouter::ResultCode) { alongTimedSignal.Signal(); }, nullptr); - session.BuildRoute(kTestRoute.front(), kTestRoute.back(), 0); + session.BuildRoute(Checkpoints(kTestRoute.front(), kTestRoute.back()), 0); // Manual check of the routeBuilded mutex to avoid spurious results. auto time = steady_clock::now() + kRouteBuildingMaxDuration; TEST(alongTimedSignal.WaitUntil(time), ("Route was not built."));