[search] Index post box name which looks like postcode as postcode.

generator/feature_builder.cpp

@@ -245,6 +245,7 @@ bool FeatureBuilder::PreSerialize()
     }
 
     // Store ref's in name field (used in "highway-motorway_junction").
+    // Also can be used to save post_box postcodes.
     if (m_params.name.IsEmpty() && !m_params.ref.empty())
       m_params.name.AddString(StringUtf8Multilang::kDefaultCode, m_params.ref);
 

generator/search_index_builder.cpp

@@ -18,6 +18,7 @@
 #include "indexer/feature_visibility.hpp"
 #include "indexer/features_vector.hpp"
 #include "indexer/ftypes_matcher.hpp"
+#include "indexer/postcodes_matcher.hpp"
 #include "indexer/search_delimiters.hpp"
 #include "indexer/search_string_utils.hpp"
 #include "indexer/trie_builder.hpp"
@@ -324,19 +325,44 @@ public:
     FeatureNameInserter<Key, Value> inserter(index, isCountryOrState(types) ? m_synonyms : nullptr,
                                              m_keyValuePairs, hasStreetType);
 
+    auto const & postBoxChecker = ftypes::IsPostBoxChecker::Instance();
     string const postcode = f.GetMetadata().Get(feature::Metadata::FMD_POSTCODE);
+    vector<string> postcodes;
     if (!postcode.empty())
+      postcodes.push_back(postcode);
+
+    bool useNameAsPostcode = false;
+    if (postBoxChecker(types))
+    {
+      auto const & names = f.GetNames();
+      if (names.CountLangs() == 1)
+      {
+        string defaultName;
+        names.GetString(StringUtf8Multilang::kDefaultCode, defaultName);
+        if (!defaultName.empty() && LooksLikePostcode(defaultName, false /* isPrefix */))
+        {
+          // In UK it's common practice to set outer postcode as postcode and outer + inner as ref.
+          // We convert ref to name at FeatureBuilder.
+          postcodes.push_back(defaultName);
+          useNameAsPostcode = true;
+        }
+      }
+    }
+
+    for (auto const & pc : postcodes)
     {
       // See OSM TagInfo or Wiki about modern postcodes format. The
       // mean number of tokens is less than two.
       buffer_vector<strings::UniString, 2> tokens;
-      SplitUniString(NormalizeAndSimplifyString(postcode), base::MakeBackInsertFunctor(tokens),
+      SplitUniString(NormalizeAndSimplifyString(pc), base::MakeBackInsertFunctor(tokens),
                      Delimiters());
       for (auto const & token : tokens)
         inserter.AddToken(kPostcodesLang, token);
     }
 
-    if (!f.ForEachName(inserter))
+    if (!useNameAsPostcode)
+      f.ForEachName(inserter);
+    if (!f.HasName())
       skipIndex.SkipEmptyNameTypes(types);
     if (types.Empty())
       return;

indexer/ftypes_matcher.cpp

@@ -180,6 +180,12 @@ IsSpeedCamChecker::IsSpeedCamChecker()
   m_types.push_back(c.GetTypeByPath({"highway", "speed_camera"}));
 }
 
+IsPostBoxChecker::IsPostBoxChecker()
+{
+  Classificator const & c = classif();
+  m_types.push_back(c.GetTypeByPath({"amenity", "post_box"}));
+}
+
 IsFuelStationChecker::IsFuelStationChecker()
 {
   Classificator const & c = classif();

indexer/ftypes_matcher.hpp

@@ -68,6 +68,14 @@ public:
   DECLARE_CHECKER_INSTANCE(IsSpeedCamChecker);
 };
 
+class IsPostBoxChecker : public BaseChecker
+{
+  IsPostBoxChecker();
+
+public:
+  DECLARE_CHECKER_INSTANCE(IsPostBoxChecker);
+};
+
 class IsFuelStationChecker : public BaseChecker
 {
   IsFuelStationChecker();

search/search_integration_tests/processor_test.cpp

@@ -2367,5 +2367,28 @@ UNIT_CLASS_TEST(ProcessorTest, StreetNumber)
   }
 }
 
+UNIT_CLASS_TEST(ProcessorTest, Postbox)
+{
+  string const countryName = "Wonderland";
+
+  TestPOI postbox(m2::PointD(0.0, 0.0), "127001", "default");
+  postbox.SetTypes({{"amenity", "post_box"}});
+  
+  auto countryId = BuildCountry(countryName, [&](TestMwmBuilder & builder) {
+    builder.Add(postbox);
+  });
+
+  SetViewport(m2::RectD(m2::PointD(0.0, 0.0), m2::PointD(1.0, 1.0)));
+  {
+    Rules rules = {ExactMatch(countryId, postbox)};
+    TEST(ResultsMatch("127001", rules), ());
+  }
+  {
+    // Misprints are not allowed for postcodes.
+    Rules rules = {};
+    TEST(ResultsMatch("127002", rules), ());
+  }
+}
+
 }  // namespace
 }  // namespace search