[geocode-glib/wip/nominatim: 4/4] tmp



commit 6740a833bef110a4eea0f93b0c5126e5d2aeca0b
Author: Zeeshan Ali (Khattak) <zeeshanak gnome org>
Date:   Thu Jun 20 23:25:12 2013 +0300

    tmp

 geocode-glib/geocode-forward.c |  410 ++++++++++++----------------------------
 geocode-glib/geocode-place.h   |   63 ++++---
 geocode-glib/geocode-reverse.c |   40 +++--
 3 files changed, 183 insertions(+), 330 deletions(-)
---
diff --git a/geocode-glib/geocode-forward.c b/geocode-glib/geocode-forward.c
index e559409..2a8294c 100644
--- a/geocode-glib/geocode-forward.c
+++ b/geocode-glib/geocode-forward.c
@@ -96,195 +96,13 @@ is_search (GObject *object)
        return GPOINTER_TO_INT (g_object_get_data (G_OBJECT (object), "is-search"));
 }
 
-static struct {
-       const char *pf_attr;
-       const char *xep_attr;
-} rev_attrs_map[] = {
-       { "longitude", "longitude" },
-       { "latitude", "latitude" },
-       { "offsetlat", NULL },
-       { "offsetlon", NULL },
-       { "name", "description" },
-       { "line1", "building" },
-       { "line2", NULL },
-       { "line3", NULL },
-       { "line4", NULL },
-       { "street", "street" },
-       { "postal", "postalcode" },
-       { "neighborhood", "area" },
-       { "city", "locality" },
-       { "county", NULL },
-       { "state", "region" },
-       { "country", "country" },
-       { "countrycode", "countrycode" },
-       { "countycode", NULL },
-       { "timezone", NULL },
-       { "uzip", NULL },
-};
-
-static const char *
-pf_to_xep (const char *attr)
-{
-       guint i;
-
-       for (i = 0; i < G_N_ELEMENTS (rev_attrs_map); i++) {
-               if (g_str_equal (attr, rev_attrs_map[i].pf_attr))
-                       return rev_attrs_map[i].xep_attr;
-       }
-
-       g_debug ("Can't convert unknown attribute '%s'", attr);
-
-       return NULL;
-}
-
 GHashTable *
 _geocode_parse_resolve_json (const char *contents,
                             GError    **error)
 {
        GHashTable *ret;
-       JsonParser *parser;
-       JsonNode *root;
-       JsonReader *reader;
-       gint64 err_code, found;
-       guint i;
-       const GError *err = NULL;
-       char **members;
-
-       ret = NULL;
-
-       parser = json_parser_new ();
-       if (json_parser_load_from_data (parser, contents, -1, error) == FALSE) {
-               g_object_unref (parser);
-               return ret;
-       }
-
-       root = json_parser_get_root (parser);
-       reader = json_reader_new (root);
-
-       if (json_reader_read_member (reader, "ResultSet") == FALSE)
-               goto parse;
-
-       if (json_reader_read_member (reader, "Error") == FALSE)
-               goto parse;
-
-       err_code = json_reader_get_int_value (reader);
-       json_reader_end_member (reader);
-
-       if (err_code != 0) {
-               const char *msg;
-
-               json_reader_read_member (reader, "ErrorMessage");
-               msg = json_reader_get_string_value (reader);
-               json_reader_end_member (reader);
-               if (msg && *msg == '\0')
-                       msg = NULL;
-
-               switch (err_code) {
-               case 1:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"Query not supported");
-                       break;
-               case 100:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"No input parameters");
-                       break;
-               case 102:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"Address data not recognized as valid UTF-8");
-                       break;
-               case 103:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"Insufficient address data");
-                       break;
-               case 104:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"Unknown language");
-                       break;
-               case 105:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"No country detected");
-                       break;
-               case 106:
-                       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NOT_SUPPORTED, msg ? msg : 
"Country not supported");
-                       break;
-               default:
-                       if (msg == NULL)
-                               g_set_error (error, GEOCODE_ERROR, GEOCODE_ERROR_PARSE, "Unknown error code 
%"G_GINT64_FORMAT, err_code);
-                       else
-                               g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_PARSE, msg);
-                       break;
-               }
-               g_object_unref (parser);
-               g_object_unref (reader);
-               return NULL;
-       }
-
-       /* Check for the number of results */
-       if (json_reader_read_member (reader, "Found") == FALSE)
-               goto parse;
-
-       found = json_reader_get_int_value (reader);
-       json_reader_end_member (reader);
-
-       if (!found) {
-               g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_NO_MATCHES, "No matches found for 
request");
-               g_object_unref (parser);
-               g_object_unref (reader);
-               return NULL;
-       }
-
-       if (json_reader_read_member (reader, "Results") == FALSE)
-               goto parse;
-
-       if (json_reader_read_element (reader, 0) == FALSE)
-               goto parse;
-
-       members = json_reader_list_members (reader);
-
-       /* Yay, start adding data */
-       ret = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                    g_free, g_free);
-
-       for (i = 0; members[i] != NULL; i++) {
-               const char *value;
-
-               json_reader_read_member (reader, members[i]);
-
-               if (g_str_equal (members[i], "radius") ||
-                   g_str_equal (members[i], "quality") ||
-                   g_str_equal (members[i], "woeid")) {
-                       gint64 num;
-
-                       num = json_reader_get_int_value (reader);
-                       g_hash_table_insert (ret, g_strdup (members[i]), g_strdup_printf ("%"G_GINT64_FORMAT, 
num));
-                       json_reader_end_member (reader);
-                       continue;
-               }
-
-               value = json_reader_get_string_value (reader);
-               if (value && *value == '\0')
-                       value = NULL;
-
-               if (value != NULL) {
-                       const char *xep_attr;
-
-                       xep_attr = pf_to_xep (members[i]);
-                       if (xep_attr != NULL)
-                               g_hash_table_insert (ret, g_strdup (xep_attr), g_strdup (value));
-                       else
-                               g_hash_table_insert (ret, g_strdup (members[i]), g_strdup (value));
-               }
-               json_reader_end_member (reader);
-       }
-       g_strfreev (members);
-
-       g_object_unref (parser);
-       g_object_unref (reader);
 
        return ret;
-
-parse:
-       if (ret != NULL)
-               g_hash_table_destroy (ret);
-       err = json_reader_get_error (reader);
-       g_set_error_literal (error, GEOCODE_ERROR, GEOCODE_ERROR_PARSE, err->message);
-       g_object_unref (parser);
-       g_object_unref (reader);
-       return NULL;
 }
 
 static GList *
@@ -727,90 +545,28 @@ out:
        return ret;
 }
 
-#define IS_EL(x) (g_str_equal (element_name, x))
-
-static void
-insert_place_attr (GHashTable *ht,
-                  JsonReader *reader,
-                  const char *element_name)
-{
-       char *value;
-
-       if (json_reader_read_member (reader, element_name) == FALSE) {
-               json_reader_end_member (reader);
-               return;
-       }
-
-       /* FIXME: check all the member names against what Place Finder outputs */
-
-       if (IS_EL("woeid") ||
-           IS_EL("popRank") ||
-           IS_EL("areaRank")) {
-               value = g_strdup_printf ("%"G_GINT64_FORMAT, json_reader_get_int_value (reader));
-       } else if (IS_EL("centroid")) {
-               char str[16];
-
-               json_reader_read_member (reader, "longitude");
-               g_ascii_dtostr (str, sizeof(str), json_reader_get_double_value (reader));
-               g_hash_table_insert (ht, g_strdup ("longitude"), g_strdup (str));
-               json_reader_end_member (reader);
-
-               json_reader_read_member (reader, "latitude");
-               g_ascii_dtostr (str, sizeof(str), json_reader_get_double_value (reader));
-               g_hash_table_insert (ht, g_strdup ("latitude"), g_strdup (str));
-               json_reader_end_member (reader);
-               goto end;
-       } else if (g_str_has_suffix (element_name, " attrs")) {
-                if (IS_EL("placeTypeName attrs")) {
-                        char *code;
-
-                        json_reader_read_member (reader, "code");
-                        code = g_strdup_printf ("%" G_GINT64_FORMAT,
-                                                json_reader_get_int_value (reader));
-                        g_hash_table_insert (ht, g_strdup ("placeType"), code);
-                        json_reader_end_member (reader);
-                        goto end;
-                } else {
-                        g_debug ("Ignoring attributes element '%s'", element_name);
-                        value = g_strdup (""); /* So that they're ignored */
-                }
-       } else if (IS_EL("boundingBox")) {
-               g_debug ("Ignoring element '%s'", element_name);
-               value = g_strdup (""); /* So that they're ignored */
-        } else if (IS_EL("placeTypeName")) {
-                /* This string is also localized so we want the code rather
-                 * than name, so we ignore name and extract the code above.
-                 */
-                g_debug ("Ignoring element '%s'", element_name);
-                value = g_strdup (""); /* So that they're ignored */
-       } else {
-               value = g_strdup (json_reader_get_string_value (reader));
-       }
-
-       if (value != NULL && *value == '\0') {
-               g_clear_pointer (&value, g_free);
-               goto end;
-       }
-
-       if (value != NULL)
-               g_hash_table_insert (ht, g_strdup (element_name), value);
-       else
-               g_warning ("Ignoring element %s, don't know how to parse it", element_name);
-
-end:
-       json_reader_end_member (reader);
-}
-
 static struct {
-        const char *yahoo_attr;
+       const char *nominatim_attr;
         const char *place_prop; /* NULL to ignore */
-} yahoo_to_place_map[] = {
-        { "postal", "postal-code" },
-        { "locality1", "town" },
-        { "admin1", "state" },
-        { "admin2", "county" },
-        { "admin3", "administrative-area" },
+} nominatim_to_place_map[] = {
+        { "license", NULL },
+        { "osm_type", NULL },
+        { "osm_id", NULL },
+        { "lat", NULL },
+        { "lon", NULL },
+        { "display_name", NULL },
+        { "house_number", "building" },
+        { "road", "street" },
+        { "suburb", NULL },
+        { "city",  "town" },
+        { "county", "county" },
+        { "state_district", "administrative-area" },
+        { "state", "state" },
+        { "postcode", "postal-code" },
         { "country", "country" },
+        { "country_code", "country-code" },
+        { "continent", "continent" },
+        { "address", NULL },
 };
 
 static void
@@ -820,10 +576,10 @@ fill_place_from_entry (const char   *key,
 {
         guint i;
 
-        for (i = 0; i < G_N_ELEMENTS (yahoo_to_place_map); i++) {
-                if (g_str_equal (key, yahoo_to_place_map[i].yahoo_attr)){
+        for (i = 0; i < G_N_ELEMENTS (nominatim_to_place_map); i++) {
+                if (g_str_equal (key, nominatim_to_place_map[i].nominatim_attr)){
                         g_object_set (G_OBJECT (place),
-                                      yahoo_to_place_map[i].place_prop,
+                                      nominatim_to_place_map[i].place_prop,
                                       value,
                                       NULL);
                         break;
@@ -846,13 +602,107 @@ node_free_func (GNode    *node,
 #define N_ATTRS 7
 static const char const *attributes[7] = {
        "country",
-       "admin1",
-       "admin2",
-       "admin3",
-       "postal",
-       "placeTypeName",
-       "locality1"
+       "state",
+       "county",
+       "state_district",
+       "postalcode",
+       "city"
 };
+        
+static GeocodePlaceType
+get_place_type_from_attributes (GHashTable *ht)
+{
+        char *class, *type;
+
+        class = g_hash_table_lookup (ht, "class");
+        type = g_hash_table_lookup (ht, "type");
+
+        if (class == NULL || type == NULL)
+                return GEOCODE_PLACE_TYPE_UNKNOWN;
+
+        if (strcmp (class, "place") == 0) {
+                if (strcmp (type, "house") == 0 ||
+                    strcmp (type, "building") == 0 ||
+                    strcmp (type, "residential") == 0 ||
+                    strcmp (type, "plaza") == 0 ||
+                    strcmp (type, "office") == 0)
+                        return GEOCODE_PLACE_TYPE_BUILDING;
+                else if (strcmp (type, "estate") == 0)
+                        return GEOCODE_PLACE_TYPE_ESTATE;
+                else if (strcmp (type, "town") == 0 || 
+                         strcmp (type, "city") == 0 ||
+                         strcmp (type, "hamlet") == 0 ||
+                         strcmp (type, "isolated_dwelling") == 0 ||
+                         strcmp (type, "village") == 0)
+                        return GEOCODE_PLACE_TYPE_TOWN;
+                else if (strcmp (type, "suburb") == 0 ||
+                         strcmp (type, "neighbourhood") == 0)
+                        return GEOCODE_PLACE_TYPE_SUBURB;
+                else if (strcmp (type, "state") == 0 ||
+                         strcmp (type, "region") == 0)
+                        return GEOCODE_PLACE_TYPE_STATE;
+                else if (strcmp (type, "farm") == 0 ||
+                         strcmp (type, "forest") == 0 ||
+                         strcmp (type, "valey") == 0 ||
+                         strcmp (type, "park") == 0 ||
+                         strcmp (type, "hill") == 0)
+                        return GEOCODE_PLACE_TYPE_LAND_FEATURE;
+                else if (strcmp (type, "island") == 0 ||
+                         strcmp (type, "islet") == 0)
+                        return GEOCODE_PLACE_TYPE_ISLAND;
+                else if (strcmp (type, "country") == 0)
+                        return GEOCODE_PLACE_TYPE_COUNTRY;
+                else if (strcmp (type, "continent") == 0)
+                        return GEOCODE_PLACE_TYPE_CONTINENT;
+                else if (strcmp (type, "lake") == 0 ||
+                         strcmp (type, "bay") == 0 ||
+                         strcmp (type, "river") == 0)
+                        return GEOCODE_PLACE_TYPE_DRAINAGE;
+                else if (strcmp (type, "sea") == 0)
+                        return GEOCODE_PLACE_TYPE_SEA;
+                else if (strcmp (type, "ocean") == 0)
+                        return GEOCODE_PLACE_TYPE_OCEAN;
+                else
+                        return GEOCODE_PLACE_TYPE_UNKNOWN;
+        } else if (strcmp (class, "highway") == 0) {
+                if (strcmp (type, "motorway") == 0)
+                        return GEOCODE_PLACE_TYPE_MOTORWAY;
+                else if (strcmp (type, "bus_stop") == 0)
+                        return GEOCODE_PLACE_TYPE_BUS_STOP;
+                else
+                        return GEOCODE_PLACE_TYPE_STEET;
+        } else if (strcmp (class, "railway") == 0) {
+                if (strcmp (type, "station") == 0)
+                        return GEOCODE_PLACE_TYPE_RAILWAY_STATION;
+                else
+                        return GEOCODE_PLACE_TYPE_UNKNOWN;
+        } else if (strcmp (class, "waterway") == 0) {
+                return GEOCODE_PLACE_TYPE_DRAINAGE;
+        } else if (strcmp (class, "boundry") == 0) {
+                if (strcmp (type, "administrative") == 0) {
+                        int rank;
+
+                        rank = atoi (g_hash_table_lookup (ht, "place_rank"));
+                        if (rank < 2)
+                                return GEOCODE_PLACE_TYPE_UNKNOWN;
+
+                        if (rank == 28)
+                                return GEOCODE_PLACE_TYPE_BUILDING;
+                        else if (rank == 16)
+                                return GEOCODE_PLACE_TYPE_TOWN;
+                        else if (rank == 12)
+                                return GEOCODE_PLACE_TYPE_COUNTY;
+                        else if (rank == 10 || rank = 8)
+                                return GEOCODE_PLACE_TYPE_STATE;
+                        else if (rank == 4)
+                                return GEOCODE_PLACE_TYPE_COUNTRY;
+                } else {
+                        return GEOCODE_PLACE_TYPE_UNKNOWN;
+                }
+        } else {
+                return GEOCODE_PLACE_TYPE_UNKNOWN;
+        }
+}
 
 static void
 insert_place_into_tree (GNode *place_tree, GHashTable *ht)
@@ -889,8 +739,8 @@ insert_place_into_tree (GNode *place_tree, GHashTable *ht)
                start = child;
        }
 
-        name = g_hash_table_lookup (ht, "name");
-        place_type = atoi (g_hash_table_lookup (ht, "placeType"));
+        name = g_hash_table_lookup (ht, "display_name");
+        place_type = get_place_type_from_attributes (ht);
         place = geocode_place_new (name, place_type);
 
         g_hash_table_foreach (ht, (GHFunc) fill_place_from_entry, place);
@@ -1002,11 +852,6 @@ _geocode_parse_search_json (const char *contents,
        root = json_parser_get_root (parser);
        reader = json_reader_new (root);
 
-       if (json_reader_read_member (reader, "places") == FALSE)
-               goto parse;
-       if (json_reader_read_member (reader, "place") == FALSE)
-               goto parse;
-
        num_places = json_reader_count_elements (reader);
        if (num_places < 0)
                goto parse;
@@ -1020,12 +865,7 @@ _geocode_parse_search_json (const char *contents,
 
                json_reader_read_element (reader, i);
 
-               ht = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                           g_free, g_free);
-
-               members = json_reader_list_members (reader);
-               for (j = 0; members != NULL && members[j] != NULL; j++)
-                       insert_place_attr (ht, reader, members[j]);
+                ht = _geocode_read_nominatim_attributes (reader, false);
 
                /* Populate the tree with place details */
                insert_place_into_tree (place_tree, ht);
diff --git a/geocode-glib/geocode-place.h b/geocode-glib/geocode-place.h
index d4ef648..66bd384 100644
--- a/geocode-glib/geocode-place.h
+++ b/geocode-glib/geocode-place.h
@@ -66,6 +66,8 @@ struct _GeocodePlaceClass {
 /**
  * GeocodePlaceType:
  * @GEOCODE_PLACE_TYPE_UNKNOWN: Type is unknown for this place.
+ * @GEOCODE_PLACE_TYPE_BUILDING: A building or house.
+ * @GEOCODE_PLACE_TYPE_STREET: A street.
  * @GEOCODE_PLACE_TYPE_TOWN: A populated settlement such as a city, town, village.
  * @GEOCODE_PLACE_TYPE_STATE: One of the primary administrative areas within a country.
  * @GEOCODE_PLACE_TYPE_COUNTY: One of the secondary administrative areas within a country.
@@ -74,6 +76,9 @@ struct _GeocodePlaceClass {
  * @GEOCODE_PLACE_TYPE_COUNTRY: One of the countries or dependent territories defined by the ISO 3166-1 
standard.
  * @GEOCODE_PLACE_TYPE_ISLAND: An island.
  * @GEOCODE_PLACE_TYPE_AIRPORT: An airport.
+ * @GEOCODE_PLACE_TYPE_RAILWAY_STATION: A railway station.
+ * @GEOCODE_PLACE_TYPE_BUS_STOP: A bus stop.
+ * @GEOCODE_PLACE_TYPE_MOTORWAY: A high capacity highways designed to safely carry fast motor traffic.
  * @GEOCODE_PLACE_TYPE_DRAINAGE: A water feature such as a river, canal, lake, bay or ocean.
  * @GEOCODE_PLACE_TYPE_LAND_FEATURE: A land feature such as a park, mountain or beach.
  * @GEOCODE_PLACE_TYPE_MISCELLANEOUS: A uncategorized place.
@@ -95,37 +100,37 @@ struct _GeocodePlaceClass {
  */
 typedef enum {
         GEOCODE_PLACE_TYPE_UNKNOWN = 0,
-        GEOCODE_PLACE_TYPE_TOWN = 7,
-        GEOCODE_PLACE_TYPE_STATE = 8,
-        GEOCODE_PLACE_TYPE_COUNTY = 9,
-        GEOCODE_PLACE_TYPE_LOCAL_ADMINISTRATIVE_AREA = 10,
-        GEOCODE_PLACE_TYPE_POSTAL_CODE = 11,
-        GEOCODE_PLACE_TYPE_COUNTRY = 12,
-        GEOCODE_PLACE_TYPE_ISLAND = 13,
-        GEOCODE_PLACE_TYPE_AIRPORT = 14,
-        GEOCODE_PLACE_TYPE_DRAINAGE = 15,
-        GEOCODE_PLACE_TYPE_LAND_FEATURE = 16,
-        GEOCODE_PLACE_TYPE_MISCELLANEOUS = 17,
-        GEOCODE_PLACE_TYPE_SUPERNAME = 19,
-        GEOCODE_PLACE_TYPE_POINT_OF_INTEREST = 20,
-        GEOCODE_PLACE_TYPE_SUBURB = 22,
-        GEOCODE_PLACE_TYPE_COLLOQUIAL = 24,
-        GEOCODE_PLACE_TYPE_ZONE = 25,
-        GEOCODE_PLACE_TYPE_HISTORICAL_STATE = 26,
-        GEOCODE_PLACE_TYPE_HISTORICAL_COUNTY = 27,
-        GEOCODE_PLACE_TYPE_CONTINENT = 29,
-        GEOCODE_PLACE_TYPE_TIME_ZONE = 31,
-        GEOCODE_PLACE_TYPE_ESTATE = 33,
-        GEOCODE_PLACE_TYPE_HISTORICAL_TOWN = 35,
-        GEOCODE_PLACE_TYPE_OCEAN = 37,
-        GEOCODE_PLACE_TYPE_SEA = 38
+        GEOCODE_PLACE_TYPE_BUILDING,
+        GEOCODE_PLACE_TYPE_STREET,
+        GEOCODE_PLACE_TYPE_TOWN,
+        GEOCODE_PLACE_TYPE_STATE,
+        GEOCODE_PLACE_TYPE_COUNTY,
+        GEOCODE_PLACE_TYPE_LOCAL_ADMINISTRATIVE_AREA,
+        GEOCODE_PLACE_TYPE_POSTAL_CODE,
+        GEOCODE_PLACE_TYPE_COUNTRY,
+        GEOCODE_PLACE_TYPE_ISLAND,
+        GEOCODE_PLACE_TYPE_AIRPORT,
+        GEOCODE_PLACE_TYPE_RAILWAY_STATION,
+        GEOCODE_PLACE_TYPE_BUS_STOP,
+        GEOCODE_PLACE_TYPE_MOTORWAY,
+        GEOCODE_PLACE_TYPE_DRAINAGE,
+        GEOCODE_PLACE_TYPE_LAND_FEATURE,
+        GEOCODE_PLACE_TYPE_MISCELLANEOUS,
+        GEOCODE_PLACE_TYPE_SUPERNAME,
+        GEOCODE_PLACE_TYPE_POINT_OF_INTEREST,
+        GEOCODE_PLACE_TYPE_SUBURB,
+        GEOCODE_PLACE_TYPE_COLLOQUIAL,
+        GEOCODE_PLACE_TYPE_ZONE,
+        GEOCODE_PLACE_TYPE_HISTORICAL_STATE,
+        GEOCODE_PLACE_TYPE_HISTORICAL_COUNTY,
+        GEOCODE_PLACE_TYPE_CONTINENT,
+        GEOCODE_PLACE_TYPE_TIME_ZONE,
+        GEOCODE_PLACE_TYPE_ESTATE,
+        GEOCODE_PLACE_TYPE_HISTORICAL_TOWN,
+        GEOCODE_PLACE_TYPE_OCEAN,
+        GEOCODE_PLACE_TYPE_SEA
 } GeocodePlaceType;
 
-/* The above values and their explanation is based on Yahoo places API:
- *
- * http://where.yahooapis.com/v1/placetypes?select=long&appid=YOUR_APP_ID
- */
-
 #define GEOCODE_TYPE_PLACE (geocode_place_get_type ())
 
 GeocodePlace *geocode_place_new                   (const char      *name,
diff --git a/geocode-glib/geocode-reverse.c b/geocode-glib/geocode-reverse.c
index a436eca..14ff24b 100644
--- a/geocode-glib/geocode-reverse.c
+++ b/geocode-glib/geocode-reverse.c
@@ -120,7 +120,7 @@ static struct {
        { "county", NULL },
        { "state_district", NULL },
        { "state", "region" },
-        { "postalcode", NULL },
+        { "postcode", "postalcode" },
        { "country", "country" },
        { "country_code", "countrycode" },
        { "continent", NULL },
@@ -142,12 +142,18 @@ nominatim_to_xep (const char *attr)
        return NULL;
 }
 
-static void
-add_nominatim_attributes (JsonReader *reader, GHashTable *hash_table)
+static GHashTable *
+_geocode_read_nominatim_attributes (JsonReader *reader,
+                                    gboolean    translate_to_xep)
 {
+       GHashTable *ret;
        char **members;
        guint i;
 
+       /* Yay, start adding data */
+       ret = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                    g_free, g_free);
+
        members = json_reader_list_members (reader);
 
        for (i = 0; members[i] != NULL; i++) {
@@ -161,18 +167,29 @@ add_nominatim_attributes (JsonReader *reader, GHashTable *hash_table)
 
                 if (value != NULL) {
                         const char *xep_attr;
+                        
+                        if (translate_to_xep)
+                            xep_attr = nominatim_to_xep (members[i]);
+                        else
+                            xep_attr = NULL;
 
-                        xep_attr = nominatim_to_xep (members[i]);
                         if (xep_attr != NULL)
-                                g_hash_table_insert (hash_table, g_strdup (xep_attr), g_strdup (value));
+                                g_hash_table_insert (ret, g_strdup (xep_attr), g_strdup (value));
                         else
-                                g_hash_table_insert (hash_table, g_strdup (members[i]), g_strdup (value));
+                                g_hash_table_insert (ret, g_strdup (members[i]), g_strdup (value));
                 }
 
                 json_reader_end_member (reader);
         }
 
        g_strfreev (members);
+
+       if (json_reader_read_member (reader, "address")) {
+                add_nominatim_attributes (reader, ret);
+                json_reader_end_member (reader);
+        }
+
+        return ret;
 }
 
 static GHashTable *
@@ -212,16 +229,7 @@ resolve_json (const char *contents,
                return NULL;
        }
 
-       /* Yay, start adding data */
-       ret = g_hash_table_new_full (g_str_hash, g_str_equal,
-                                    g_free, g_free);
-
-        add_nominatim_attributes (reader, ret);
-
-       if (json_reader_read_member (reader, "address")) {
-                add_nominatim_attributes (reader, ret);
-                json_reader_end_member (reader);
-        }
+        ret = _geocode_read_nominatim_attributes (reader, true);
 
        g_object_unref (parser);
        g_object_unref (reader);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]