[indexer] Move FeaturesLoaderGuard out of DataSource

editor/editable_data_source.hpp

@@ -11,12 +11,3 @@ class EditableDataSource : public DataSource
 public:
   EditableDataSource() : DataSource(std::make_unique<EditableFeatureSourceFactory>()) {}
 };
-
-class EditableFeaturesLoaderGuard : public DataSource::FeaturesLoaderGuard
-{
-public:
-  EditableFeaturesLoaderGuard(DataSource const & dataSource, DataSource::MwmId const & id)
-    : DataSource::FeaturesLoaderGuard(dataSource, id, EditableFeatureSourceFactory())
-  {
-  }
-};

feature_list/feature_list.cpp

@@ -353,7 +353,7 @@ int main(int argc, char ** argv)
     map<uint32_t, osm::Id> featureIdToOsmId;
     ParseFeatureIdToOsmIdMapping(osmToFeatureFile, featureIdToOsmId);
     MwmSet::MwmId mwmId(mwmInfo);
-    FrozenFeaturesLoaderGuard loader(dataSource, mwmId);
+    FeaturesLoaderGuard loader(dataSource, mwmId);
     for (uint32_t ftIndex = 0; ftIndex < loader.GetNumFeatures(); ftIndex++)
     {
       FeatureType ft;

indexer/data_source.cpp

@@ -103,25 +103,24 @@ class ReadMWMFunctor
 };
 }  //  namespace
 
-// DataSource::FeaturesLoaderGuard ---------------------------------------------------------
-string DataSource::FeaturesLoaderGuard::GetCountryFileName() const
+// FeaturesLoaderGuard ---------------------------------------------------------------------
+string FeaturesLoaderGuard::GetCountryFileName() const
 {
   if (!m_handle.IsAlive())
     return string();
 
   return m_handle.GetValue<MwmValue>()->GetCountryFileName();
 }
 
-bool DataSource::FeaturesLoaderGuard::IsWorld() const
+bool FeaturesLoaderGuard::IsWorld() const
 {
   if (!m_handle.IsAlive())
     return false;
 
   return m_handle.GetValue<MwmValue>()->GetHeader().GetType() == feature::DataHeader::world;
 }
 
-unique_ptr<FeatureType> DataSource::FeaturesLoaderGuard::GetOriginalFeatureByIndex(
-    uint32_t index) const
+unique_ptr<FeatureType> FeaturesLoaderGuard::GetOriginalFeatureByIndex(uint32_t index) const
 {
   auto feature = make_unique<FeatureType>();
   if (GetOriginalFeatureByIndex(index, *feature))
@@ -130,8 +129,7 @@ unique_ptr<FeatureType> DataSource::FeaturesLoaderGuard::GetOriginalFeatureByInd
   return {};
 }
 
-unique_ptr<FeatureType> DataSource::FeaturesLoaderGuard::GetOriginalOrEditedFeatureByIndex(
-    uint32_t index) const
+unique_ptr<FeatureType> FeaturesLoaderGuard::GetOriginalOrEditedFeatureByIndex(uint32_t index) const
 {
   auto feature = make_unique<FeatureType>();
   if (!m_handle.IsAlive())
@@ -144,8 +142,8 @@ unique_ptr<FeatureType> DataSource::FeaturesLoaderGuard::GetOriginalOrEditedFeat
   return {};
 }
 
-WARN_UNUSED_RESULT bool DataSource::FeaturesLoaderGuard::GetFeatureByIndex(uint32_t index,
-                                                                           FeatureType & ft) const
+WARN_UNUSED_RESULT bool FeaturesLoaderGuard::GetFeatureByIndex(uint32_t index,
+                                                               FeatureType & ft) const
 {
   if (!m_handle.IsAlive())
     return false;
@@ -157,8 +155,8 @@ WARN_UNUSED_RESULT bool DataSource::FeaturesLoaderGuard::GetFeatureByIndex(uint3
   return GetOriginalFeatureByIndex(index, ft);
 }
 
-WARN_UNUSED_RESULT bool DataSource::FeaturesLoaderGuard::GetOriginalFeatureByIndex(
-    uint32_t index, FeatureType & ft) const
+WARN_UNUSED_RESULT bool FeaturesLoaderGuard::GetOriginalFeatureByIndex(uint32_t index,
+                                                                       FeatureType & ft) const
 {
   return m_handle.IsAlive() ? m_source->GetOriginalFeature(index, ft) : false;
 }

indexer/data_source.hpp

@@ -29,33 +29,6 @@ class DataSource : public MwmSet
   using FeatureCallback = std::function<void(FeatureType &)>;
   using FeatureIdCallback = std::function<void(FeatureID const &)>;
 
-  /// Guard for loading features from particular MWM by demand.
-  /// @note This guard is suitable when mwm is loaded.
-  class FeaturesLoaderGuard
-  {
-  public:
-    FeaturesLoaderGuard(DataSource const & dataSource, MwmId const & id,
-                        FeatureSourceFactory const & factory)
-      : m_handle(dataSource.GetMwmHandleById(id)), m_source(factory(m_handle))
-    {
-    }
-
-    MwmSet::MwmId const & GetId() const { return m_handle.GetId(); }
-    std::string GetCountryFileName() const;
-    bool IsWorld() const;
-    std::unique_ptr<FeatureType> GetOriginalFeatureByIndex(uint32_t index) const;
-    std::unique_ptr<FeatureType> GetOriginalOrEditedFeatureByIndex(uint32_t index) const;
-    /// Everyone, except Editor core, should use this method.
-    WARN_UNUSED_RESULT bool GetFeatureByIndex(uint32_t index, FeatureType & ft) const;
-    /// Editor core only method, to get 'untouched', original version of feature.
-    WARN_UNUSED_RESULT bool GetOriginalFeatureByIndex(uint32_t index, FeatureType & ft) const;
-    size_t GetNumFeatures() const { return m_source->GetNumFeatures(); }
-
-  private:
-    MwmHandle m_handle;
-    std::unique_ptr<FeatureSource> m_source;
-  };
-
   ~DataSource() override = default;
 
   /// Registers a new map.
@@ -95,6 +68,8 @@ class DataSource : public MwmSet
   std::unique_ptr<MwmValueBase> CreateValue(MwmInfo & info) const override;
 
 private:
+  friend class FeaturesLoaderGuard;
+
   std::unique_ptr<FeatureSourceFactory> m_factory;
 };
 
@@ -106,11 +81,28 @@ class FrozenDataSource : public DataSource
   FrozenDataSource() : DataSource(std::make_unique<FeatureSourceFactory>()) {}
 };
 
-class FrozenFeaturesLoaderGuard : public DataSource::FeaturesLoaderGuard
+/// Guard for loading features from particular MWM by demand.
+/// @note This guard is suitable when mwm is loaded.
+class FeaturesLoaderGuard
 {
 public:
-  FrozenFeaturesLoaderGuard(DataSource const & dataSource, DataSource::MwmId const & id)
-    : DataSource::FeaturesLoaderGuard(dataSource, id, FeatureSourceFactory())
+  FeaturesLoaderGuard(DataSource const & dataSource, DataSource::MwmId const & id)
+    : m_handle(dataSource.GetMwmHandleById(id)), m_source((*dataSource.m_factory)(m_handle))
   {
   }
+
+  MwmSet::MwmId const & GetId() const { return m_handle.GetId(); }
+  std::string GetCountryFileName() const;
+  bool IsWorld() const;
+  std::unique_ptr<FeatureType> GetOriginalFeatureByIndex(uint32_t index) const;
+  std::unique_ptr<FeatureType> GetOriginalOrEditedFeatureByIndex(uint32_t index) const;
+  /// Everyone, except Editor core, should use this method.
+  WARN_UNUSED_RESULT bool GetFeatureByIndex(uint32_t index, FeatureType & ft) const;
+  /// Editor core only method, to get 'untouched', original version of feature.
+  WARN_UNUSED_RESULT bool GetOriginalFeatureByIndex(uint32_t index, FeatureType & ft) const;
+  size_t GetNumFeatures() const { return m_source->GetNumFeatures(); }
+
+private:
+  DataSource::MwmHandle m_handle;
+  std::unique_ptr<FeatureSource> m_source;
 };

indexer/indexer_tests/scale_index_reading_tests.cpp

@@ -54,7 +54,7 @@ class ScaleIndexReadingTest : public TestWithCustomMwms
                                       [&](uint32_t index) { indices.push_back(index); });
     }
 
-    FrozenFeaturesLoaderGuard loader(m_dataSource, id);
+    FeaturesLoaderGuard loader(m_dataSource, id);
 
     Names names;
     for (auto const & index : indices)

map/booking_availability_filter.cpp

@@ -15,8 +15,6 @@
 #include <utility>
 #include <vector>
 
-using LoaderGuard = EditableFeaturesLoaderGuard;
-
 using namespace booking::filter;
 
 namespace
@@ -107,12 +105,12 @@ void PrepareData(DataSource const & dataSource, search::Results const & results,
   std::sort(features.begin(), features.end());
 
   MwmSet::MwmId mwmId;
-  std::unique_ptr<LoaderGuard> guard;
+  std::unique_ptr<FeaturesLoaderGuard> guard;
   for (auto const & featureId : features)
   {
     if (mwmId != featureId.m_mwmId)
     {
-      guard = my::make_unique<LoaderGuard>(dataSource, featureId.m_mwmId);
+      guard = my::make_unique<FeaturesLoaderGuard>(dataSource, featureId.m_mwmId);
       mwmId = featureId.m_mwmId;
     }
 
@@ -224,12 +222,12 @@ void AvailabilityFilter::GetFeaturesFromCache(search::Results const & results,
   std::sort(features.begin(), features.end());
 
   MwmSet::MwmId mwmId;
-  std::unique_ptr<LoaderGuard> guard;
+  std::unique_ptr<FeaturesLoaderGuard> guard;
   for (auto const & featureId : features)
   {
     if (mwmId != featureId.m_mwmId)
     {
-      guard = my::make_unique<LoaderGuard>(GetDelegate().GetDataSource(), featureId.m_mwmId);
+      guard = my::make_unique<FeaturesLoaderGuard>(GetDelegate().GetDataSource(), featureId.m_mwmId);
       mwmId = featureId.m_mwmId;
     }
 

map/discovery/discovery_manager.cpp

@@ -71,7 +71,7 @@ std::string Manager::GetCityViatorId(m2::PointD const & point) const
   if (!fid.IsValid())
     return {};
 
-  EditableFeaturesLoaderGuard const guard(m_dataSource, fid.m_mwmId);
+  FeaturesLoaderGuard const guard(m_dataSource, fid.m_mwmId);
   FeatureType ft;
   if (!guard.GetFeatureByIndex(fid.m_index, ft))
   {

map/framework.cpp

@@ -749,7 +749,7 @@ void Framework::FillFeatureInfo(FeatureID const & fid, place_page::Info & info)
     return;
   }
 
-  EditableFeaturesLoaderGuard const guard(m_model.GetDataSource(), fid.m_mwmId);
+  FeaturesLoaderGuard const guard(m_model.GetDataSource(), fid.m_mwmId);
   FeatureType ft;
   if (!guard.GetFeatureByIndex(fid.m_index, ft))
   {
@@ -2085,7 +2085,7 @@ bool Framework::GetFeatureByID(FeatureID const & fid, FeatureType & ft) const
 {
   ASSERT(fid.IsValid(), ());
 
-  EditableFeaturesLoaderGuard guard(m_model.GetDataSource(), fid.m_mwmId);
+  FeaturesLoaderGuard guard(m_model.GetDataSource(), fid.m_mwmId);
   if (!guard.GetFeatureByIndex(fid.m_index, ft))
     return false;
 
@@ -2604,7 +2604,7 @@ vector<m2::TriangleD> Framework::GetSelectedFeatureTriangles() const
   if (!m_selectedFeature.IsValid())
     return triangles;
 
-  EditableFeaturesLoaderGuard const guard(m_model.GetDataSource(), m_selectedFeature.m_mwmId);
+  FeaturesLoaderGuard const guard(m_model.GetDataSource(), m_selectedFeature.m_mwmId);
   FeatureType ft;
   if (!guard.GetFeatureByIndex(m_selectedFeature.m_index, ft))
     return triangles;
@@ -2741,7 +2741,7 @@ namespace
 WARN_UNUSED_RESULT bool LocalizeStreet(DataSource const & dataSource, FeatureID const & fid,
                                        osm::LocalizedStreet & result)
 {
-  EditableFeaturesLoaderGuard g(dataSource, fid.m_mwmId);
+  FeaturesLoaderGuard g(dataSource, fid.m_mwmId);
   FeatureType ft;
   if (!g.GetFeatureByIndex(fid.m_index, ft))
     return false;
@@ -2858,7 +2858,7 @@ void SetHostingBuildingAddress(FeatureID const & hostingBuildingFid, DataSource
 
   FeatureType hostingBuildingFeature;
 
-  EditableFeaturesLoaderGuard g(dataSource, hostingBuildingFid.m_mwmId);
+  FeaturesLoaderGuard g(dataSource, hostingBuildingFid.m_mwmId);
   if (!g.GetFeatureByIndex(hostingBuildingFid.m_index, hostingBuildingFeature))
     return;
 
@@ -2952,7 +2952,7 @@ osm::Editor::SaveResult Framework::SaveEditedMapObject(osm::EditableMapObject em
   {
     auto const isCreatedFeature = editor.IsCreatedFeature(emo.GetID());
 
-    EditableFeaturesLoaderGuard g(m_model.GetDataSource(), emo.GetID().m_mwmId);
+    FeaturesLoaderGuard g(m_model.GetDataSource(), emo.GetID().m_mwmId);
     FeatureType originalFeature;
     if (!isCreatedFeature)
     {

openlr/openlr_decoder.cpp

@@ -81,7 +81,7 @@ struct alignas(kCacheLineSize) Stats
 
 bool IsRealVertex(m2::PointD const & p, FeatureID const & fid, DataSource const & dataSource)
 {
-  FrozenFeaturesLoaderGuard g(dataSource, fid.m_mwmId);
+  FeaturesLoaderGuard g(dataSource, fid.m_mwmId);
   auto const ft = g.GetOriginalFeatureByIndex(fid.m_index);
   bool matched = false;
   ft->ForEachPoint(

openlr/openlr_tests/decoded_path_test.cpp

@@ -140,7 +140,7 @@ void WithRoad(vector<m2::PointD> const & points, Func && fn)
   MwmSet::MwmHandle mwmHandle = dataSource.GetMwmHandleById(regResult.first);
   TEST(mwmHandle.IsAlive(), ());
 
-  FrozenFeaturesLoaderGuard const guard(dataSource, regResult.first);
+  FeaturesLoaderGuard const guard(dataSource, regResult.first);
   FeatureType road;
   TEST(guard.GetFeatureByIndex(0, road), ());
   road.ParseEverything();

openlr/road_info_getter.cpp

@@ -21,7 +21,7 @@ RoadInfoGetter::RoadInfo RoadInfoGetter::Get(FeatureID const & fid)
   if (it != end(m_cache))
     return it->second;
 
-  FrozenFeaturesLoaderGuard g(m_dataSource, fid.m_mwmId);
+  FeaturesLoaderGuard g(m_dataSource, fid.m_mwmId);
   FeatureType ft;
   CHECK(g.GetOriginalFeatureByIndex(fid.m_index, ft), ());
 

routing/bicycle_directions.cpp

@@ -211,10 +211,10 @@ bool BicycleDirectionsEngine::Generate(IndexRoadGraph const & graph, vector<Junc
   return true;
 }
 
-DataSource::FeaturesLoaderGuard & BicycleDirectionsEngine::GetLoader(MwmSet::MwmId const & id)
+FeaturesLoaderGuard & BicycleDirectionsEngine::GetLoader(MwmSet::MwmId const & id)
 {
   if (!m_loader || id != m_loader->GetId())
-    m_loader = make_unique<EditableFeaturesLoaderGuard>(m_dataSource, id);
+    m_loader = make_unique<FeaturesLoaderGuard>(m_dataSource, id);
   return *m_loader;
 }
 

routing/bicycle_directions.hpp

@@ -39,7 +39,7 @@ class BicycleDirectionsEngine : public IDirectionsEngine
                 vector<Segment> & segments) override;
 
 private:
-  DataSource::FeaturesLoaderGuard & GetLoader(MwmSet::MwmId const & id);
+  FeaturesLoaderGuard & GetLoader(MwmSet::MwmId const & id);
   void LoadPathAttributes(FeatureID const & featureId, LoadedPathSegment & pathSegment);
   void GetSegmentRangeAndAdjacentEdges(IRoadGraph::TEdgeVector const & outgoingEdges,
                                        Edge const & inEdge, uint32_t startSegId, uint32_t endSegId,
@@ -60,6 +60,6 @@ class BicycleDirectionsEngine : public IDirectionsEngine
   TUnpackedPathSegments m_pathSegments;
   DataSource const & m_dataSource;
   std::shared_ptr<NumMwmIds> m_numMwmIds;
-  std::unique_ptr<DataSource::FeaturesLoaderGuard> m_loader;
+  std::unique_ptr<FeaturesLoaderGuard> m_loader;
 };
 }  // namespace routing

routing/features_road_graph.cpp

@@ -205,7 +205,7 @@ void FeaturesRoadGraph::FindClosestEdges(m2::PointD const & point, uint32_t coun
 void FeaturesRoadGraph::GetFeatureTypes(FeatureID const & featureId, feature::TypesHolder & types) const
 {
   FeatureType ft;
-  EditableFeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
+  FeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
   if (!loader.GetFeatureByIndex(featureId.m_index, ft))
     return;
 
@@ -306,7 +306,7 @@ IRoadGraph::RoadInfo const & FeaturesRoadGraph::GetCachedRoadInfo(FeatureID cons
 
   FeatureType ft;
 
-  EditableFeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
+  FeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
 
   if (!loader.GetFeatureByIndex(featureId.m_index, ft))
     return ri;

routing/geometry.cpp

@@ -33,7 +33,7 @@ class GeometryLoaderImpl final : public GeometryLoader
 
 private:
   shared_ptr<VehicleModelInterface> m_vehicleModel;
-  EditableFeaturesLoaderGuard m_guard;
+  FeaturesLoaderGuard m_guard;
   string const m_country;
   feature::AltitudeLoader m_altitudeLoader;
   bool const m_loadAltitudes;

routing/index_road_graph.cpp

@@ -60,7 +60,7 @@ void IndexRoadGraph::GetEdgeTypes(Edge const & edge, feature::TypesHolder & type
 
   FeatureID const featureId = edge.GetFeatureId();
   FeatureType ft;
-  EditableFeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
+  FeaturesLoaderGuard loader(m_dataSource, featureId.m_mwmId);
   if (!loader.GetFeatureByIndex(featureId.m_index, ft))
   {
     LOG(LERROR, ("Can't load types for feature", featureId));

search/downloader_search_callback.cpp

@@ -63,7 +63,7 @@ void DownloaderSearchCallback::operator()(search::Results const & results)
     if (result.GetResultType() != search::Result::Type::LatLon)
     {
       FeatureID const & fid = result.GetFeatureID();
-      EditableFeaturesLoaderGuard loader(m_dataSource, fid.m_mwmId);
+      FeaturesLoaderGuard loader(m_dataSource, fid.m_mwmId);
       FeatureType ft;
       if (!loader.GetFeatureByIndex(fid.m_index, ft))
       {

search/editor_delegate.cpp

@@ -18,7 +18,7 @@ MwmSet::MwmId EditorDelegate::GetMwmIdByMapName(string const & name) const
 
 unique_ptr<FeatureType> EditorDelegate::GetOriginalFeature(FeatureID const & fid) const
 {
-  EditableFeaturesLoaderGuard guard(m_dataSource, fid.m_mwmId);
+  FeaturesLoaderGuard guard(m_dataSource, fid.m_mwmId);
   auto feature = guard.GetOriginalFeatureByIndex(fid.m_index);
   if (feature)
     feature->ParseEverything();

search/feature_loader.cpp

@@ -16,7 +16,7 @@ bool FeatureLoader::Load(FeatureID const & id, FeatureType & ft)
 
   auto const & mwmId = id.m_mwmId;
   if (!m_guard || m_guard->GetId() != mwmId)
-    m_guard = my::make_unique<EditableFeaturesLoaderGuard>(m_dataSource, mwmId);
+    m_guard = my::make_unique<FeaturesLoaderGuard>(m_dataSource, mwmId);
   return m_guard->GetFeatureByIndex(id.m_index, ft);
 }
 

search/feature_loader.hpp

@@ -32,7 +32,7 @@ class FeatureLoader
 
 private:
   DataSource const & m_dataSource;
-  std::unique_ptr<DataSource::FeaturesLoaderGuard> m_guard;
+  std::unique_ptr<FeaturesLoaderGuard> m_guard;
 
   ThreadChecker m_checker;
 };