[indexer] enum feature::EGeomType is changed to enum class feature::GeomType

15 files changed, 71 insertions, 70 deletions

diff --git a/generator/booking_dataset.cpp b/generator/booking_dataset.cpp
index 2e89f2739b..2e7fe1aa10 100644
--- a/generator/booking_dataset.cpp
+++ b/generator/booking_dataset.cpp
@@ -59,7 +59,7 @@ void BookingDataset::PreprocessMatchedOsmObject(ObjectId, FeatureBuilder1 & fb,
                                                 std::function<void(FeatureBuilder1 &)> const fn) const
 {
   // Turn a hotel into a simple building.
-  if (fb.GetGeomType() == feature::GEOM_AREA)
+  if (fb.GetGeomType() == feature::GeomType::Area)
   {
     // Remove all information about the hotel.
     auto & meta = fb.GetMetadata();
diff --git a/generator/booking_quality_check/booking_quality_check.cpp b/generator/booking_quality_check/booking_quality_check.cpp
index 3b0648c11d..aedb3cd049 100644
--- a/generator/booking_quality_check/booking_quality_check.cpp
+++ b/generator/booking_quality_check/booking_quality_check.cpp
@@ -72,10 +72,10 @@ string PrintBuilder(FeatureBuilder1 const & fb)
   auto const center = MercatorBounds::ToLatLon(fb.GetKeyPoint());
   s << "lat: " << center.lat << " lon: " << center.lon << '\t';
 
-  if (fb.GetGeomType() == feature::GEOM_POINT)
-    s << "GeomType: GEOM_POINT";
-  else if (fb.GetGeomType() == feature::GEOM_AREA)
-    s << "GeomType: GEOM_AREA";
+  if (fb.GetGeomType() == feature::GeomType::Point)
+    s << "GeomType: Point";
+  else if (fb.GetGeomType() == feature::GeomType::Area)
+    s << "GeomType: Area";
   else
     CHECK(false, ());
 
diff --git a/generator/camera_info_collector.cpp b/generator/camera_info_collector.cpp
index 16cb427de2..5c888a55ac 100644
--- a/generator/camera_info_collector.cpp
+++ b/generator/camera_info_collector.cpp
@@ -206,7 +206,7 @@ void CamerasInfoCollector::Camera::FindClosestSegmentWithGeometryIndex(FrozenDat
 
   // Look at each segment of roads and find the closest.
   auto const updateClosestFeatureCallback = [&](FeatureType & ft) {
-    if (ft.GetFeatureType() != feature::GEOM_LINE)
+    if (ft.GetGeomType() != feature::GeomType::Line)
       return;
 
     if (!routing::IsCarRoad(feature::TypesHolder(ft)))
diff --git a/generator/check_model.cpp b/generator/check_model.cpp
index 1a4a46ed12..53fc57afd1 100644
--- a/generator/check_model.cpp
+++ b/generator/check_model.cpp
@@ -33,11 +33,11 @@ namespace check_model
       m2::RectD const r = ft.GetLimitRect(FeatureType::BEST_GEOMETRY);
       CHECK(r.IsValid(), ());
 
-      EGeomType const type = ft.GetFeatureType();
-      if (type == GEOM_LINE)
+      GeomType const type = ft.GetGeomType();
+      if (type == GeomType::Line)
         CHECK_GREATER(ft.GetPointsCount(), 1, ());
 
-      IsDrawableLike(vTypes, ft.GetFeatureType());
+      IsDrawableLike(vTypes, ft.GetGeomType());
     });
 
     LOG(LINFO, ("OK"));
diff --git a/generator/emitter_restaurants.cpp b/generator/emitter_restaurants.cpp
index fbf2140bd8..ffbca9cc4e 100644
--- a/generator/emitter_restaurants.cpp
+++ b/generator/emitter_restaurants.cpp
@@ -20,8 +20,8 @@ void EmitterRestaurants::Process(FeatureBuilder1 & fb)
 
   switch (fb.GetGeomType())
   {
-  case feature::GEOM_POINT: ++m_stats.m_restaurantsPoi; break;
-  case feature::GEOM_AREA: ++m_stats.m_restaurantsBuilding; break;
+  case feature::GeomType::Point: ++m_stats.m_restaurantsPoi; break;
+  case feature::GeomType::Area: ++m_stats.m_restaurantsBuilding; break;
   default: ++m_stats.m_unexpectedFeatures;
   }
   m_features.emplace_back(fb);
diff --git a/generator/extract_addr/extract_addr.cpp b/generator/extract_addr/extract_addr.cpp
index d802f8ca1e..a81d349fc8 100644
--- a/generator/extract_addr/extract_addr.cpp
+++ b/generator/extract_addr/extract_addr.cpp
@@ -47,7 +47,7 @@ void PrintFeature(FeatureBuilder1 const & fb, uint64_t)
   bool const isPOI = !name.empty() && !category.empty() &&
                      category.find("building") == std::string::npos;
 
-  if ((house.empty() && !isPOI) || fb.GetGeomType() == feature::GEOM_LINE)
+  if ((house.empty() && !isPOI) || fb.GetGeomType() == feature::GeomType::Line)
     return;
 
   auto const center = MercatorBounds::ToLatLon(fb.GetKeyPoint());
diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index e6dbc18d38..534902fea5 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -60,9 +60,10 @@ m2::PointD FeatureBuilder1::GetKeyPoint() const
 {
   switch (GetGeomType())
   {
-  case GEOM_POINT:
+  case GeomType::Point:
     return m_center;
-  case GEOM_LINE: case GEOM_AREA:
+  case GeomType::Line:
+  case GeomType::Area:
     return GetGeometryCenter();
   default:
     CHECK(false, ());
@@ -73,7 +74,7 @@ m2::PointD FeatureBuilder1::GetKeyPoint() const
 void FeatureBuilder1::SetCenter(m2::PointD const & p)
 {
   m_center = p;
-  m_params.SetGeomType(GEOM_POINT);
+  m_params.SetGeomType(GeomType::Point);
   m_limitRect.Add(p);
 }
 
@@ -102,7 +103,7 @@ void FeatureBuilder1::AddPoint(m2::PointD const & p)
 
 void FeatureBuilder1::SetLinear(bool reverseGeometry)
 {
-  m_params.SetGeomType(feature::GEOM_LINE);
+  m_params.SetGeomType(feature::GeomType::Line);
   m_polygons.resize(1);
 
   if (reverseGeometry)
@@ -115,7 +116,7 @@ void FeatureBuilder1::SetLinear(bool reverseGeometry)
 
 void FeatureBuilder1::SetAreaAddHoles(FeatureBuilder1::Geometry const & holes)
 {
-  m_params.SetGeomType(GEOM_AREA);
+  m_params.SetGeomType(GeomType::Area);
   m_polygons.resize(1);
 
   if (holes.empty()) return;
@@ -226,7 +227,7 @@ bool FeatureBuilder1::PreSerialize()
 
   switch (m_params.GetGeomType())
   {
-  case GEOM_POINT:
+  case GeomType::Point:
     // Store house number like HEADER_GEOM_POINT_EX.
     if (!m_params.house.IsEmpty())
     {
@@ -241,7 +242,7 @@ bool FeatureBuilder1::PreSerialize()
     m_params.ref.clear();
     break;
 
-  case GEOM_LINE:
+  case GeomType::Line:
   {
     // We need refs for road's numbers.
     if (!IsRoad())
@@ -252,7 +253,7 @@ bool FeatureBuilder1::PreSerialize()
     break;
   }
 
-  case GEOM_AREA:
+  case GeomType::Area:
     m_params.rank = 0;
     m_params.ref.clear();
     break;
@@ -325,7 +326,7 @@ bool FeatureBuilder1::operator==(FeatureBuilder1 const & fb) const
   if (m_coastCell != fb.m_coastCell)
     return false;
 
-  if (m_params.GetGeomType() == GEOM_POINT && !IsEqual(m_center, fb.m_center))
+  if (m_params.GetGeomType() == GeomType::Point && !IsEqual(m_center, fb.m_center))
     return false;
 
   if (!IsEqual(m_limitRect, fb.m_limitRect))
@@ -350,12 +351,12 @@ bool FeatureBuilder1::CheckValid() const
 {
   CHECK(m_params.CheckValid(), (*this));
 
-  EGeomType const type = m_params.GetGeomType();
+  GeomType const type = m_params.GetGeomType();
 
-  if (type == GEOM_LINE)
+  if (type == GeomType::Line)
     CHECK(GetOuterGeometry().size() >= 2, (*this));
 
-  if (type == GEOM_AREA)
+  if (type == GeomType::Area)
     for (PointSeq const & points : m_polygons)
       CHECK(points.size() >= 3, (*this));
 
@@ -369,7 +370,7 @@ void FeatureBuilder1::SerializeBase(Buffer & data, serial::GeometryCodingParams
 
   m_params.Write(sink, saveAddInfo);
 
-  if (m_params.GetGeomType() == GEOM_POINT)
+  if (m_params.GetGeomType() == GeomType::Point)
     serial::SavePoint(sink, m_center, params);
 }
 
@@ -385,7 +386,7 @@ void FeatureBuilder1::Serialize(Buffer & data) const
 
   PushBackByteSink<Buffer> sink(data);
 
-  if (m_params.GetGeomType() != GEOM_POINT)
+  if (m_params.GetGeomType() != GeomType::Point)
   {
     WriteVarUint(sink, static_cast<uint32_t>(m_polygons.size()));
 
@@ -442,8 +443,8 @@ void FeatureBuilder1::Deserialize(Buffer & data)
 
   m_limitRect.MakeEmpty();
 
-  EGeomType const type = m_params.GetGeomType();
-  if (type == GEOM_POINT)
+  GeomType const type = m_params.GetGeomType();
+  if (type == GeomType::Point)
   {
     m_center = serial::LoadPoint(source, cp);
     m_limitRect.Add(m_center);
@@ -550,9 +551,9 @@ string DebugPrint(FeatureBuilder1 const & f)
 
   switch (f.GetGeomType())
   {
-  case GEOM_POINT: out << DebugPrint(f.m_center); break;
-  case GEOM_LINE: out << "line with " << f.GetPointsCount() << " points"; break;
-  case GEOM_AREA: out << "area with " << f.GetPointsCount() << " points"; break;
+  case GeomType::Point: out << DebugPrint(f.m_center); break;
+  case GeomType::Line: out << "line with " << f.GetPointsCount() << " points"; break;
+  case GeomType::Area: out << "area with " << f.GetPointsCount() << " points"; break;
   default: out << "ERROR: unknown geometry type"; break;
   }
 
@@ -591,13 +592,13 @@ string DebugPrint(FeatureBuilder2 const & f)
 bool FeatureBuilder2::PreSerializeAndRemoveUselessNames(SupportingData const & data)
 {
   // make flags actual before header serialization
-  EGeomType const geoType = m_params.GetGeomType();
-  if (geoType == GEOM_LINE)
+  GeomType const geomType = m_params.GetGeomType();
+  if (geomType == GeomType::Line)
   {
     if (data.m_ptsMask == 0 && data.m_innerPts.empty())
       return false;
   }
-  else if (geoType == GEOM_AREA)
+  else if (geomType == GeomType::Area)
   {
     if (data.m_trgMask == 0 && data.m_innerTrg.empty())
       return false;
@@ -618,13 +619,13 @@ void FeatureBuilder2::SerializeLocalityObject(serial::GeometryCodingParams const
   auto const type = m_params.GetGeomType();
   WriteToSink(sink, static_cast<uint8_t>(type));
 
-  if (type == GEOM_POINT)
+  if (type == GeomType::Point)
   {
     serial::SavePoint(sink, m_center, params);
     return;
   }
 
-  CHECK_EQUAL(type, GEOM_AREA, ("Supported types are GEOM_POINT and GEOM_AREA"));
+  CHECK_EQUAL(type, GeomType::Area, ("Supported types are Point and Area"));
 
   uint32_t trgCount = base::asserted_cast<uint32_t>(data.m_innerTrg.size());
   CHECK_GREATER(trgCount, 2, ());
@@ -652,18 +653,18 @@ void FeatureBuilder2::Serialize(SupportingData & data,
     trgCount -= 2;
   }
 
-  EGeomType const type = m_params.GetGeomType();
+  GeomType const type = m_params.GetGeomType();
 
   {
     BitWriter<PushBackByteSink<Buffer>> bitSink(sink);
 
-    if (type == GEOM_LINE)
+    if (type == GeomType::Line)
     {
       bitSink.Write(ptsCount, 4);
       if (ptsCount == 0)
         bitSink.Write(data.m_ptsMask, 4);
     }
-    else if (type == GEOM_AREA)
+    else if (type == GeomType::Area)
     {
       bitSink.Write(trgCount, 4);
       if (trgCount == 0)
@@ -671,7 +672,7 @@ void FeatureBuilder2::Serialize(SupportingData & data,
     }
   }
 
-  if (type == GEOM_LINE)
+  if (type == GeomType::Line)
   {
     if (ptsCount > 0)
     {
@@ -700,7 +701,7 @@ void FeatureBuilder2::Serialize(SupportingData & data,
       WriteVarUintArray(data.m_ptsOffset, sink);
     }
   }
-  else if (type == GEOM_AREA)
+  else if (type == GeomType::Area)
   {
     if (trgCount > 0)
       serial::SaveInnerTriangles(data.m_innerTrg, params, sink);
diff --git a/generator/feature_builder.hpp b/generator/feature_builder.hpp
index e1b48e26f4..4299c3f432 100644
--- a/generator/feature_builder.hpp
+++ b/generator/feature_builder.hpp
@@ -53,11 +53,11 @@ public:
 
   /// Set that feature is area and get ownership of holes.
   void SetAreaAddHoles(Geometry const & holes);
-  void SetArea() { m_params.SetGeomType(feature::GEOM_AREA); }
+  void SetArea() { m_params.SetGeomType(feature::GeomType::Area); }
 
-  bool IsPoint() const { return (GetGeomType() == feature::GEOM_POINT); }
-  bool IsLine() const { return (GetGeomType() == feature::GEOM_LINE); }
-  bool IsArea() const { return (GetGeomType() == feature::GEOM_AREA); }
+  bool IsPoint() const { return (GetGeomType() == feature::GeomType::Point); }
+  bool IsLine() const { return (GetGeomType() == feature::GeomType::Line); }
+  bool IsArea() const { return (GetGeomType() == feature::GeomType::Area); }
 
   void AddPolygon(std::vector<m2::PointD> & poly);
 
@@ -69,7 +69,7 @@ public:
   feature::Metadata & GetMetadata() { return m_params.GetMetadata(); }
   Geometry const & GetGeometry() const { return m_polygons; }
   PointSeq const & GetOuterGeometry() const { return m_polygons.front(); }
-  feature::EGeomType GetGeomType() const { return m_params.GetGeomType(); }
+  feature::GeomType GetGeomType() const { return m_params.GetGeomType(); }
 
   void AddType(uint32_t type) { m_params.AddType(type); }
   bool HasType(uint32_t t) const { return m_params.IsTypeExist(t); }
@@ -138,7 +138,7 @@ public:
   template <class ToDo>
   void ForEachGeometryPointEx(ToDo & toDo) const
   {
-    if (m_params.GetGeomType() == feature::GEOM_POINT)
+    if (m_params.GetGeomType() == feature::GeomType::Point)
       toDo(m_center);
     else
     {
diff --git a/generator/feature_processing_layers.cpp b/generator/feature_processing_layers.cpp
index 74109bf146..ac215171fc 100644
--- a/generator/feature_processing_layers.cpp
+++ b/generator/feature_processing_layers.cpp
@@ -99,7 +99,7 @@ void RepresentationLayer::Handle(FeatureBuilder1 & feature)
   {
     switch (geomType)
     {
-    case feature::EGeomType::GEOM_AREA:
+    case feature::GeomType::Area:
     {
       HandleArea(feature, params);
       if (CanBeLine(params))
@@ -109,7 +109,7 @@ void RepresentationLayer::Handle(FeatureBuilder1 & feature)
       }
       break;
     }
-    case feature::EGeomType::GEOM_LINE:
+    case feature::GeomType::Line:
       LayerBase::Handle(feature);
       break;
     default:
@@ -122,7 +122,7 @@ void RepresentationLayer::Handle(FeatureBuilder1 & feature)
   {
     switch (geomType)
     {
-    case feature::EGeomType::GEOM_AREA:
+    case feature::GeomType::Area:
       HandleArea(feature, params);
       break;
     default:
@@ -157,19 +157,19 @@ void RepresentationLayer::HandleArea(FeatureBuilder1 & feature, FeatureParams co
 // static
 bool RepresentationLayer::CanBeArea(FeatureParams const & params)
 {
-  return feature::IsDrawableLike(params.m_types, feature::GEOM_AREA);
+  return feature::IsDrawableLike(params.m_types, feature::GeomType::Area);
 }
 
 // static
 bool RepresentationLayer::CanBePoint(FeatureParams const & params)
 {
-  return feature::HasUsefulType(params.m_types, feature::GEOM_POINT);
+  return feature::HasUsefulType(params.m_types, feature::GeomType::Point);
 }
 
 // static
 bool RepresentationLayer::CanBeLine(FeatureParams const & params)
 {
-  return feature::HasUsefulType(params.m_types, feature::GEOM_LINE);
+  return feature::HasUsefulType(params.m_types, feature::GeomType::Line);
 }
 
 void PrepareFeatureLayer::Handle(FeatureBuilder1 & feature)
@@ -262,10 +262,10 @@ void RepresentationCoastlineLayer::Handle(FeatureBuilder1 & feature)
   {
     switch (geomType)
     {
-    case feature::EGeomType::GEOM_AREA:
+    case feature::GeomType::Area:
       LayerBase::Handle(feature);
       break;
-    case feature::EGeomType::GEOM_LINE:
+    case feature::GeomType::Line:
       LayerBase::Handle(feature);
       break;
     default:
diff --git a/generator/generator_tests/feature_builder_test.cpp b/generator/generator_tests/feature_builder_test.cpp
index 9d0f5efab8..c68b0d46a5 100644
--- a/generator/generator_tests/feature_builder_test.cpp
+++ b/generator/generator_tests/feature_builder_test.cpp
@@ -147,7 +147,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FVisibility_RemoveUselessTypes)
     types.push_back(c.GetTypeByPath({ "building" }));
     types.push_back(c.GetTypeByPath({ "amenity", "theatre" }));
 
-    TEST(feature::RemoveUselessTypes(types, feature::GEOM_AREA), ());
+    TEST(feature::RemoveUselessTypes(types, feature::GeomType::Area), ());
     TEST_EQUAL(types.size(), 2, ());
   }
 
@@ -156,7 +156,7 @@ UNIT_CLASS_TEST(TestWithClassificator, FVisibility_RemoveUselessTypes)
     types.push_back(c.GetTypeByPath({ "highway", "primary" }));
     types.push_back(c.GetTypeByPath({ "building" }));
 
-    TEST(feature::RemoveUselessTypes(types, feature::GEOM_AREA, true /* emptyName */), ());
+    TEST(feature::RemoveUselessTypes(types, feature::GeomType::Area, true /* emptyName */), ());
     TEST_EQUAL(types.size(), 1, ());
     TEST_EQUAL(types[0], c.GetTypeByPath({ "building" }), ());
   }
diff --git a/generator/generator_tests_support/test_mwm_builder.cpp b/generator/generator_tests_support/test_mwm_builder.cpp
index 8e9f6aebdc..924347026e 100644
--- a/generator/generator_tests_support/test_mwm_builder.cpp
+++ b/generator/generator_tests_support/test_mwm_builder.cpp
@@ -80,7 +80,7 @@ bool TestMwmBuilder::Add(FeatureBuilder1 & fb)
 {
   CHECK(m_collector, ("It's not possible to add features after call to Finish()."));
 
-  if (ftypes::IsCityTownOrVillage(fb.GetTypes()) && fb.GetGeomType() == feature::GEOM_AREA)
+  if (ftypes::IsCityTownOrVillage(fb.GetTypes()) && fb.GetGeomType() == feature::GeomType::Area)
   {
     auto const & metadata = fb.GetMetadata();
     uint64_t testId;
diff --git a/generator/place.hpp b/generator/place.hpp
index d26c6e85c6..444cbf9ca9 100644
--- a/generator/place.hpp
+++ b/generator/place.hpp
@@ -22,7 +22,7 @@ public:
   bool IsBetterThan(Place const & r) const;
 
 private:
-  bool IsPoint() const { return (m_ft.GetGeomType() == feature::GEOM_POINT); }
+  bool IsPoint() const { return (m_ft.GetGeomType() == feature::GeomType::Point); }
   static bool AreTypesEqual(uint32_t t1, uint32_t t2);
 
   FeatureBuilder1 m_ft;
diff --git a/generator/statistics.cpp b/generator/statistics.cpp
index db4b2d4d9b..20f812bd93 100644
--- a/generator/statistics.cpp
+++ b/generator/statistics.cpp
@@ -75,7 +75,7 @@ namespace stats
       double len = 0.0;
       double area = 0.0;
 
-      if (f.GetFeatureType() == feature::GEOM_LINE)
+      if (f.GetGeomType() == feature::GeomType::Line)
       {
         m2::PointD lastPoint;
         bool firstPoint = true;
@@ -88,7 +88,7 @@ namespace stats
           lastPoint = pt;
         }, FeatureType::BEST_GEOMETRY);
       }
-      else if (f.GetFeatureType() == feature::GEOM_AREA)
+      else if (f.GetGeomType() == feature::GeomType::Area)
       {
         f.ForEachTriangle([&area](m2::PointD const & p1, m2::PointD const & p2, m2::PointD const & p3)
         {
@@ -96,7 +96,7 @@ namespace stats
         }, FeatureType::BEST_GEOMETRY);
       }
 
-      m_info.m_byGeomType[f.GetFeatureType()].Add(allSize, len, area);
+      m_info.m_byGeomType[f.GetGeomType()].Add(allSize, len, area);
 
       f.ForEachType([this, allSize, len, area](uint32_t type)
       {
@@ -123,12 +123,12 @@ namespace stats
     std::cout << endl;
   }
 
-  std::string GetKey(EGeomType type)
+  std::string GetKey(GeomType type)
   {
     switch (type)
     {
-    case GEOM_LINE: return "Line";
-    case GEOM_AREA: return "Area";
+    case GeomType::Line: return "Line";
+    case GeomType::Area: return "Area";
     default: return "Point";
     }
   }
diff --git a/generator/statistics.hpp b/generator/statistics.hpp
index fbbe855d33..37bb58d633 100644
--- a/generator/statistics.hpp
+++ b/generator/statistics.hpp
@@ -41,7 +41,7 @@ namespace stats
 
   struct MapInfo
   {
-    std::map<feature::EGeomType, GeneralInfo> m_byGeomType;
+    std::map<feature::GeomType, GeneralInfo> m_byGeomType;
     std::map<ClassifType, GeneralInfo> m_byClassifType;
     std::map<CountType, GeneralInfo> m_byPointsCount, m_byTrgCount;
     std::map<AreaType, GeneralInfo> m_byAreaSize;
diff --git a/generator/world_map_generator.hpp b/generator/world_map_generator.hpp
index 53152292fa..149c78464e 100644
--- a/generator/world_map_generator.hpp
+++ b/generator/world_map_generator.hpp
@@ -297,10 +297,10 @@ public:
       if (PushFeature(fb) || !forcePushToWorld)
         return;
 
-      // We push GEOM_POINT with all the same tags, names and center instead of GEOM_WAY/GEOM_AREA
+      // We push Point with all the same tags, names and center instead of GEOM_WAY/Area
       // because we do not need geometry for invisible features (just search index and placepage
       // data) and want to avoid size checks applied to areas.
-      if (originalFeature.GetGeomType() != feature::GEOM_POINT)
+      if (originalFeature.GetGeomType() != feature::GeomType::Point)
         generator::TransformAreaToPoint(originalFeature);
 
       m_worldBucket.PushSure(originalFeature);
@@ -317,14 +317,14 @@ public:
   {
     switch (fb.GetGeomType())
     {
-    case feature::GEOM_LINE:
+    case feature::GeomType::Line:
     {
       MergedFeatureBuilder1 * p = m_typesCorrector(fb);
       if (p)
         m_merger(p);
       return false;
     }
-    case feature::GEOM_AREA:
+    case feature::GeomType::Area:
     {
       // This constant is set according to size statistics.
       // Added approx 4Mb of data to the World.mwm