[search] Rename Result::Metadata to Result::Details.

map/booking_availability_filter.cpp

@@ -147,7 +147,7 @@ void PrepareData(DataSource const & dataSource, search::Results const & results,
 
   for (auto const & r : results)
   {
-    if (!r.m_metadata.m_isSponsoredHotel || r.GetResultType() != search::Result::Type::Feature)
+    if (!r.m_details.m_isSponsoredHotel || r.GetResultType() != search::Result::Type::Feature)
       continue;
 
     features.push_back(r.GetFeatureID());
@@ -320,7 +320,7 @@ void AvailabilityFilter::GetFeaturesFromCache(search::Results const & results,
 
   for (auto const & r : results)
   {
-    if (!r.m_metadata.m_isSponsoredHotel || r.GetResultType() != search::Result::Type::Feature)
+    if (!r.m_details.m_isSponsoredHotel || r.GetResultType() != search::Result::Type::Feature)
       continue;
 
     features.push_back(r.GetFeatureID());

map/discovery/discovery_search.cpp

@@ -27,18 +27,19 @@ search::Result MakeResultFromFeatureType(FeatureType & ft)
   feature::TypesHolder holder(ft);
   holder.SortBySpec();
 
-  search::Result::Metadata metadata;
-  search::ProcessMetadata(ft, metadata);
+  search::Result::Details details;
+  search::FillDetails(ft, details);
 
-  return {ft.GetID(), feature::GetCenter(ft), name, "", holder.GetBestType(), metadata};
+  return {ft.GetID(),       feature::GetCenter(ft), name,
+          "" /* address */, holder.GetBestType(),   details};
 }
 
 class GreaterRating
 {
 public:
   bool operator()(search::Result const & lhs, search::Result const & rhs) const
   {
-    return lhs.m_metadata.m_hotelRating > rhs.m_metadata.m_hotelRating;
+    return lhs.m_details.m_hotelRating > rhs.m_details.m_hotelRating;
   }
 };
 }  // namespace

map/framework.cpp

@@ -1778,11 +1778,11 @@ void Framework::FillSearchResultsMarks(search::Results::ConstIter begin,
 
     mark->SetMatchedName(r.GetString());
 
-    if (r.m_metadata.m_isSponsoredHotel)
+    if (r.m_details.m_isSponsoredHotel)
     {
       mark->SetBookingType(isFeature && m_localAdsManager.HasVisualization(r.GetFeatureID()) /* hasLocalAds */);
-      mark->SetRating(r.m_metadata.m_hotelRating);
-      mark->SetPricing(r.m_metadata.m_hotelPricing);
+      mark->SetRating(r.m_details.m_hotelRating);
+      mark->SetPricing(r.m_details.m_hotelPricing);
     }
     else if (isFeature)
     {
@@ -3172,9 +3172,9 @@ bool Framework::ParseEditorDebugCommand(search::SearchParams const & params)
       string name;
       ft->GetReadableName(name);
       feature::TypesHolder const types(*ft);
-      search::Result::Metadata smd;
+      search::Result::Details details;
       results.AddResultNoChecks(search::Result(fid, feature::GetCenter(*ft), name, edit.second,
-                                               types.GetBestType(), smd));
+                                               types.GetBestType(), details));
     }
     params.m_onResults(results);
 

map/map_tests/booking_filter_test.cpp

@@ -104,9 +104,9 @@ UNIT_CLASS_TEST(TestMwmEnvironment, BookingFilter_AvailabilitySmoke)
   search::Results expectedResults;
   m_dataSource.ForEachInRect(
       [&results, &expectedResults](FeatureType & ft) {
-        search::Result::Metadata metadata;
-        metadata.m_isSponsoredHotel = true;
-        search::Result result(ft.GetID(), ft.GetCenter(), "", "", 0, metadata);
+        search::Result::Details details;
+        details.m_isSponsoredHotel = true;
+        search::Result result(ft.GetID(), ft.GetCenter(), "", "", 0, details);
         auto copy = result;
         results.AddResult(std::move(result));
         expectedResults.AddResult(std::move(copy));
@@ -177,11 +177,11 @@ UNIT_CLASS_TEST(TestMwmEnvironment, BookingFilter_ProcessorSmoke)
   search::Results expectedAvailableWithDeals;
   m_dataSource.ForEachInRect(
     [&](FeatureType & ft) {
-      search::Result::Metadata metadata;
-      metadata.m_isSponsoredHotel = true;
+      search::Result::Details details;
+      details.m_isSponsoredHotel = true;
       std::string name;
       ft.GetName(StringUtf8Multilang::kDefaultCode, name);
-      search::Result result(ft.GetID(), ft.GetCenter(), name, "", 0, metadata);
+      search::Result result(ft.GetID(), ft.GetCenter(), name, "", 0, details);
       InsertResult(result, results);
 
       auto const sponsoredId = ft.GetMetadata().Get(feature::Metadata::FMD_SPONSORED_ID);
@@ -300,9 +300,9 @@ UNIT_CLASS_TEST(TestMwmEnvironment, BookingFilter_ApplyFilterOntoWithFeatureIds)
   std::vector<FeatureID> expectedFeatureIds;
   m_dataSource.ForEachInRect(
     [&results, &allFeatureIds, &expectedFeatureIds, &kHotelIds](FeatureType & ft) {
-      search::Result::Metadata metadata;
-      metadata.m_isSponsoredHotel = true;
-      search::Result result(ft.GetID(), ft.GetCenter(), "", "", 0, metadata);
+      search::Result::Details details;
+      details.m_isSponsoredHotel = true;
+      search::Result result(ft.GetID(), ft.GetCenter(), "", "", 0, details);
       auto copy = result;
       results.AddResult(std::move(result));
 

search/hotels_classifier.cpp

@@ -16,8 +16,8 @@ bool HotelsClassifier::IsHotelResults(Results const & results)
 
 void HotelsClassifier::Add(Result const & result)
 {
-  if (result.m_metadata.m_isHotel)
-   ++m_numHotels;
+  if (result.m_details.m_isHotel)
+    ++m_numHotels;
 
   ++m_numResults;
 }

search/intermediate_result.cpp

@@ -1,4 +1,5 @@
 #include "search/intermediate_result.hpp"
+
 #include "search/geometry_utils.hpp"
 #include "search/reverse_geocoder.hpp"
 
@@ -9,14 +10,15 @@
 #include "indexer/cuisines.hpp"
 #include "indexer/feature.hpp"
 #include "indexer/feature_algo.hpp"
+#include "indexer/feature_utils.hpp"
 #include "indexer/ftypes_matcher.hpp"
 #include "indexer/ftypes_sponsored.hpp"
 #include "indexer/scales.hpp"
 
-#include "geometry/angles.hpp"
-
 #include "platform/measurement_utils.hpp"
 
+#include "geometry/angles.hpp"
+
 #include "base/logging.hpp"
 #include "base/string_utils.hpp"
 
@@ -148,7 +150,7 @@ RankerResult::RankerResult(FeatureType & f, m2::PointD const & center, m2::Point
   m_region.SetParams(fileName, center);
   m_distance = PointDistance(center, pivot);
 
-  ProcessMetadata(f, m_metadata);
+  FillDetails(f, m_details);
 }
 
 RankerResult::RankerResult(double lat, double lon)
@@ -224,15 +226,15 @@ bool RankerResult::RegionInfo::GetCountryId(storage::CountryInfoGetter const & i
 }
 
 // Functions ---------------------------------------------------------------------------------------
-void ProcessMetadata(FeatureType & ft, Result::Metadata & meta)
+void FillDetails(FeatureType & ft, Result::Details & details)
 {
-  if (meta.m_isInitialized)
+  if (details.m_isInitialized)
     return;
 
   feature::Metadata const & src = ft.GetMetadata();
 
-  meta.m_airportIata = src.Get(feature::Metadata::FMD_AIRPORT_IATA);
-  meta.m_brand = src.Get(feature::Metadata::FMD_BRAND);
+  details.m_airportIata = src.Get(feature::Metadata::FMD_AIRPORT_IATA);
+  details.m_brand = src.Get(feature::Metadata::FMD_BRAND);
 
   string const openHours = src.Get(feature::Metadata::FMD_OPEN_HOURS);
   if (!openHours.empty())
@@ -241,18 +243,18 @@ void ProcessMetadata(FeatureType & ft, Result::Metadata & meta)
     // TODO: We should check closed/open time for specific feature's timezone.
     time_t const now = time(nullptr);
     if (oh.IsValid() && !oh.IsUnknown(now))
-      meta.m_isOpenNow = oh.IsOpen(now) ? osm::Yes : osm::No;
+      details.m_isOpenNow = oh.IsOpen(now) ? osm::Yes : osm::No;
     // In else case value us osm::Unknown, it's set in preview's constructor.
   }
 
-  if (strings::to_int(src.Get(feature::Metadata::FMD_STARS), meta.m_stars))
-    meta.m_stars = base::Clamp(meta.m_stars, 0, 5);
+  if (strings::to_int(src.Get(feature::Metadata::FMD_STARS), details.m_stars))
+    details.m_stars = base::Clamp(details.m_stars, 0, 5);
   else
-    meta.m_stars = 0;
+    details.m_stars = 0;
 
   bool const isSponsoredHotel = ftypes::IsBookingChecker::Instance()(ft);
-  meta.m_isSponsoredHotel = isSponsoredHotel;
-  meta.m_isHotel = ftypes::IsHotelChecker::Instance()(ft);
+  details.m_isSponsoredHotel = isSponsoredHotel;
+  details.m_isHotel = ftypes::IsHotelChecker::Instance()(ft);
 
   if (isSponsoredHotel)
   {
@@ -261,10 +263,9 @@ void ProcessMetadata(FeatureType & ft, Result::Metadata & meta)
     {
       float raw;
       if (strings::to_float(r.c_str(), raw))
-        meta.m_hotelRating = raw;
+        details.m_hotelRating = raw;
     }
 
-
     int pricing;
     if (!strings::to_int(src.Get(feature::Metadata::FMD_PRICE_RATE), pricing))
       pricing = 0;
@@ -273,11 +274,11 @@ void ProcessMetadata(FeatureType & ft, Result::Metadata & meta)
     for (auto i = 0; i < pricing; i++)
       pricingStr.append(kPricingSymbol);
 
-    meta.m_hotelPricing = pricing;
-    meta.m_hotelApproximatePricing = pricingStr;
+    details.m_hotelPricing = pricing;
+    details.m_hotelApproximatePricing = pricingStr;
   }
 
-  meta.m_isInitialized = true;
+  details.m_isInitialized = true;
 }
 
 string DebugPrint(RankerResult const & r)

search/intermediate_result.hpp

@@ -121,7 +121,7 @@ class RankerResult
   m2::PointD GetCenter() const { return m_region.m_point; }
   double GetDistance() const { return m_distance; }
   feature::GeomType GetGeomType() const { return m_geomType; }
-  Result::Metadata GetMetadata() const { return m_metadata; }
+  Result::Details GetDetails() const { return m_details; }
 
   double GetDistanceToPivot() const { return m_info.m_distanceToPivot; }
   double GetLinearModelRank() const { return m_info.GetLinearModelRank(); }
@@ -161,13 +161,13 @@ class RankerResult
   Type m_resultType;
   RankingInfo m_info;
   feature::GeomType m_geomType;
-  Result::Metadata m_metadata;
+  Result::Details m_details;
 
   // The call path in the Geocoder that leads to this result.
   std::vector<ResultTracer::Branch> m_provenance;
 };
 
-void ProcessMetadata(FeatureType & ft, Result::Metadata & meta);
+void FillDetails(FeatureType & ft, Result::Details & meta);
 
 std::string DebugPrint(RankerResult const & r);
 }  // namespace search

search/ranker.cpp

@@ -586,7 +586,7 @@ Result Ranker::MakeResult(RankerResult const & rankerResult, bool needAddress,
     case RankerResult::Type::Building:
     {
       auto const type = rankerResult.GetBestType(m_params.m_preferredTypes);
-      return Result(r.GetID(), r.GetCenter(), name, address, type, r.GetMetadata());
+      return Result(r.GetID(), r.GetCenter(), name, address, type, r.GetDetails());
     }
     case RankerResult::Type::LatLon: return Result(r.GetCenter(), name, address);
     case RankerResult::Type::Postcode: return Result(r.GetCenter(), name);

search/result.cpp

@@ -15,14 +15,14 @@ namespace search
 {
 // Result ------------------------------------------------------------------------------------------
 Result::Result(FeatureID const & id, m2::PointD const & pt, string const & str,
-               string const & address, uint32_t featureType, Metadata const & meta)
+               string const & address, uint32_t featureType, Details const & details)
   : m_resultType(Type::Feature)
   , m_id(id)
   , m_center(pt)
   , m_str(str)
   , m_address(address)
   , m_featureType(featureType)
-  , m_metadata(meta)
+  , m_details(details)
 {
 }
 

search/result.hpp

@@ -41,8 +41,8 @@ class Result
     Postcode
   };
 
-  // Metadata for search results. Considered valid if GetResultType() == Type::Feature.
-  struct Metadata
+  // Search results details. Considered valid if GetResultType() == Type::Feature.
+  struct Details
   {
     // Valid only if not empty, used for restaurants.
     std::string m_cuisine;
@@ -72,7 +72,7 @@ class Result
 
   // For Type::Feature.
   Result(FeatureID const & id, m2::PointD const & pt, std::string const & str,
-         std::string const & address, uint32_t featureType, Metadata const & meta);
+         std::string const & address, uint32_t featureType, Details const & meta);
 
   // For Type::LatLon.
   Result(m2::PointD const & pt, std::string const & latlon, std::string const & address);
@@ -90,18 +90,18 @@ class Result
 
   std::string const & GetString() const { return m_str; }
   std::string const & GetAddress() const { return m_address; }
-  std::string const & GetCuisine() const { return m_metadata.m_cuisine; }
-  std::string const & GetAirportIata() const { return m_metadata.m_airportIata; }
-  std::string const & GetBrand() const { return m_metadata.m_brand; }
-  float GetHotelRating() const { return m_metadata.m_hotelRating; }
+  std::string const & GetCuisine() const { return m_details.m_cuisine; }
+  std::string const & GetAirportIata() const { return m_details.m_airportIata; }
+  std::string const & GetBrand() const { return m_details.m_brand; }
+  float GetHotelRating() const { return m_details.m_hotelRating; }
   std::string const & GetHotelApproximatePricing() const
   {
-    return m_metadata.m_hotelApproximatePricing;
+    return m_details.m_hotelApproximatePricing;
   }
-  bool IsHotel() const { return m_metadata.m_isHotel; }
+  bool IsHotel() const { return m_details.m_isHotel; }
 
-  osm::YesNoUnknown IsOpenNow() const { return m_metadata.m_isOpenNow; }
-  int GetStarsCount() const { return m_metadata.m_stars; }
+  osm::YesNoUnknown IsOpenNow() const { return m_details.m_isOpenNow; }
+  int GetStarsCount() const { return m_details.m_stars; }
 
   bool IsSuggest() const;
   bool HasPoint() const;
@@ -175,7 +175,7 @@ class Result
 
 public:
   // Careful when moving: the order of destructors is important.
-  Metadata m_metadata;
+  Details m_details;
 };
 
 std::string DebugPrint(search::Result::Type type);

search/search_tests/results_tests.cpp

@@ -38,19 +38,19 @@ UNIT_TEST(Results_Sorting)
 UNIT_TEST(Result_PrependCity)
 {
   FeatureID const fid;
-  Result::Metadata const meta;
+  Result::Details const details;
 
   {
     Result r(fid, m2::PointD::Zero(), "" /* str */, "Moscow, Russia" /* address */,
-             0 /* featureType */, meta);
+             0 /* featureType */, details);
 
     r.PrependCity("Moscow");
     TEST_EQUAL(r.GetAddress(), "Moscow, Russia", ());
   }
 
   {
     Result r(fid, m2::PointD::Zero(), "улица Михася Лынькова" /* str */,
-             "Минская область, Беларусь" /* address */, 0 /* featureType */, meta);
+             "Минская область, Беларусь" /* address */, 0 /* featureType */, details);
 
     r.PrependCity("Минск");
     TEST_EQUAL(r.GetAddress(), "Минск, Минская область, Беларусь", ());