Function LeaveLongestTypes

generator/osm2type.cpp:367–423

If first 2 (1 for short types like "building") components of pre-matched types are the same, then leave only the longest types (there could be a few of them). Equal arity types are kept. - highway-primary-bridge is left while highway-primary is removed; - building-garages is left while building is removed; - amenity-parking-underground-fee is left while amenity-parking and amenity-parking-fee is r

// - amenity-parking-underground-fee is left while amenity-parking and amenity-parking-fee is removed;
// - both amenity-charging_station-motorcar and amenity-charging_station-bicycle are left;
void LeaveLongestTypes(std::vector<generator::TypeStrings> & matchedTypes)
{
  // Prevents types, that either have subtypes or are subtypes, from being removed
  auto subtypes = ftypes::Subtypes::Instance();
  auto const areSubtypeRelatedTypes = [subtypes](auto const & lhs, auto const & rhs)
  { return subtypes.IsTypeWithSubtypesOrSubtype(lhs) && subtypes.IsTypeWithSubtypesOrSubtype(rhs); };
  auto const isBetterBecauseOfSubtypeRelation = [subtypes](auto const & lhs, auto const & rhs) -> std::optional<bool>
  {
    bool const lhsIsTypeWithSubtypesOrSubtype = subtypes.IsTypeWithSubtypesOrSubtype(lhs);
    bool const rhsIsTypeWithSubtypesOrSubtype = subtypes.IsTypeWithSubtypesOrSubtype(rhs);
    if (lhsIsTypeWithSubtypesOrSubtype && !rhsIsTypeWithSubtypesOrSubtype)
      return true;
    else if (!lhsIsTypeWithSubtypesOrSubtype && rhsIsTypeWithSubtypesOrSubtype)
      return false;

    return subtypes.ComparisonResultBasedOnTypeRelation(lhs, rhs);
  };

  auto const equalPrefix = [](auto const & lhs, auto const & rhs)
  {
    size_t const prefixSz = std::min(lhs.size(), rhs.size());
    return equal(lhs.begin(), lhs.begin() + std::min(size_t(2), prefixSz), rhs.begin());
  };

  auto const isBetter = [&equalPrefix, &isBetterBecauseOfSubtypeRelation](auto const & lhs, auto const & rhs)
  {
    std::optional<bool> const isBetterBecauseOfSubtypeRelationResult = isBetterBecauseOfSubtypeRelation(lhs, rhs);
    if (isBetterBecauseOfSubtypeRelationResult.has_value())
      return isBetterBecauseOfSubtypeRelationResult.value();

    if (equalPrefix(lhs, rhs))
    {
      // Longest type is better.
      if (lhs.size() != rhs.size())
        return lhs.size() > rhs.size();
    }

    return lhs < rhs;
  };

  // `true` means the second one will be removed, because being equal means it isn't unique and the first one is more
  // important
  auto const isEqual = [&equalPrefix, &areSubtypeRelatedTypes](auto const & lhs, auto const & rhs)
  {
    if (equalPrefix(lhs, rhs))
    {
      // Keep longest type only
      if (lhs.size() != rhs.size())
        return !areSubtypeRelatedTypes(lhs, rhs);

      return lhs == rhs;
    }
    return false;
  };

  base::SortUnique(matchedTypes, isBetter, isEqual);
}