pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[discovery] New search

Browse source
This commit is contained in:
Arsentiy Milchakov 2018-07-18 15:40:33 +03:00 • committed by Vlad Mihaylenko
parent 4b59eef5c8
commit a8d38bb7c9
11 changed files with 392 additions and 228 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
map/CMakeLists.txt
View file

@ -39,8 +39,8 @@ set(
discovery/discovery_client_params.hpp
discovery/discovery_manager.cpp
discovery/discovery_manager.hpp
discovery/discovery_search_callback.cpp
discovery/discovery_search_callback.hpp
discovery/discovery_search.cpp
discovery/discovery_search.hpp
discovery/discovery_search_params.hpp
displacement_mode_manager.cpp
displacement_mode_manager.hpp

11
map/discovery/discovery_manager.cpp
View file

@ -35,20 +35,13 @@ Manager::Manager(DataSource const & dataSource, search::CityFinder & cityFinder,
}
// static
search::DiscoverySearchParams Manager::GetSearchParams(Manager::Params const & params, ItemType const type)
DiscoverySearchParams Manager::GetSearchParams(Manager::Params const & params, ItemType const type)
{
search::DiscoverySearchParams p;
DiscoverySearchParams p;
p.m_query = GetQuery(type);
p.m_viewport = params.m_viewport;
p.m_position = params.m_viewportCenter;
p.m_itemsCount = params.m_itemsCount;
using Sorting = search::DiscoverySearchParams::SortingType;
if (type == ItemType::Hotels)
p.m_sortingType = Sorting::HotelRating;
else if (type == ItemType::Attractions || type == ItemType::Cafes)
p.m_sortingType = Sorting::Popularity;
return p;
}

10
map/discovery/discovery_manager.hpp
View file

@ -3,6 +3,7 @@
#include "search/city_finder.hpp"
#include "map/discovery/discovery_client_params.hpp"
#include "map/discovery/discovery_search.hpp"
#include "map/discovery/discovery_search_params.hpp"
#include "map/search_api.hpp"
#include "map/search_product_info.hpp"
@ -123,7 +124,12 @@ public:
onResult(requestId, results, productInfo, type, viewportCenter);
});
};
m_searchApi.SearchForDiscovery(p);
if (type == ItemType::Hotels)
ProcessSearchIntent(std::make_shared<SearchHotels>(m_dataSource, p, m_searchApi));
else
ProcessSearchIntent(std::make_shared<SearchPopularPlaces>(m_dataSource, p, m_searchApi));
break;
}
case ItemType::LocalExperts:
@ -153,7 +159,7 @@ public:
std::string GetLocalExpertsUrl(m2::PointD const & point) const;
private:
static search::DiscoverySearchParams GetSearchParams(Manager::Params const & params, ItemType const type);
static DiscoverySearchParams GetSearchParams(Manager::Params const & params, ItemType const type);
std::string GetCityViatorId(m2::PointD const & point) const;
DataSource const & m_dataSource;

285
map/discovery/discovery_search.cpp Normal file
View file

@ -0,0 +1,285 @@
#include "map/discovery/discovery_search.hpp"
#include "search/intermediate_result.hpp"
#include "search/utils.hpp"
#include "indexer/feature_algo.hpp"
#include "indexer/data_source.hpp"
#include "platform/platform.hpp"
#include "base/assert.hpp"
#include <algorithm>
#include <set>
#include <utility>
namespace
{
search::Result MakeResultFromFeatureType(FeatureType const & ft)
{
std::string name;
ft.GetName(StringUtf8Multilang::GetLangIndex(languages::GetCurrentNorm()), name);
feature::TypesHolder holder(ft);
holder.SortBySpec();
CategoriesHolder const & categories = GetDefaultCategories();
auto const readableType =
categories.GetReadableFeatureType(holder.GetBestType(),
categories.MapLocaleToInteger(languages::GetCurrentOrig()));
search::Result::Metadata metadata;
search::ProcessMetadata(ft, metadata);
return {ft.GetID(), feature::GetCenter(ft), name, "", readableType, holder.GetBestType(), metadata};
}
FeatureType MakeFeatureTypeWithCachedGuard(DataSource const & dataSource, MwmSet::MwmId & mwmId,
std::unique_ptr<FeaturesLoaderGuard> & guard,
FeatureID const & id)
{
if (mwmId != id.m_mwmId)
{
guard = my::make_unique<FeaturesLoaderGuard>(dataSource, id.m_mwmId);
mwmId = id.m_mwmId;
}
FeatureType ft;
if (!guard->GetFeatureByIndex(id.m_index, ft))
{
LOG(LERROR, ("Feature can't be loaded:", id));
return {};
}
return ft;
}
class GreaterRating
{
public:
bool operator()(FeatureType const & lhs, FeatureType const & rhs) const
{
double constexpr kPenaltyRating = -1.0;
double lhsRating = kPenaltyRating;
double rhsRating = kPenaltyRating;
if (!strings::to_double(lhs.GetMetadata().Get(feature::Metadata::EType::FMD_RATING), lhsRating))
lhsRating = kPenaltyRating;
if (!strings::to_double(rhs.GetMetadata().Get(feature::Metadata::EType::FMD_RATING), rhsRating))
rhsRating = kPenaltyRating;
return lhsRating > rhsRating;
}
};
} // namespace
namespace discovery
{
SearchBase::SearchBase(DataSource const & dataSource, DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate)
: m_dataSource(dataSource)
, m_params(params)
, m_productInfoDelegate(productInfoDelegate)
{
CHECK(params.m_onResults, ());
CHECK(!params.m_query.empty(), ());
CHECK_GREATER(params.m_itemsCount, 0, ());
}
void SearchBase::Search()
{
MwmSet::MwmId currentMwmId;
MwmSet::MwmHandle currentMwmHandle;
search::ForEachOfTypesInRect(m_dataSource,
search::GetCategoryTypes(m_params.m_query, "en", GetDefaultCategories()),
m_params.m_viewport,
[&](FeatureID const & id)
{
if (currentMwmId != id.m_mwmId)
{
currentMwmId = id.m_mwmId;
OnMwmChanged(m_dataSource.GetMwmHandleById(id.m_mwmId));
}
ProcessFeatureId(id);
});
ProcessAccumulated();
if (m_params.m_onResults)
m_params.m_onResults(m_results, m_productInfo);
}
search::Results const & SearchBase::GetResults() const
{
return m_results;
}
std::vector<search::ProductInfo> const & SearchBase::GetProductInfo() const
{
return m_productInfo;
}
DataSource const & SearchBase::GetDataSource() const
{
return m_dataSource;
}
DiscoverySearchParams const & SearchBase::GetParams() const
{
return m_params;
}
void SearchBase::AppendResult(search::Result && result)
{
m_productInfo.emplace_back(m_productInfoDelegate.GetProductInfo(result));
m_results.AddResultNoChecks(std::move(result));
}
void SearchBase::OnMwmChanged(MwmSet::MwmHandle const & handle)
{
}
SearchHotels::SearchHotels(DataSource const & dataSource, DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate)
: SearchBase(dataSource, params, productInfoDelegate)
{
}
void SearchHotels::ProcessFeatureId(FeatureID const & id)
{
m_featureIds.emplace_back(id);
}
void SearchHotels::ProcessAccumulated()
{
ASSERT(std::is_sorted(m_featureIds.cbegin(), m_featureIds.cend()), ());
MwmSet::MwmId mwmId;
std::unique_ptr<FeaturesLoaderGuard> guard;
auto const makeFeatureType = [this, &guard, &mwmId](FeatureID const & id)
{
return MakeFeatureTypeWithCachedGuard(GetDataSource(), mwmId, guard, id);
};
std::multiset<FeatureType, GreaterRating> sortedByRating;
for (auto const & id : m_featureIds)
{
sortedByRating.emplace(makeFeatureType(id));
}
for (auto const & ft : sortedByRating)
{
auto result = MakeResultFromFeatureType(ft);
AppendResult(std::move(result));
if (GetResults().GetCount() >= GetParams().m_itemsCount)
break;
}
}
SearchPopularPlaces::SearchPopularPlaces(DataSource const & dataSource,
DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate)
: SearchBase(dataSource, params, productInfoDelegate)
{
}
void SearchPopularPlaces::OnMwmChanged(MwmSet::MwmHandle const & handle)
{
m_popularityRanks.reset();
if (handle.IsAlive())
{
m_popularityRanks = search::RankTable::Load(handle.GetValue<MwmValue>()->m_cont,
POPULARITY_RANKS_FILE_TAG);
}
}
void SearchPopularPlaces::ProcessFeatureId(FeatureID const & id)
{
uint8_t popularity = 0;
if (m_popularityRanks)
popularity = m_popularityRanks->Get(id.m_index);
if (popularity != 0 || m_accumulatedResults.size() < GetParams().m_itemsCount)
{
m_accumulatedResults.emplace(popularity, id);
}
}
void SearchPopularPlaces::ProcessAccumulated()
{
MwmSet::MwmId mwmId;
std::unique_ptr<FeaturesLoaderGuard> guard;
auto const makeFeatureType = [this, &guard, &mwmId](FeatureID const & id)
{
return MakeFeatureTypeWithCachedGuard(GetDataSource(), mwmId, guard, id);
};
auto const appendResult = [this](uint8_t popularity, FeatureType const & ft)
{
auto result = MakeResultFromFeatureType(ft);
search::RankingInfo rankingInfo;
rankingInfo.m_popularity = popularity;
result.SetRankingInfo(std::move(rankingInfo));
AppendResult(std::move(result));
};
auto const itemsCount = GetParams().m_itemsCount;
std::vector<FeatureID> featuresWithoutNames;
for (auto const & item : m_accumulatedResults)
{
if (GetResults().GetCount() >= itemsCount)
break;
auto const popularity = item.first;
auto const ft = makeFeatureType(item.second);
if (popularity > 0)
{
appendResult(popularity, ft);
continue;
}
if (ft.HasName())
{
appendResult(popularity, ft);
continue;
}
if (featuresWithoutNames.size() < (itemsCount - GetResults().GetCount()))
featuresWithoutNames.emplace_back(item.second);
}
// Append unnamed results if needed.
if (GetResults().GetCount() < itemsCount)
{
for (auto const & featureId : featuresWithoutNames)
{
appendResult(0, makeFeatureType(featureId));
if (GetResults().GetCount() >= itemsCount)
break;
}
}
}
void ProcessSearchIntent(std::shared_ptr<SearchBase> intent)
{
if (!intent)
return;
GetPlatform().RunTask(Platform::Thread::File, [intent]()
{
intent->Search();
});
}
} // namespace discovery

83
map/discovery/discovery_search.hpp Normal file
View file

@ -0,0 +1,83 @@
#pragma once
#include "map/discovery/discovery_search_params.hpp"
#include "map/search_product_info.hpp"
#include "indexer/feature_decl.hpp"
#include "indexer/mwm_set.hpp"
#include "indexer/rank_table.hpp"
#include "search/result.hpp"
#include <cstdint>
#include <map>
#include <memory>
#include <vector>
class DataSource;
namespace discovery
{
class SearchBase
{
public:
SearchBase(DataSource const & dataSource, DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate);
void Search();
search::Results const & GetResults() const;
std::vector<search::ProductInfo> const & GetProductInfo() const;
protected:
DataSource const & GetDataSource() const;
DiscoverySearchParams const & GetParams() const;
void AppendResult(search::Result && result);
virtual void OnMwmChanged(MwmSet::MwmHandle const & handle);
virtual void ProcessFeatureId(FeatureID const & id) = 0;
virtual void ProcessAccumulated() = 0;
private:
DataSource const & m_dataSource;
DiscoverySearchParams const m_params;
search::ProductInfo::Delegate const & m_productInfoDelegate;
search::Results m_results;
std::vector<search::ProductInfo> m_productInfo;
};
struct SearchHotels : public SearchBase
{
public:
SearchHotels(DataSource const & dataSource, DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate);
protected:
// SearchBase overrides:
void ProcessFeatureId(FeatureID const & id) override;
void ProcessAccumulated() override;
private:
std::vector<FeatureID> m_featureIds;
};
struct SearchPopularPlaces : public SearchBase
{
public:
SearchPopularPlaces(DataSource const & dataSource, DiscoverySearchParams const & params,
search::ProductInfo::Delegate const & productInfoDelegate);
protected:
// SearchBase overrides:
void OnMwmChanged(MwmSet::MwmHandle const & handle) override;
void ProcessFeatureId(FeatureID const & id) override;
void ProcessAccumulated() override;
private:
unique_ptr<search::RankTable> m_popularityRanks;
std::map<uint8_t, FeatureID, std::greater<uint8_t>> m_accumulatedResults;
};
void ProcessSearchIntent(std::shared_ptr<SearchBase> intent);
} // namespace discovery

28
map/discovery/discovery_search_callback.cpp
View file

@ -1,28 +0,0 @@
#include "map/discovery/discovery_search_callback.hpp"
#include <cstddef>
#include <utility>
namespace search
{
DiscoverySearchCallback::DiscoverySearchCallback(ProductInfo::Delegate & delegate,
DiscoverySearchParams::OnResults onResults)
: m_delegate(delegate)
, m_onResults(std::move(onResults))
{
}
void DiscoverySearchCallback::operator()(Results const & results)
{
auto const prevSize = m_productInfo.size();
ASSERT_LESS_OR_EQUAL(prevSize, results.GetCount(), ());
for (size_t i = prevSize; i < results.GetCount(); ++i)
{
m_productInfo.push_back(m_delegate.GetProductInfo(results[i]));
}
ASSERT_EQUAL(m_productInfo.size(), results.GetCount(), ());
m_onResults(results, m_productInfo);
}
} // namespace search

26
map/discovery/discovery_search_callback.hpp
View file

@ -1,26 +0,0 @@
#pragma once
#include "map/discovery/discovery_search_params.hpp"
#include "map/search_product_info.hpp"
#include "search/result.hpp"
#include <functional>
#include <vector>
namespace search
{
class DiscoverySearchCallback
{
public:
DiscoverySearchCallback(ProductInfo::Delegate & delegate,
DiscoverySearchParams::OnResults onResults);
void operator()(Results const & results);
private:
ProductInfo::Delegate & m_delegate;
DiscoverySearchParams::OnResults m_onResults;
std::vector<ProductInfo> m_productInfo;
};
} // namespace search

44
map/discovery/discovery_search_params.hpp
View file

@ -13,53 +13,17 @@
#include <string>
#include <vector>
namespace search
namespace discovery
{
struct DiscoverySearchParams
{
enum class SortingType
{
ByPosition,
HotelRating,
Popularity
};
struct ByPositionComparator
{
bool operator()(Result const & lhs, Result const & rhs) const
{
return lhs.GetPositionInResults() < rhs.GetPositionInResults();
}
};
struct HotelRatingComparator
{
bool operator()(Result const & lhs, Result const & rhs) const
{
return lhs.m_metadata.m_hotelRating > rhs.m_metadata.m_hotelRating;
}
};
struct PopularityComparator
{
bool operator()(Result const & lhs, Result const & rhs) const
{
// Move results without names to the end.
if (lhs.GetString().empty())
return false;
return lhs.GetRankingInfo().m_popularity > rhs.GetRankingInfo().m_popularity;
}
};
using OnResults =
std::function<void(Results const & results, std::vector<ProductInfo> const & productInfo)>;
std::function<void(search::Results const & results,
std::vector<search::ProductInfo> const & productInfo)>;
std::string m_query;
size_t m_itemsCount = 0;
m2::PointD m_position;
m2::RectD m_viewport;
SortingType m_sortingType = SortingType::ByPosition;
OnResults m_onResults = nullptr;
};
} // namespace search
} // namespace discovery

110
map/search_api.cpp
View file

@ -1,7 +1,6 @@
#include "map/search_api.hpp"
#include "map/bookmarks_search_params.hpp"
#include "map/discovery/discovery_search_callback.hpp"
#include "map/discovery/discovery_search_params.hpp"
#include "map/everywhere_search_params.hpp"
#include "map/viewport_search_params.hpp"
@ -33,7 +32,6 @@ namespace
using BookmarkIdDoc = pair<bookmarks::Id, bookmarks::Doc>;
double const kDistEqualQueryMeters = 100.0;
size_t const kDefaultNumResultsForDiscovery = 200;
// Cancels search query by |handle|.
void CancelQuery(weak_ptr<ProcessorHandle> & handle)
@ -117,70 +115,6 @@ private:
BookmarksSearchParams::Status m_status = BookmarksSearchParams::Status::InProgress;
OnResults m_onResults;
};
Results TrimResults(Results && results, size_t const maxCount)
{
if (results.GetCount() <= maxCount)
return results;
Results r;
r.AddResultsNoChecks(results.begin(), results.begin() + maxCount);
return r;
}
class DiscoveryResultMaker
{
public:
DiscoveryResultMaker(DiscoverySearchParams const & params, Results const & results,
vector<ProductInfo> const & productInfo)
: m_params(params)
, m_results(results)
, m_productInfo(productInfo)
{
}
template <typename Comparator>
void OnResults()
{
Results r;
vector<ProductInfo> info;
for (auto & item : MakeMap<Comparator>())
{
auto copy = item.first;
r.AddResultNoChecks(move(copy));
info.emplace_back(move(item.second));
}
m_params.m_onResults(TrimResults(move(r), m_params.m_itemsCount), info);
}
private:
template <typename Comparator>
multimap<Result, ProductInfo, Comparator> MakeMap()
{
auto const & v = m_params.m_viewport;
auto const maxDistance = MercatorBounds::DistanceOnEarth(v.LeftTop(), v.RightTop()) / 2;
multimap<Result, ProductInfo, Comparator> ret;
for (size_t i = 0; i < m_results.GetCount(); ++i)
{
auto distanceToCenter =
MercatorBounds::DistanceOnEarth(m_results[i].GetFeatureCenter(), v.Center());
if (distanceToCenter > maxDistance)
continue;
ret.emplace(m_results[i], m_productInfo[i]);
}
return ret;
};
DiscoverySearchParams const & m_params;
Results const & m_results;
vector<ProductInfo> const & m_productInfo;
};
} // namespace
SearchAPI::SearchAPI(DataSource & dataSource, storage::Storage const & storage,
@ -279,50 +213,6 @@ bool SearchAPI::SearchInViewport(ViewportSearchParams const & params)
return Search(p, false /* forceSearch */);
}
void SearchAPI::SearchForDiscovery(DiscoverySearchParams const & params)
{
CHECK(params.m_onResults, ());
CHECK(!params.m_query.empty(), ());
CHECK_GREATER(params.m_itemsCount, 0, ());
SearchParams p;
p.m_query = params.m_query;
p.m_inputLocale = "en";
p.m_viewport = params.m_viewport;
p.m_position = params.m_position;
p.m_maxNumResults = kDefaultNumResultsForDiscovery;
p.m_mode = search::Mode::Everywhere;
p.m_onResults = DiscoverySearchCallback(
static_cast<ProductInfo::Delegate &>(*this),
[params](Results const & results, vector<ProductInfo> const & productInfo) {
if (!results.IsEndMarker())
return;
DiscoveryResultMaker maker(params, results, productInfo);
switch (params.m_sortingType)
{
case DiscoverySearchParams::SortingType::ByPosition:
{
maker.OnResults<DiscoverySearchParams::ByPositionComparator>();
break;
}
case DiscoverySearchParams::SortingType::HotelRating:
{
maker.OnResults<DiscoverySearchParams::HotelRatingComparator>();
break;
}
case DiscoverySearchParams::SortingType::Popularity:
{
maker.OnResults<DiscoverySearchParams::PopularityComparator>();
break;
}
}
});
GetEngine().Search(p);
}
bool SearchAPI::SearchInDownloader(storage::DownloaderSearchParams const & params)
{
SearchParams p;

3
map/search_api.hpp
View file

@ -2,7 +2,6 @@
#include "map/booking_filter_params.hpp"
#include "map/bookmark.hpp"
#include "map/discovery/discovery_search_callback.hpp"
#include "map/everywhere_search_callback.hpp"
#include "map/search_product_info.hpp"
#include "map/viewport_search_callback.hpp"
@ -104,8 +103,6 @@ public:
// Search in the viewport.
bool SearchInViewport(search::ViewportSearchParams const & params);
void SearchForDiscovery(search::DiscoverySearchParams const & params);
// Search for maps by countries or cities.
bool SearchInDownloader(storage::DownloaderSearchParams const & params);

16
xcode/map/map.xcodeproj/project.pbxproj
View file

@ -33,8 +33,8 @@
3D4E99A31FB4A6410025B48C /* booking_filter_cache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D4E999F1FB4A6400025B48C /* booking_filter_cache.cpp */; };
3D4E99A51FB4A6410025B48C /* booking_filter.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D4E99A11FB4A6410025B48C /* booking_filter.hpp */; };
3D62CBCC20F4DFD600E7BB6E /* search_product_info.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D62CBCB20F4DFD600E7BB6E /* search_product_info.hpp */; };
3D62CBCF20F4DFE800E7BB6E /* discovery_search_callback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D62CBCD20F4DFE700E7BB6E /* discovery_search_callback.cpp */; };
3D62CBD020F4DFE800E7BB6E /* discovery_search_callback.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D62CBCE20F4DFE700E7BB6E /* discovery_search_callback.hpp */; };
3D62CBD920FF6C8B00E7BB6E /* discovery_search.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D62CBD720FF6C8B00E7BB6E /* discovery_search.cpp */; };
3D62CBDA20FF6C8B00E7BB6E /* discovery_search.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3D62CBD820FF6C8B00E7BB6E /* discovery_search.hpp */; };
3D74ABBE1EA76F1D0063A898 /* local_ads_supported_types.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3D74ABBD1EA76F1D0063A898 /* local_ads_supported_types.cpp */; };
3DA5713F20B5CC80007BDE27 /* booking_availability_filter.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3DA5713A20B5CC7F007BDE27 /* booking_availability_filter.hpp */; };
3DA5714020B5CC80007BDE27 /* booking_filter_params.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 3DA5713B20B5CC7F007BDE27 /* booking_filter_params.hpp */; };
@ -251,8 +251,8 @@
3D4E999F1FB4A6400025B48C /* booking_filter_cache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = booking_filter_cache.cpp; sourceTree = "<group>"; };
3D4E99A11FB4A6410025B48C /* booking_filter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = booking_filter.hpp; sourceTree = "<group>"; };
3D62CBCB20F4DFD600E7BB6E /* search_product_info.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = search_product_info.hpp; sourceTree = "<group>"; };
3D62CBCD20F4DFE700E7BB6E /* discovery_search_callback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = discovery_search_callback.cpp; sourceTree = "<group>"; };
3D62CBCE20F4DFE700E7BB6E /* discovery_search_callback.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = discovery_search_callback.hpp; sourceTree = "<group>"; };
3D62CBD720FF6C8B00E7BB6E /* discovery_search.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = discovery_search.cpp; sourceTree = "<group>"; };
3D62CBD820FF6C8B00E7BB6E /* discovery_search.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = discovery_search.hpp; sourceTree = "<group>"; };
3D74ABBD1EA76F1D0063A898 /* local_ads_supported_types.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = local_ads_supported_types.cpp; sourceTree = "<group>"; };
3DA5713A20B5CC7F007BDE27 /* booking_availability_filter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = booking_availability_filter.hpp; sourceTree = "<group>"; };
3DA5713B20B5CC7F007BDE27 /* booking_filter_params.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = booking_filter_params.hpp; sourceTree = "<group>"; };
@ -818,8 +818,8 @@
F6FC3CB11FC323420001D929 /* discovery */ = {
isa = PBXGroup;
children = (
3D62CBCD20F4DFE700E7BB6E /* discovery_search_callback.cpp */,
3D62CBCE20F4DFE700E7BB6E /* discovery_search_callback.hpp */,
3D62CBD720FF6C8B00E7BB6E /* discovery_search.cpp */,
3D62CBD820FF6C8B00E7BB6E /* discovery_search.hpp */,
F69687C7201B4A3500457650 /* discovery_search_params.hpp */,
F6FC3CB21FC323420001D929 /* discovery_client_params.hpp */,
F6FC3CB31FC323420001D929 /* discovery_manager.cpp */,
@ -866,12 +866,12 @@
BBFC7E3B202D29C000531BE7 /* user_mark_layer.hpp in Headers */,
3D4E99A51FB4A6410025B48C /* booking_filter.hpp in Headers */,
56C116612090E5670068BBC0 /* extrapolator.hpp in Headers */,
3D62CBDA20FF6C8B00E7BB6E /* discovery_search.hpp in Headers */,
675346491A4054E800A0A8C3 /* bookmark_manager.hpp in Headers */,
3DA5714320B5CC80007BDE27 /* booking_filter_processor.hpp in Headers */,
F6B2830A1C1B03320081957A /* gps_track.hpp in Headers */,
3D4E99A21FB4A6410025B48C /* booking_filter_cache.hpp in Headers */,
F6D67CE32063F4980032FD38 /* framework_light.hpp in Headers */,
3D62CBD020F4DFE800E7BB6E /* discovery_search_callback.hpp in Headers */,
45F6EE9D1FB1C77600019892 /* search_api.hpp in Headers */,
3DA5723120C195ED007BDE27 /* everywhere_search_callback.hpp in Headers */,
3DA5723020C195ED007BDE27 /* viewport_search_callback.hpp in Headers */,
@ -1062,7 +1062,6 @@
3DA5723320C195ED007BDE27 /* viewport_search_callback.cpp in Sources */,
675346641A4054E800A0A8C3 /* framework.cpp in Sources */,
BB4E5F281FCC664A00A77250 /* transit_reader.cpp in Sources */,
3D62CBCF20F4DFE800E7BB6E /* discovery_search_callback.cpp in Sources */,
454649F11F2728CE00EF4064 /* local_ads_mark.cpp in Sources */,
F63421F81DF9BF9100A96868 /* reachable_by_taxi_checker.cpp in Sources */,
56C116602090E5670068BBC0 /* extrapolator.cpp in Sources */,
@ -1074,6 +1073,7 @@
45201E931CE4AC90008A4842 /* api_mark_point.cpp in Sources */,
F6FC3CB61FC323430001D929 /* discovery_manager.cpp in Sources */,
675346661A4054E800A0A8C3 /* ge0_parser.cpp in Sources */,
3D62CBD920FF6C8B00E7BB6E /* discovery_search.cpp in Sources */,
BBA014AD2073C784007402E4 /* bookmark_helpers.cpp in Sources */,
F6D2CE7E1EDEB7F500636DFD /* routing_manager.cpp in Sources */,
3D74ABBE1EA76F1D0063A898 /* local_ads_supported_types.cpp in Sources */,