fix postcode search when using primitive parser

Author: rinigus

importer/src/main.cpp

@@ -582,10 +582,11 @@ class AdminVisitor: public osmscout::AdminRegionVisitor
         const auto &v = additional_postal_codes.at(rid);
         for (auto c: v)
           {
-            sqlite3pp::command cmd(m_db, "INSERT INTO object_primary_tmp (id, postal_code, longitude, latitude) VALUES (?, ?, ?, ?)");
+            sqlite3pp::command cmd(m_db, "INSERT INTO object_primary_tmp (id, postal_code, parent, longitude, latitude) VALUES (?, ?, ?, ?, ?)");
             id = IDs.next();
             cmd.binder() << id
                          << c.code
+                         << regionID
                          << c.longitude
                          << c.latitude;
             if (cmd.execute() != SQLITE_OK)

src/geocoder.cpp

@@ -210,7 +210,7 @@ bool Geocoder::search(const std::vector<Postal::ParseResult> &parsed_query, std:
           search(r, postal_code, result);
 #ifdef GEONLP_PRINT_DEBUG_QUERIES
         else
-          std::cout << "Skipping hierarchy since search result already has more levels than provided\n";
+          std::cout << "Skipping hierarchy since search result already has more levels (" << m_levels_resolved << ") than provided\n";
 #endif
 #ifdef GEONLP_PRINT_DEBUG_QUERIES
         std::cout << "\n";
@@ -371,13 +371,14 @@ bool Geocoder::search(const Postal::Hierarchy &parsed, const std::string &postal
            !search(parsed, postal_is_ok ? "" : postal_code, result, level+1, id+1, last_subobject) )
         {
           size_t levels_resolved = level+1;
+          bool newlevel = false;
           if ( m_levels_resolved < levels_resolved )
             {
               result.clear();
-              m_levels_resolved = levels_resolved;
+              newlevel = true;
             }
-
-          if (m_levels_resolved == levels_resolved && (m_max_results == 0 || result.size() < m_max_inter_results))
+              
+          if ( (m_levels_resolved == levels_resolved || newlevel) && (m_max_results == 0 || result.size() < m_max_inter_results))
             {
               bool have_already = false;
               for (const auto &r: result)
@@ -395,6 +396,7 @@ bool Geocoder::search(const Postal::Hierarchy &parsed, const std::string &postal
                       r.id = id;
                       r.levels_resolved = levels_resolved;
                       result.push_back(r);
+                      m_levels_resolved = levels_resolved;
                     }
                   else if (id < last_subobject)
                     {
@@ -415,6 +417,7 @@ bool Geocoder::search(const Postal::Hierarchy &parsed, const std::string &postal
                           v.getter() >> r.id;
                           r.levels_resolved = levels_resolved;
                           result.push_back(r);
+                          m_levels_resolved = levels_resolved;
                           if (m_max_results > 0 && result.size() >= m_max_inter_results)
                             break;
                         }

src/postal.cpp

@@ -27,7 +27,8 @@ using namespace GeoNLP;
 #define ADDRESS_PARSER_LABEL_COUNTRY_REGION "country_region"
 #define ADDRESS_PARSER_LABEL_COUNTRY  "country"
 
-#define PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE "post:"
+#define PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_INPUT "post:"
+#define PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_KEY "h-postcode"
 
 //////////////////////////////////////////////////////////////////////
 /// Helper string functions
@@ -311,29 +312,28 @@ bool Postal::parse(const std::string &input, std::vector<Postal::ParseResult> &r
     {
       std::vector<std::string> hier;
       split_tokens(input, ',', hier);
+      if (hier.empty()) hier.push_back(input);
 
-      if (!hier.empty())
+      ParseResult prim;
+      int shift = 0;
+      size_t np = strlen(PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_INPUT);
+      for (size_t j = 0; j < hier.size(); j++)
         {
-          ParseResult prim;
-          int shift = 0;
-          size_t np = strlen(PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE);
-          for (size_t j = 0; j < hier.size(); j++)
+          std::string v = hier[hier.size()-j-1];
+          std::string key = primitive_key(j-shift);
+          v = trim(v);
+          if (v.compare(0, np, PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_INPUT) == 0)
             {
-              std::string v = hier[hier.size()-j-1];
-              std::string key = primitive_key(j-shift);
-              if (v.compare(0, np, PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE) == 0)
-                {
-                  v = v.substr(np+1);
-                  v = trim(v);
-                  key = PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE;
-                  shift += 1;
-                }
-              std::vector<std::string> pc; pc.push_back(v);
-              prim[key] = pc;
+              v = v.substr(np);
+              v = trim(v);
+              key = PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_KEY;
+              shift += 1;
             }
-
-          expand(prim, result);
+          std::vector<std::string> pc; pc.push_back(v);
+          prim[key] = pc;
         }
+      
+      expand(prim, result);
     }
 
   if (m_initialize_for_every_call) drop();
@@ -370,7 +370,7 @@ void Postal::expand(const Postal::ParseResult &input, std::vector<Postal::ParseR
         {
           std::vector< std::string > norm;
           // no need to keep postal code in normalized and expanded
-          if (i.first == ADDRESS_PARSER_LABEL_POSTAL_CODE)
+          if (i.first == ADDRESS_PARSER_LABEL_POSTAL_CODE || i.first == PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_KEY)
             norm.push_back(tonorm);
           else
             {
@@ -492,6 +492,11 @@ void Postal::result2hierarchy(const std::vector<ParseResult> &p, std::vector<Hie
             }
         }
 
+      // overwrite with the primitive parser postal code if needed
+      ParseResult::const_iterator it = r.find(PRIMITIVE_ADDRESS_PARSER_POSTAL_CODE_KEY);
+      if (it != r.end() && it->second.size())
+        postal_code = normalize_postalcode(it->second[0]);
+
       h.push_back(h_result);
     }
 }