Organic Maps sources as of 02.04.2025 (fad26bbf22ac3da75e01e62aa01e5c8e11861005)

To expand with full Organic Maps and Maps.ME commits history run:
  git remote add om-historic [om-historic.git repo url]
  git fetch --tags om-historic
  git replace squashed-history historic-commits

indexer/ftypes_matcher.hpp

@@ -0,0 +1,647 @@
+#pragma once
+
+#include "indexer/feature_data.hpp"
+#include "indexer/feature_utils.hpp"
+
+#include "base/small_map.hpp"
+#include "base/stl_helpers.hpp"
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#define DECLARE_CHECKER_INSTANCE(CheckerType) static CheckerType const & Instance() { \
+                                              static CheckerType const inst; return inst; }
+
+namespace ftypes
+{
+class BaseChecker
+{
+protected:
+  uint8_t const m_level;
+  std::vector<uint32_t> m_types;
+
+  explicit BaseChecker(uint8_t level = 2) : m_level(level) {}
+  virtual ~BaseChecker() = default;
+
+public:
+  virtual bool IsMatched(uint32_t type) const;
+  virtual void ForEachType(std::function<void(uint32_t)> const & fn) const;
+
+  std::vector<uint32_t> const & GetTypes() const { return m_types; }
+
+  bool operator()(feature::TypesHolder const & types) const;
+  bool operator()(FeatureType & ft) const;
+  bool operator()(std::vector<uint32_t> const & types) const;
+  bool operator()(uint32_t type) const { return IsMatched(type); }
+
+  static uint32_t PrepareToMatch(uint32_t type, uint8_t level);
+};
+
+class IsPeakChecker : public BaseChecker
+{
+  IsPeakChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsPeakChecker);
+};
+
+class IsATMChecker : public BaseChecker
+{
+  IsATMChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsATMChecker);
+};
+
+class IsSpeedCamChecker : public BaseChecker
+{
+  IsSpeedCamChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsSpeedCamChecker);
+};
+
+class IsPostBoxChecker : public BaseChecker
+{
+  IsPostBoxChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsPostBoxChecker);
+};
+
+class IsPostPoiChecker : public BaseChecker
+{
+  IsPostPoiChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsPostPoiChecker);
+};
+
+class IsOperatorOthersPoiChecker : public BaseChecker
+{
+  IsOperatorOthersPoiChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsOperatorOthersPoiChecker);
+};
+
+class IsRecyclingCentreChecker : public BaseChecker
+{
+  IsRecyclingCentreChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsRecyclingCentreChecker);
+
+  uint32_t GetType() const;
+};
+
+class IsRecyclingContainerChecker : public BaseChecker
+{
+  IsRecyclingContainerChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsRecyclingContainerChecker);
+
+  uint32_t GetType() const;
+};
+
+class IsRailwayStationChecker : public BaseChecker
+{
+  IsRailwayStationChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsRailwayStationChecker);
+};
+
+class IsSubwayStationChecker : public BaseChecker
+{
+  IsSubwayStationChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsSubwayStationChecker);
+};
+
+class IsAirportChecker : public BaseChecker
+{
+  IsAirportChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsAirportChecker);
+};
+
+class IsSquareChecker : public BaseChecker
+{
+  IsSquareChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsSquareChecker);
+};
+
+// Type of suburb.
+// Do not change values and order - they are in the order of decreasing specificity.
+// Suburb > Neighbourhood > Residential
+enum class SuburbType
+{
+  Residential = 0,
+  Neighbourhood,
+  Quarter,
+  Suburb,
+  Count
+};
+
+class IsSuburbChecker : public BaseChecker
+{
+  IsSuburbChecker();
+
+public:
+  SuburbType GetType(uint32_t t) const;
+  SuburbType GetType(feature::TypesHolder const & types) const;
+  SuburbType GetType(FeatureType & f) const;
+
+  DECLARE_CHECKER_INSTANCE(IsSuburbChecker);
+};
+
+/// @todo Better to rename like IsStreetChecker, as it is used in search context only?
+class IsWayChecker : public BaseChecker
+{
+  IsWayChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsWayChecker);
+
+  enum SearchRank : uint8_t
+  {
+    Default = 0,  // Not a road, other linear way like river, rail ...
+
+    // Bigger is better (more important).
+    Pedestrian,
+    Cycleway,
+    Outdoor,
+    Minors,
+    Residential,
+    Regular,
+    Motorway,
+
+    Count
+  };
+
+  SearchRank GetSearchRank(uint32_t type) const;
+
+private:
+  base::SmallMap<uint32_t, SearchRank> m_ranks;
+};
+
+class IsStreetOrSquareChecker : public BaseChecker
+{
+  IsStreetOrSquareChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsStreetOrSquareChecker);
+};
+
+class IsAddressObjectChecker : public BaseChecker
+{
+  IsAddressObjectChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsAddressObjectChecker);
+};
+
+class IsAddressChecker : public BaseChecker
+{
+  IsAddressChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsAddressChecker);
+};
+
+class IsVillageChecker : public BaseChecker
+{
+  IsVillageChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsVillageChecker);
+};
+
+class IsOneWayChecker : public BaseChecker
+{
+  IsOneWayChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsOneWayChecker);
+
+  uint32_t GetType() const { return m_types[0]; }
+};
+
+class IsRoundAboutChecker : public BaseChecker
+{
+  IsRoundAboutChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsRoundAboutChecker);
+};
+
+class IsLinkChecker : public BaseChecker
+{
+  IsLinkChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsLinkChecker);
+};
+
+class IsBuildingChecker : public BaseChecker
+{
+  IsBuildingChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsBuildingChecker);
+};
+
+class IsBuildingPartChecker : public ftypes::BaseChecker
+{
+  IsBuildingPartChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsBuildingPartChecker);
+};
+
+class IsBuildingHasPartsChecker : public ftypes::BaseChecker
+{
+  IsBuildingHasPartsChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsBuildingHasPartsChecker);
+
+  uint32_t GetType() const { return m_types[0]; }
+};
+
+class IsIsolineChecker : public BaseChecker
+{
+  IsIsolineChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsIsolineChecker);
+};
+
+class IsPisteChecker : public BaseChecker
+{
+  IsPisteChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsPisteChecker);
+};
+
+
+class OneLevelPOIChecker : public ftypes::BaseChecker
+{
+public:
+  OneLevelPOIChecker();
+};
+
+/// Describes 2-level POI-exception types that don't belong to any POI-common classes
+/// (amenity, shop, tourism, ...). Used in search algo and search categories index generation.
+class TwoLevelPOIChecker : public ftypes::BaseChecker
+{
+public:
+  TwoLevelPOIChecker();
+};
+
+// Used in:
+// - search ranking (POIs are ranked somewhat higher than "unclassified" features, see search/model.hpp)
+// - add type's translation into complex PP subtitle (see GetLocalizedAllTypes())
+// - building lists of popular places (generator/popular_places_section_builder.cpp)
+class IsPoiChecker
+{
+public:
+  DECLARE_CHECKER_INSTANCE(IsPoiChecker);
+
+  bool operator()(FeatureType & ft) const { return m_oneLevel(ft) || m_twoLevel(ft); }
+  template <class T> bool operator()(T const & t) const { return m_oneLevel(t) || m_twoLevel(t); }
+
+private:
+  OneLevelPOIChecker const m_oneLevel;
+  TwoLevelPOIChecker const m_twoLevel;
+};
+
+
+class IsAmenityChecker : public BaseChecker
+{
+  IsAmenityChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsAmenityChecker);
+
+  uint32_t GetType() const { return m_types[0]; }
+};
+
+class AttractionsChecker : public BaseChecker
+{
+  size_t m_additionalTypesStart;
+
+  AttractionsChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(AttractionsChecker);
+
+  // Used in generator.
+  uint32_t GetBestType(FeatureParams::Types const & types) const;
+};
+
+class IsPlaceChecker : public BaseChecker
+{
+  IsPlaceChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsPlaceChecker);
+};
+
+class IsBridgeOrTunnelChecker : public BaseChecker
+{
+  virtual bool IsMatched(uint32_t type) const override;
+
+  IsBridgeOrTunnelChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsBridgeOrTunnelChecker);
+};
+
+class IsIslandChecker : public BaseChecker
+{
+  IsIslandChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsIslandChecker);
+};
+
+class IsLandChecker : public BaseChecker
+{
+  IsLandChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsLandChecker);
+
+  uint32_t GetLandType() const;
+};
+
+class IsCoastlineChecker : public BaseChecker
+{
+  IsCoastlineChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsCoastlineChecker);
+
+  uint32_t GetCoastlineType() const;
+};
+
+class IsHotelChecker : public BaseChecker
+{
+  IsHotelChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsHotelChecker);
+};
+
+// WiFi is a type in classificator.txt,
+// it should be checked for filling metadata in MapObject.
+class IsWifiChecker : public BaseChecker
+{
+  IsWifiChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsWifiChecker);
+
+  uint32_t GetType() const { return m_types[0]; }
+};
+
+class IsEatChecker : public BaseChecker
+{
+public:
+//  enum class Type
+//  {
+//    Cafe = 0,
+//    FastFood,
+//    Restaurant,
+//    Bar,
+//    Pub,
+//    Biergarten,
+
+//    Count
+//  };
+
+  DECLARE_CHECKER_INSTANCE(IsEatChecker);
+
+//  Type GetType(uint32_t t) const;
+
+private:
+  IsEatChecker();
+
+//  std::array<uint32_t, base::Underlying(Type::Count)> m_eat2clType;
+};
+
+class IsCuisineChecker : public BaseChecker
+{
+  IsCuisineChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsCuisineChecker);
+};
+
+class IsRecyclingTypeChecker : public BaseChecker
+{
+  IsRecyclingTypeChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsRecyclingTypeChecker);
+};
+
+class IsFeeTypeChecker : public BaseChecker
+{
+  IsFeeTypeChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsFeeTypeChecker);
+};
+
+class IsToiletsChecker : public BaseChecker
+{
+  IsToiletsChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsToiletsChecker);
+};
+
+class IsCapitalChecker : public BaseChecker
+{
+  IsCapitalChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsCapitalChecker);
+};
+
+class IsPublicTransportStopChecker : public BaseChecker
+{
+  IsPublicTransportStopChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsPublicTransportStopChecker);
+};
+
+class IsTaxiChecker : public BaseChecker
+{
+  IsTaxiChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsTaxiChecker);
+};
+
+class IsMotorwayJunctionChecker : public BaseChecker
+{
+  IsMotorwayJunctionChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsMotorwayJunctionChecker);
+};
+
+/// Exotic OSM ways that potentially have "duration" tag.
+class IsWayWithDurationChecker : public BaseChecker
+{
+  IsWayWithDurationChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsWayWithDurationChecker);
+};
+
+/// Type of locality (do not change values and order - they have detalization order)
+/// Country < State < City < ...
+enum class LocalityType : int8_t
+{
+  None = -1,
+  Country = 0,
+  State,
+  City,
+  Town,
+  Village,
+  Count
+};
+
+LocalityType LocalityFromString(std::string_view s);
+
+static_assert(base::Underlying(LocalityType::Country) < base::Underlying(LocalityType::State), "");
+static_assert(base::Underlying(LocalityType::State) < base::Underlying(LocalityType::City), "");
+static_assert(base::Underlying(LocalityType::City) < base::Underlying(LocalityType::Town), "");
+static_assert(base::Underlying(LocalityType::Town) < base::Underlying(LocalityType::Village), "");
+static_assert(base::Underlying(LocalityType::Village) < base::Underlying(LocalityType::Count), "");
+
+class IsLocalityChecker : public BaseChecker
+{
+  IsLocalityChecker();
+
+public:
+  LocalityType GetType(uint32_t t) const;
+
+  template <class Types> LocalityType GetType(Types const & types) const
+  {
+    for (uint32_t const t : types)
+    {
+      LocalityType const type = GetType(t);
+      if (type != LocalityType::None)
+        return type;
+    }
+    return LocalityType::None;
+  }
+
+  LocalityType GetType(FeatureType & f) const;
+
+  DECLARE_CHECKER_INSTANCE(IsLocalityChecker);
+};
+
+
+class IsCountryChecker : public BaseChecker
+{
+  IsCountryChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsCountryChecker);
+};
+
+class IsStateChecker : public BaseChecker
+{
+  IsStateChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsStateChecker);
+};
+
+class IsCityTownOrVillageChecker : public BaseChecker
+{
+  IsCityTownOrVillageChecker();
+public:
+  DECLARE_CHECKER_INSTANCE(IsCityTownOrVillageChecker);
+};
+
+class IsEntranceChecker : public BaseChecker
+{
+  IsEntranceChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsEntranceChecker);
+};
+
+class IsAerowayGateChecker : public BaseChecker
+{
+  IsAerowayGateChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsAerowayGateChecker);
+};
+
+class IsRailwaySubwayEntranceChecker : public BaseChecker
+{
+  IsRailwaySubwayEntranceChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsRailwaySubwayEntranceChecker);
+};
+
+class IsPlatformChecker : public BaseChecker
+{
+  IsPlatformChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsPlatformChecker);
+};
+
+class IsAddressInterpolChecker : public BaseChecker
+{
+  IsAddressInterpolChecker();
+
+  uint32_t m_odd, m_even;
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsAddressInterpolChecker);
+
+  template <class Range> feature::InterpolType GetInterpolType(Range const & range) const
+  {
+    for (uint32_t t : range)
+    {
+      if (t == m_odd)
+        return feature::InterpolType::Odd;
+      if (t == m_even)
+        return feature::InterpolType::Even;
+
+      ftype::TruncValue(t, 1);
+      if (t == m_types[0])
+        return feature::InterpolType::Any;
+    }
+
+    return feature::InterpolType::None;
+  }
+
+  feature::InterpolType GetInterpolType(FeatureType & ft) const
+  {
+    return GetInterpolType(feature::TypesHolder(ft));
+  }
+};
+
+
+/// @name Get city radius and population.
+/// @param r Radius in meters.
+//@{
+uint64_t GetDefPopulation(LocalityType localityType);
+uint64_t GetPopulation(FeatureType & ft);
+double GetRadiusByPopulation(uint64_t p);
+double GetRadiusByPopulationForRouting(uint64_t p, LocalityType localityType);
+uint64_t GetPopulationByRadius(double r);
+//@}
+
+// Highway class. The order is important.
+// The enum values follow from the biggest roads (Trunk) to the smallest ones (Service).
+enum class HighwayClass
+{
+  Undefined = 0,  // There has not been any attempt of calculating HighwayClass.
+  Trunk,
+  Primary,
+  Secondary,
+  Tertiary,
+  LivingStreet,
+  Service,
+  Pedestrian,
+  Transported,    // Vehicles are transported by train or ferry.
+  Count           // This value is used for internals only.
+};
+
+std::string DebugPrint(HighwayClass const cls);
+std::string DebugPrint(LocalityType const localityType);
+
+HighwayClass GetHighwayClass(feature::TypesHolder const & types);
+}  // namespace ftypes