[search] Moved Results from Engine to Ranker.

6 files changed, 151 insertions, 155 deletions

diff --git a/search/engine.cpp b/search/engine.cpp
index 67cdbe08cd..97b63a2ea2 100644
--- a/search/engine.cpp
+++ b/search/engine.cpp
@@ -25,14 +25,10 @@
 #include "std/map.hpp"
 #include "std/vector.hpp"
 
-#include "3party/Alohalytics/src/alohalytics.h"
-
 namespace search
 {
 namespace
 {
-int const kResultsCount = 30;
-
 class InitSuggestions
 {
   using TSuggestMap = map<pair<strings::UniString, int8_t>, uint8_t>;
@@ -58,36 +54,6 @@ public:
       suggests.emplace_back(s.first.first, s.second, s.first.second);
   }
 };
-
-void SendStatistics(SearchParams const & params, m2::RectD const & viewport, Results const & res)
-{
-  size_t const kMaxNumResultsToSend = 10;
-
-  size_t const numResultsToSend = min(kMaxNumResultsToSend, res.GetCount());
-  string resultString = strings::to_string(numResultsToSend);
-  for (size_t i = 0; i < numResultsToSend; ++i)
-    resultString.append("\t" + res.GetResult(i).ToStringForStats());
-
-  string posX, posY;
-  if (params.IsValidPosition())
-  {
-    posX = strings::to_string(MercatorBounds::LonToX(params.m_lon));
-    posY = strings::to_string(MercatorBounds::LatToY(params.m_lat));
-  }
-
-  alohalytics::TStringMap const stats = {
-      {"posX", posX},
-      {"posY", posY},
-      {"viewportMinX", strings::to_string(viewport.minX())},
-      {"viewportMinY", strings::to_string(viewport.minY())},
-      {"viewportMaxX", strings::to_string(viewport.maxX())},
-      {"viewportMaxY", strings::to_string(viewport.maxY())},
-      {"query", params.m_query},
-      {"locale", params.m_inputLocale},
-      {"results", resultString},
-  };
-  alohalytics::LogEvent("searchEmitResultsAndCoords", stats);
-}
 }  // namespace
 
 // ProcessorHandle----------------------------------------------------------------------------------
@@ -192,27 +158,6 @@ void Engine::ClearCaches()
               });
 }
 
-void Engine::SetRankPivot(SearchParams const & params, m2::RectD const & viewport,
-                          bool viewportSearch, Processor & processor)
-{
-  if (!viewportSearch && params.IsValidPosition())
-  {
-    m2::PointD const pos = MercatorBounds::FromLatLon(params.m_lat, params.m_lon);
-    if (m2::Inflate(viewport, viewport.SizeX() / 4.0, viewport.SizeY() / 4.0).IsPointInside(pos))
-    {
-      processor.SetRankPivot(pos);
-      return;
-    }
-  }
-
-  processor.SetRankPivot(viewport.Center());
-}
-
-void Engine::EmitResults(SearchParams const & params, Results const & res)
-{
-  params.m_onResults(res);
-}
-
 void Engine::MainLoop(Context & context)
 {
   while (true)
@@ -284,7 +229,6 @@ void Engine::DoSearch(SearchParams const & params, m2::RectD const & viewport,
 {
   bool const viewportSearch = params.GetMode() == Mode::Viewport;
 
-  // Initialize query processor.
   processor.Reset();
   processor.Init(viewportSearch);
   handle->Attach(processor);
@@ -300,54 +244,6 @@ void Engine::DoSearch(SearchParams const & params, m2::RectD const & viewport,
     return;
   }
 
-  SetRankPivot(params, viewport, viewportSearch, processor);
-
-  if (params.IsValidPosition())
-    processor.SetPosition(MercatorBounds::FromLatLon(params.m_lat, params.m_lon));
-  else
-    processor.SetPosition(viewport.Center());
-
-  processor.SetMode(params.GetMode());
-  processor.SetSuggestsEnabled(params.GetSuggestsEnabled());
-  processor.SetInputLocale(params.m_inputLocale);
-
-  ASSERT(!params.m_query.empty(), ());
-  processor.SetQuery(params.m_query);
-
-  Results res;
-
-  try
-  {
-    processor.SearchCoordinates(res);
-  }
-  catch (CancelException const &)
-  {
-    LOG(LDEBUG, ("Search has been cancelled."));
-  }
-
-  try
-  {
-    if (params.m_onStarted)
-      params.m_onStarted();
-
-    processor.SetViewport(viewport, true /* forceUpdate */);
-    if (viewportSearch)
-      processor.SearchViewportPoints(res);
-    else
-      processor.Search(res, kResultsCount);
-
-    if (!processor.IsCancelled())
-      EmitResults(params, res);
-  }
-  catch (CancelException const &)
-  {
-    LOG(LDEBUG, ("Search has been cancelled."));
-  }
-
-  if (!viewportSearch && !processor.IsCancelled())
-    SendStatistics(params, viewport, res);
-
-  // Emit finish marker to client.
-  params.m_onResults(Results::GetEndMarker(processor.IsCancelled()));
+  processor.Search(params, viewport);
 }
 }  // namespace search
diff --git a/search/engine.hpp b/search/engine.hpp
index 07f66119e2..4760d9ba68 100644
--- a/search/engine.hpp
+++ b/search/engine.hpp
@@ -144,10 +144,6 @@ private:
   };
 
   // *ALL* following methods are executed on the m_threads threads.
-  void SetRankPivot(SearchParams const & params, m2::RectD const & viewport, bool viewportSearch,
-                    Processor & processor);
-
-  void EmitResults(SearchParams const & params, Results const & res);
 
   // This method executes tasks from a common pool (|tasks|) in a FIFO
   // manner.  |broadcast| contains per-thread tasks, but nevertheless
diff --git a/search/processor.cpp b/search/processor.cpp
index 7ea9df0b23..c83a4d06ba 100644
--- a/search/processor.cpp
+++ b/search/processor.cpp
@@ -41,6 +41,7 @@
 #include "coding/multilang_utf8_string.hpp"
 #include "coding/reader_wrapper.hpp"
 
+#include "base/assert.hpp"
 #include "base/logging.hpp"
 #include "base/macros.hpp"
 #include "base/scope_guard.hpp"
@@ -53,6 +54,8 @@
 #include "std/iterator.hpp"
 #include "std/limits.hpp"
 
+#include "3party/Alohalytics/src/alohalytics.h"
+
 namespace search
 {
 namespace
@@ -94,10 +97,40 @@ m2::RectD GetRectAroundPosition(m2::PointD const & position)
   double constexpr kMaxPositionRadiusM = 50.0 * 1000;
   return MercatorBounds::RectByCenterXYAndSizeInMeters(position, kMaxPositionRadiusM);
 }
+
+void SendStatistics(SearchParams const & params, m2::RectD const & viewport, Results const & res)
+{
+  size_t const kMaxNumResultsToSend = 10;
+
+  size_t const numResultsToSend = min(kMaxNumResultsToSend, res.GetCount());
+  string resultString = strings::to_string(numResultsToSend);
+  for (size_t i = 0; i < numResultsToSend; ++i)
+    resultString.append("\t" + res.GetResult(i).ToStringForStats());
+
+  string posX, posY;
+  if (params.IsValidPosition())
+  {
+    posX = strings::to_string(MercatorBounds::LonToX(params.m_lon));
+    posY = strings::to_string(MercatorBounds::LatToY(params.m_lat));
+  }
+
+  alohalytics::TStringMap const stats = {
+      {"posX", posX},
+      {"posY", posY},
+      {"viewportMinX", strings::to_string(viewport.minX())},
+      {"viewportMinY", strings::to_string(viewport.minY())},
+      {"viewportMaxX", strings::to_string(viewport.maxX())},
+      {"viewportMaxY", strings::to_string(viewport.maxY())},
+      {"query", params.m_query},
+      {"locale", params.m_inputLocale},
+      {"results", resultString},
+  };
+  alohalytics::LogEvent("searchEmitResultsAndCoords", stats);
+}
 }  // namespace
 
 // static
-size_t const Processor::kPreResultsCount;
+size_t const Processor::kPreResultsCount = 200;
 
 // static
 double const Processor::kMinViewportRadiusM = 5.0 * 1000;
@@ -259,8 +292,10 @@ int8_t Processor::GetLanguage(int id) const
 {
   return m_ranker.GetLanguage(GetLangIndex(id));
 }
-m2::PointD Processor::GetPivotPoint(bool viewportSearch) const
+m2::PointD Processor::GetPivotPoint() const
 {
+  bool const viewportSearch = m_mode == Mode::Viewport;
+
   m2::RectD const & viewport = m_viewport[CURRENT_V];
   if (viewportSearch || !viewport.IsPointInside(GetPosition()))
     return viewport.Center();
@@ -339,31 +374,84 @@ void Processor::ForEachCategoryType(StringSliceBase const & slice, ToDo && todo)
   ::search::ForEachCategoryType(slice, GetCategoryLocales(), m_categories, forward<ToDo>(todo));
 }
 
-void Processor::Search(Results & results, size_t limit)
+void Processor::Search(SearchParams const & params, m2::RectD const & viewport)
 {
-  Geocoder::Params geocoderParams;
-  InitGeocoderParams(geocoderParams, false /* viewportSearch */);
+  bool const viewportSearch = m_mode == Mode::Viewport;
 
-  InitPreRanker(false /* viewportSearch */);
-  InitRanker(false /* viewportSearch */);
+  bool rankPivotIsSet = false;
+  if (!viewportSearch && params.IsValidPosition())
+  {
+    m2::PointD const pos = MercatorBounds::FromLatLon(params.m_lat, params.m_lon);
+    if (m2::Inflate(viewport, viewport.SizeX() / 4.0, viewport.SizeY() / 4.0).IsPointInside(pos))
+    {
+      SetRankPivot(pos);
+      rankPivotIsSet = true;
+    }
+  }
+  if (!rankPivotIsSet)
+    SetRankPivot(viewport.Center());
 
-  if (m_tokens.empty())
-    m_ranker.SuggestStrings(results);
+  if (params.IsValidPosition())
+    SetPosition(MercatorBounds::FromLatLon(params.m_lat, params.m_lon));
+  else
+    SetPosition(viewport.Center());
 
-  m_geocoder.GoEverywhere();
-  m_ranker.FlushResults(geocoderParams, results, limit);
-}
+  SetMode(params.GetMode());
+  SetSuggestsEnabled(params.GetSuggestsEnabled());
+  SetInputLocale(params.m_inputLocale);
+
+  ASSERT(!params.m_query.empty(), ());
+  SetQuery(params.m_query);
+  SetViewport(viewport, true /* forceUpdate */);
+  SetOnResults(params.m_onResults);
 
-void Processor::SearchViewportPoints(Results & results)
-{
   Geocoder::Params geocoderParams;
-  InitGeocoderParams(geocoderParams, true /* viewportSearch */);
+  InitGeocoderParams(geocoderParams);
 
-  InitPreRanker(true /* viewportSearch */);
-  InitRanker(true /* viewportSearch */);
+  InitPreRanker();
+  InitRanker();
 
-  m_geocoder.GoInViewport();
-  m_ranker.FlushViewportResults(geocoderParams, results);
+  try
+  {
+    SearchCoordinates(m_ranker.GetResults());
+  }
+  catch (CancelException const &)
+  {
+    LOG(LDEBUG, ("Search has been cancelled."));
+  }
+
+  try
+  {
+    if (params.m_onStarted)
+      params.m_onStarted();
+
+    if (viewportSearch)
+    {
+      m_geocoder.GoInViewport();
+      m_ranker.FlushViewportResults(geocoderParams);
+    }
+    else
+    {
+      if (m_tokens.empty())
+        m_ranker.SuggestStrings(m_ranker.GetResults());
+
+      m_geocoder.GoEverywhere();
+      m_ranker.FlushResults(geocoderParams);
+    }
+
+    if (!IsCancelled())
+      params.m_onResults(m_ranker.GetResults());
+  }
+  catch (CancelException const &)
+  {
+    LOG(LDEBUG, ("Search has been cancelled."));
+  }
+
+  if (!viewportSearch && !IsCancelled())
+    SendStatistics(params, viewport, m_ranker.GetResults());
+
+  // Emit finish marker to client.
+  params.m_onResults(Results::GetEndMarker(IsCancelled()));
 }
 
 void Processor::SearchCoordinates(Results & res) const
@@ -580,8 +668,10 @@ void Processor::InitParams(QueryParams & params)
     params.m_langs.insert(GetLanguage(i));
 }
 
-void Processor::InitGeocoderParams(Geocoder::Params & params, bool viewportSearch)
+void Processor::InitGeocoderParams(Geocoder::Params & params)
 {
+  bool const viewportSearch = m_mode == Mode::Viewport;
+
   InitParams(params);
   params.m_mode = m_mode;
   if (viewportSearch)
@@ -591,21 +681,30 @@ void Processor::InitGeocoderParams(Geocoder::Params & params, bool viewportSearc
   m_geocoder.SetParams(params);
 }
 
-void Processor::InitPreRanker(bool viewportSearch)
+void Processor::InitPreRanker()
 {
   PreRanker::Params params;
 
-  params.m_accuratePivotCenter = GetPivotPoint(viewportSearch);
+  params.m_accuratePivotCenter = GetPivotPoint();
   m_preRanker.Init(params);
 }
 
-void Processor::InitRanker(bool viewportSearch)
+void Processor::InitRanker()
 {
+  size_t const kResultsCount = 30;
+  bool const viewportSearch = m_mode == Mode::Viewport;
   Ranker::Params params;
 
   params.m_currentLocaleCode = m_currentLocaleCode;
-  if (m_mode == Mode::Viewport)
+  if (viewportSearch)
+  {
     params.m_viewport = GetViewport();
+    params.m_limit = kResultsCount;
+  }
+  else
+  {
+    params.m_limit = numeric_limits<size_t>::max();
+  }
   params.m_position = GetPosition();
   params.m_pivotRegion = GetPivotRegion();
   params.m_preferredTypes = m_preferredTypes;
@@ -614,7 +713,8 @@ void Processor::InitRanker(bool viewportSearch)
   params.m_tokens = m_tokens;
   params.m_prefix = m_prefix;
   params.m_categoryLocales = GetCategoryLocales();
-  params.m_accuratePivotCenter = GetPivotPoint(viewportSearch);
+  params.m_accuratePivotCenter = GetPivotPoint();
+  params.m_onResults = m_onResults;
   m_ranker.Init(params);
 }
 
diff --git a/search/processor.hpp b/search/processor.hpp
index 7369941a1f..b33b9da9c7 100644
--- a/search/processor.hpp
+++ b/search/processor.hpp
@@ -61,7 +61,7 @@ class Processor : public my::Cancellable
 {
 public:
   // Maximum result candidates count for each viewport/criteria.
-  static size_t const kPreResultsCount = 200;
+  static size_t const kPreResultsCount;
 
   static double const kMinViewportRadiusM;
   static double const kMaxViewportRadiusM;
@@ -84,7 +84,7 @@ public:
   inline void SetMode(Mode mode) { m_mode = mode; }
   inline void SetSuggestsEnabled(bool enabled) { m_suggestsEnabled = enabled; }
   inline void SetPosition(m2::PointD const & position) { m_position = position; }
-
+  inline void SetOnResults(TOnResults const & onResults) { m_onResults = onResults; }
   inline string const & GetPivotRegion() const { return m_region; }
   inline m2::PointD const & GetPosition() const { return m_position; }
 
@@ -92,20 +92,15 @@ public:
   int8_t m_inputLocaleCode, m_currentLocaleCode;
 
   inline bool IsEmptyQuery() const { return (m_prefix.empty() && m_tokens.empty()); }
-
-  /// @name Various search functions.
-  //@{
-  void Search(Results & results, size_t limit);
-  void SearchViewportPoints(Results & results);
+  void Search(SearchParams const & params, m2::RectD const & viewport);
 
   // Tries to generate a (lat, lon) result from |m_query|.
   void SearchCoordinates(Results & res) const;
-  //@}
 
   void InitParams(QueryParams & params);
-  void InitGeocoderParams(Geocoder::Params & params, bool viewportSearch);
-  void InitPreRanker(bool viewportSearch);
-  void InitRanker(bool viewportSearch);
+  void InitGeocoderParams(Geocoder::Params & params);
+  void InitPreRanker();
+  void InitRanker();
 
   void ClearCaches();
 
@@ -137,7 +132,7 @@ protected:
   template <typename ToDo>
   void ForEachCategoryType(StringSliceBase const & slice, ToDo && todo) const;
 
-  m2::PointD GetPivotPoint(bool viewportSearch) const;
+  m2::PointD GetPivotPoint() const;
   m2::RectD GetPivotRect() const;
 
   void SetViewportByIndex(m2::RectD const & viewport, size_t idx, bool forceUpdate);
@@ -157,6 +152,7 @@ protected:
   m2::PointD m_position;
   Mode m_mode;
   bool m_suggestsEnabled;
+  TOnResults m_onResults;
 
   /// @name Get ranking params.
   //@{
diff --git a/search/ranker.cpp b/search/ranker.cpp
index 1f5d7edfe8..5f40c81ec6 100644
--- a/search/ranker.cpp
+++ b/search/ranker.cpp
@@ -290,6 +290,7 @@ void Ranker::Init(Params const & params)
 {
   m_params = params;
   m_preResults1.clear();
+  m_results.Clear();
 }
 
 bool Ranker::IsResultExists(PreResult2 const & p, vector<IndexedValue> const & values)
@@ -478,7 +479,7 @@ void Ranker::ProcessSuggestions(vector<IndexedValue> & vec, Results & res) const
   }
 }
 
-void Ranker::FlushResults(Geocoder::Params const & params, Results & res, size_t resCount)
+void Ranker::FlushResults(Geocoder::Params const & params)
 {
   vector<IndexedValue> values;
   vector<FeatureID> streets;
@@ -489,23 +490,23 @@ void Ranker::FlushResults(Geocoder::Params const & params, Results & res, size_t
 
   sort(values.rbegin(), values.rend(), my::LessBy(&IndexedValue::GetRank));
 
-  ProcessSuggestions(values, res);
+  ProcessSuggestions(values, m_results);
 
   // Emit feature results.
-  size_t count = res.GetCount();
-  for (size_t i = 0; i < values.size() && count < resCount; ++i)
+  size_t count = m_results.GetCount();
+  for (size_t i = 0; i < values.size() && count < m_params.m_limit; ++i)
   {
     BailIfCancelled();
 
     LOG(LDEBUG, (values[i]));
 
     auto const & preResult2 = *values[i];
-    if (res.AddResult(MakeResult(preResult2)))
+    if (m_results.AddResult(MakeResult(preResult2)))
       ++count;
   }
 }
 
-void Ranker::FlushViewportResults(Geocoder::Params const & geocoderParams, Results & res)
+void Ranker::FlushViewportResults(Geocoder::Params const & geocoderParams)
 {
   vector<IndexedValue> values;
   vector<FeatureID> streets;
@@ -520,7 +521,7 @@ void Ranker::FlushViewportResults(Geocoder::Params const & geocoderParams, Resul
   {
     BailIfCancelled();
 
-    res.AddResultNoChecks(
+    m_results.AddResultNoChecks(
         (*(values[i]))
             .GenerateFinalResult(m_infoGetter, &m_categories, &m_params.m_preferredTypes,
                                  m_params.m_currentLocaleCode,
diff --git a/search/ranker.hpp b/search/ranker.hpp
index 96037582bc..4acbd9c30c 100644
--- a/search/ranker.hpp
+++ b/search/ranker.hpp
@@ -5,6 +5,8 @@
 #include "search/intermediate_result.hpp"
 #include "search/keyword_lang_matcher.hpp"
 #include "search/mode.hpp"
+#include "search/params.hpp"
+#include "search/result.hpp"
 #include "search/reverse_geocoder.hpp"
 #include "search/suggest.hpp"
 
@@ -62,6 +64,9 @@ public:
     m2::PointD m_accuratePivotCenter = m2::PointD(0, 0);
 
     TLocales m_categoryLocales;
+
+    size_t m_limit;
+    TOnResults m_onResults;
   };
 
   Ranker(Index const & index, storage::CountryInfoGetter const & infoGetter,
@@ -90,8 +95,9 @@ public:
   void GetBestMatchName(FeatureType const & f, string & name) const;
   void ProcessSuggestions(vector<IndexedValue> & vec, Results & res) const;
 
-  void FlushResults(Geocoder::Params const & geocoderParams, Results & res, size_t resCount);
-  void FlushViewportResults(Geocoder::Params const & geocoderParams, Results & res);
+  Results & GetResults() { return m_results; }
+  void FlushResults(Geocoder::Params const & geocoderParams);
+  void FlushViewportResults(Geocoder::Params const & geocoderParams);
 
   void SetPreResults1(vector<PreResult1> && preResults1) { m_preResults1 = move(preResults1); }
   void ClearCaches();
@@ -141,5 +147,6 @@ private:
   vector<Suggest> const & m_suggests;
 
   vector<PreResult1> m_preResults1;
+  Results m_results;
 };
 }  // namespace search