lib: Stop using g_type_class_add_private()

It was deprecated, replace it with the G_DEFINE_TYPE_WITH_CODE macro.

5 files changed, 405 insertions, 219 deletions

diff --git a/geocode-glib/geocode-bounding-box.c b/geocode-glib/geocode-bounding-box.c
index 2dd99de..bb57c0e 100644
--- a/geocode-glib/geocode-bounding-box.c
+++ b/geocode-glib/geocode-bounding-box.c
@@ -47,7 +47,8 @@ enum {
         PROP_RIGHT
 };
 
-G_DEFINE_TYPE (GeocodeBoundingBox, geocode_bounding_box, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_CODE (GeocodeBoundingBox, geocode_bounding_box, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GeocodeBoundingBox))
 
 static void
 geocode_bounding_box_get_property (GObject    *object,
@@ -89,36 +90,44 @@ static void
 geocode_bounding_box_set_top (GeocodeBoundingBox *bbox,
                               gdouble             top)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_if_fail (top >= -90.0 && top <= 90.0);
 
-        bbox->priv->top = top;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        priv->top = top;
 }
 
 static void
 geocode_bounding_box_set_bottom (GeocodeBoundingBox *bbox,
                                  gdouble             bottom)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_if_fail (bottom >= -90.0 && bottom <= 90.0);
 
-        bbox->priv->bottom = bottom;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        priv->bottom = bottom;
 }
 
 static void
 geocode_bounding_box_set_left (GeocodeBoundingBox *bbox,
                                gdouble             left)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_if_fail (left >= -180.0 && left <= 180.0);
 
-        bbox->priv->left = left;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        priv->left = left;
 }
 
 static void
 geocode_bounding_box_set_right (GeocodeBoundingBox *bbox,
                                 gdouble             right)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_if_fail (right >= -180.0 && right <= 180.0);
 
-        bbox->priv->right = right;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        priv->right = right;
 }
 
 static void
@@ -173,8 +182,6 @@ geocode_bounding_box_class_init (GeocodeBoundingBoxClass *klass)
         gbbox_class->get_property = geocode_bounding_box_get_property;
         gbbox_class->set_property = geocode_bounding_box_set_property;
 
-        g_type_class_add_private (klass, sizeof (GeocodeBoundingBoxPrivate));
-
         /**
          * GeocodeBoundingBox:top:
          *
@@ -244,9 +251,6 @@ geocode_bounding_box_class_init (GeocodeBoundingBoxClass *klass)
 static void
 geocode_bounding_box_init (GeocodeBoundingBox *bbox)
 {
-        bbox->priv = G_TYPE_INSTANCE_GET_PRIVATE ((bbox),
-                                                  GEOCODE_TYPE_BOUNDING_BOX,
-                                                  GeocodeBoundingBoxPrivate);
 }
 
 /**
@@ -291,13 +295,19 @@ gboolean
 geocode_bounding_box_equal (GeocodeBoundingBox *a,
                             GeocodeBoundingBox *b)
 {
+        GeocodeBoundingBoxPrivate *priv_a;
+        GeocodeBoundingBoxPrivate *priv_b;
+
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (a), FALSE);
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (b), FALSE);
 
-        return (a->priv->top == b->priv->top &&
-                a->priv->bottom == b->priv->bottom &&
-                a->priv->left == b->priv->left &&
-                a->priv->right == b->priv->right);
+        priv_a = geocode_bounding_box_get_instance_private (a);
+        priv_b = geocode_bounding_box_get_instance_private (b);
+
+        return (priv_a->top == priv_b->top &&
+                priv_a->bottom == priv_b->bottom &&
+                priv_a->left == priv_b->left &&
+                priv_a->right == priv_b->right);
 }
 
 /**
@@ -311,9 +321,11 @@ geocode_bounding_box_equal (GeocodeBoundingBox *a,
 gdouble
 geocode_bounding_box_get_top (GeocodeBoundingBox *bbox)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (bbox), 0.0);
 
-        return bbox->priv->top;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        return priv->top;
 }
 
 /**
@@ -327,9 +339,11 @@ geocode_bounding_box_get_top (GeocodeBoundingBox *bbox)
 gdouble
 geocode_bounding_box_get_bottom (GeocodeBoundingBox *bbox)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (bbox), 0.0);
 
-        return bbox->priv->bottom;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        return priv->bottom;
 }
 
 /**
@@ -343,9 +357,11 @@ geocode_bounding_box_get_bottom (GeocodeBoundingBox *bbox)
 gdouble
 geocode_bounding_box_get_left (GeocodeBoundingBox *bbox)
 {
+        GeocodeBoundingBoxPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (bbox), 0.0);
 
-        return bbox->priv->left;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        return priv->left;
 }
 
 /**
@@ -359,7 +375,10 @@ geocode_bounding_box_get_left (GeocodeBoundingBox *bbox)
 gdouble
 geocode_bounding_box_get_right (GeocodeBoundingBox *bbox)
 {
+        GeocodeBoundingBoxPrivate *priv;
+
         g_return_val_if_fail (GEOCODE_IS_BOUNDING_BOX (bbox), 0.0);
 
-        return bbox->priv->right;
+        priv = geocode_bounding_box_get_instance_private (bbox);
+        return priv->right;
 }
diff --git a/geocode-glib/geocode-forward.c b/geocode-glib/geocode-forward.c
index 43ea4ad..e690c30 100644
--- a/geocode-glib/geocode-forward.c
+++ b/geocode-glib/geocode-forward.c
@@ -58,7 +58,8 @@ enum {
         PROP_BOUNDED
 };
 
-G_DEFINE_TYPE (GeocodeForward, geocode_forward, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_CODE (GeocodeForward, geocode_forward, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GeocodeForward))
 
 static void
 geocode_forward_get_property (GObject	 *object,
@@ -125,10 +126,12 @@ geocode_forward_set_property(GObject	   *object,
 static void
 geocode_forward_finalize (GObject *gforward)
 {
+	GeocodeForwardPrivate *priv;
 	GeocodeForward *forward = (GeocodeForward *) gforward;
 
-	g_clear_pointer (&forward->priv->ht, g_hash_table_unref);
-	g_clear_object (&forward->priv->backend);
+	priv = geocode_forward_get_instance_private (forward);
+	g_clear_pointer (&priv->ht, g_hash_table_unref);
+	g_clear_object (&priv->backend);
 
 	G_OBJECT_CLASS (geocode_forward_parent_class)->finalize (gforward);
 }
@@ -143,9 +146,6 @@ geocode_forward_class_init (GeocodeForwardClass *klass)
 	gforward_class->get_property = geocode_forward_get_property;
 	gforward_class->set_property = geocode_forward_set_property;
 
-
-	g_type_class_add_private (klass, sizeof (GeocodeForwardPrivate));
-
 	/**
 	* GeocodeForward:answer-count:
 	*
@@ -203,21 +203,24 @@ free_value (GValue *value)
 static void
 geocode_forward_init (GeocodeForward *forward)
 {
-	forward->priv = G_TYPE_INSTANCE_GET_PRIVATE ((forward), GEOCODE_TYPE_FORWARD, GeocodeForwardPrivate);
-	forward->priv->ht = g_hash_table_new_full (g_str_hash, g_str_equal,
-	                                           g_free,
-	                                           (GDestroyNotify) free_value);
-	forward->priv->answer_count = DEFAULT_ANSWER_COUNT;
-	forward->priv->search_area = NULL;
-	forward->priv->bounded = FALSE;
+	GeocodeForwardPrivate *priv;
+
+	priv = geocode_forward_get_instance_private (forward);
+	priv->ht = g_hash_table_new_full (g_str_hash, g_str_equal,
+	                                  g_free,
+	                                  (GDestroyNotify) free_value);
+	priv->answer_count = DEFAULT_ANSWER_COUNT;
+	priv->search_area = NULL;
+	priv->bounded = FALSE;
 }
 
 static void
 ensure_backend (GeocodeForward *object)
 {
+	GeocodeForwardPrivate *priv = geocode_forward_get_instance_private (object);
 	/* If no backend is specified, default to the GNOME Nominatim backend */
-	if (object->priv->backend == NULL)
-		object->priv->backend = GEOCODE_BACKEND (geocode_nominatim_get_gnome ());
+	if (priv->backend == NULL)
+		priv->backend = GEOCODE_BACKEND (geocode_nominatim_get_gnome ());
 }
 
 /**
@@ -236,6 +239,7 @@ GeocodeForward *
 geocode_forward_new_for_params (GHashTable *params)
 {
 	GeocodeForward *forward;
+	GeocodeForwardPrivate *priv;
 	GHashTableIter iter;
 	const gchar *key;
 	const GValue *value;
@@ -250,12 +254,13 @@ geocode_forward_new_for_params (GHashTable *params)
 	forward = g_object_new (GEOCODE_TYPE_FORWARD, NULL);
 
 	g_hash_table_iter_init (&iter, params);
+	priv = geocode_forward_get_instance_private (forward);
 
 	while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value)) {
 		GValue *value_copy = g_new0 (GValue, 1);
 		g_value_init (value_copy, G_VALUE_TYPE (value));
 		g_value_copy (value, value_copy);
-		g_hash_table_insert (forward->priv->ht, g_strdup (key), value_copy);
+		g_hash_table_insert (priv->ht, g_strdup (key), value_copy);
 	}
 
 	return forward;
@@ -274,6 +279,7 @@ GeocodeForward *
 geocode_forward_new_for_string (const char *location)
 {
 	GeocodeForward *forward;
+	GeocodeForwardPrivate *priv;
 	GValue *location_value;
 
 	g_return_val_if_fail (location != NULL, NULL);
@@ -283,7 +289,8 @@ geocode_forward_new_for_string (const char *location)
 	location_value = g_new0 (GValue, 1);
 	g_value_init (location_value, G_TYPE_STRING);
 	g_value_set_string (location_value, location);
-	g_hash_table_insert (forward->priv->ht, g_strdup ("location"),
+	priv = geocode_forward_get_instance_private (forward);
+	g_hash_table_insert (priv->ht, g_strdup ("location"),
 	                     location_value);
 
 	return forward;
@@ -325,17 +332,19 @@ geocode_forward_search_async (GeocodeForward      *forward,
 			      GAsyncReadyCallback  callback,
 			      gpointer             user_data)
 {
+	GeocodeForwardPrivate *priv;
 	GTask *task;
 
 	g_return_if_fail (GEOCODE_IS_FORWARD (forward));
 	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
 
 	ensure_backend (forward);
-	g_assert (forward->priv->backend != NULL);
+	priv = geocode_forward_get_instance_private (forward);
+	g_assert (priv->backend != NULL);
 
 	task = g_task_new (forward, cancellable, callback, user_data);
-	geocode_backend_forward_search_async (forward->priv->backend,
-	                                      forward->priv->ht,
+	geocode_backend_forward_search_async (priv->backend,
+	                                      priv->ht,
 	                                      cancellable,
 	                                      (GAsyncReadyCallback) backend_forward_search_ready,
 	                                      g_object_ref (task));
@@ -386,14 +395,16 @@ GList *
 geocode_forward_search (GeocodeForward      *forward,
 			GError             **error)
 {
+	GeocodeForwardPrivate *priv;
 	g_return_val_if_fail (GEOCODE_IS_FORWARD (forward), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	ensure_backend (forward);
-	g_assert (forward->priv->backend != NULL);
+	priv = geocode_forward_get_instance_private (forward);
+	g_assert (priv->backend != NULL);
 
-	return geocode_backend_forward_search (forward->priv->backend,
-	                                       forward->priv->ht,
+	return geocode_backend_forward_search (priv->backend,
+	                                       priv->ht,
 	                                       NULL,
 	                                       error);
 }
@@ -410,18 +421,20 @@ geocode_forward_set_answer_count (GeocodeForward *forward,
 				  guint           count)
 {
 	GValue *count_value;
+	GeocodeForwardPrivate *priv;
 
 	g_return_if_fail (GEOCODE_IS_FORWARD (forward));
 	g_return_if_fail (count > 0);
 
-	forward->priv->answer_count = count;
+	priv = geocode_forward_get_instance_private (forward);
+	priv->answer_count = count;
 
 	/* Note: This key name is not defined in the Telepathy specification or
 	 * in XEP-0080; it is custom, but standard within Geocode. */
 	count_value = g_new0 (GValue, 1);
 	g_value_init (count_value, G_TYPE_UINT);
 	g_value_set_uint (count_value, count);
-	g_hash_table_insert (forward->priv->ht, g_strdup ("limit"),
+	g_hash_table_insert (priv->ht, g_strdup ("limit"),
 	                     count_value);
 }
 
@@ -437,6 +450,7 @@ geocode_forward_set_search_area (GeocodeForward     *forward,
 				 GeocodeBoundingBox *bbox)
 {
 	GValue *area_value;
+	GeocodeForwardPrivate *priv;
 	char *area;
 	char top[G_ASCII_DTOSTR_BUF_SIZE];
 	char left[G_ASCII_DTOSTR_BUF_SIZE];
@@ -445,7 +459,8 @@ geocode_forward_set_search_area (GeocodeForward     *forward,
 
 	g_return_if_fail (GEOCODE_IS_FORWARD (forward));
 
-	forward->priv->search_area = bbox;
+	priv = geocode_forward_get_instance_private (forward);
+	priv->search_area = bbox;
 
 	/* need to convert with g_ascii_dtostr to be locale safe */
 	g_ascii_dtostr (top, G_ASCII_DTOSTR_BUF_SIZE,
@@ -466,7 +481,7 @@ geocode_forward_set_search_area (GeocodeForward     *forward,
 	area_value = g_new0 (GValue, 1);
 	g_value_init (area_value, G_TYPE_STRING);
 	g_value_take_string (area_value, area);
-	g_hash_table_insert (forward->priv->ht, g_strdup ("viewbox"),
+	g_hash_table_insert (priv->ht, g_strdup ("viewbox"),
 	                     area_value);
 }
 
@@ -484,17 +499,19 @@ geocode_forward_set_bounded (GeocodeForward *forward,
 			     gboolean        bounded)
 {
 	GValue *bounded_value;
+	GeocodeForwardPrivate *priv;
 
 	g_return_if_fail (GEOCODE_IS_FORWARD (forward));
 
-	forward->priv->bounded = bounded;
+	priv = geocode_forward_get_instance_private (forward);
+	priv->bounded = bounded;
 
 	/* Note: This key name is not defined in the Telepathy specification or
 	 * in XEP-0080; it is custom, but standard within Geocode. */
 	bounded_value = g_new0 (GValue, 1);
 	g_value_init (bounded_value, G_TYPE_STRING);
 	g_value_set_boolean (bounded_value, bounded);
-	g_hash_table_insert (forward->priv->ht, g_strdup ("bounded"),
+	g_hash_table_insert (priv->ht, g_strdup ("bounded"),
 	                     bounded_value);
 }
 
@@ -507,9 +524,11 @@ geocode_forward_set_bounded (GeocodeForward *forward,
 guint
 geocode_forward_get_answer_count (GeocodeForward *forward)
 {
+	GeocodeForwardPrivate *priv;
 	g_return_val_if_fail (GEOCODE_IS_FORWARD (forward), 0);
 
-	return forward->priv->answer_count;
+	priv = geocode_forward_get_instance_private (forward);
+	return priv->answer_count;
 }
 
 /**
@@ -523,9 +542,11 @@ geocode_forward_get_answer_count (GeocodeForward *forward)
 GeocodeBoundingBox *
 geocode_forward_get_search_area (GeocodeForward *forward)
 {
+	GeocodeForwardPrivate *priv;
 	g_return_val_if_fail (GEOCODE_IS_FORWARD (forward), NULL);
 
-	return forward->priv->search_area;
+	priv = geocode_forward_get_instance_private (forward);
+	return priv->search_area;
 }
 
 /**
@@ -538,9 +559,11 @@ geocode_forward_get_search_area (GeocodeForward *forward)
 gboolean
 geocode_forward_get_bounded (GeocodeForward *forward)
 {
+	GeocodeForwardPrivate *priv;
 	g_return_val_if_fail (GEOCODE_IS_FORWARD (forward), FALSE);
 
-	return forward->priv->bounded;
+	priv = geocode_forward_get_instance_private (forward);
+	return priv->bounded;
 }
 
 /**
@@ -559,8 +582,11 @@ void
 geocode_forward_set_backend (GeocodeForward *forward,
                              GeocodeBackend *backend)
 {
+	GeocodeForwardPrivate *priv;
+
 	g_return_if_fail (GEOCODE_IS_FORWARD (forward));
 	g_return_if_fail (backend == NULL || GEOCODE_IS_BACKEND (backend));
 
-	g_set_object (&forward->priv->backend, backend);
+	priv = geocode_forward_get_instance_private (forward);
+	g_set_object (&priv->backend, backend);
 }
diff --git a/geocode-glib/geocode-location.c b/geocode-glib/geocode-location.c
index 70a94c1..5be1711 100644
--- a/geocode-glib/geocode-location.c
+++ b/geocode-glib/geocode-location.c
@@ -60,7 +60,8 @@ enum {
         PROP_CRS,
 };
 
-G_DEFINE_TYPE (GeocodeLocation, geocode_location, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_CODE (GeocodeLocation, geocode_location, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GeocodeLocation))
 
 static void
 geocode_location_get_property (GObject    *object,
@@ -138,77 +139,100 @@ gboolean
 geocode_location_equal (GeocodeLocation *a,
                         GeocodeLocation *b)
 {
+        GeocodeLocationPrivate *priv_a;
+        GeocodeLocationPrivate *priv_b;
+
         g_return_val_if_fail (GEOCODE_IS_LOCATION (a), FALSE);
         g_return_val_if_fail (GEOCODE_IS_LOCATION (b), FALSE);
 
-        return (a->priv->longitude == b->priv->longitude &&
-                a->priv->latitude == b->priv->latitude &&
-                a->priv->altitude == b->priv->altitude &&
-                a->priv->accuracy == b->priv->accuracy &&
-                a->priv->timestamp == b->priv->timestamp &&
-                g_strcmp0 (a->priv->description, b->priv->description) == 0 &&
-                a->priv->crs == b->priv->crs);
+        priv_a = geocode_location_get_instance_private (a);
+        priv_b = geocode_location_get_instance_private (b);
+
+        return (priv_a->longitude == priv_b->longitude &&
+                priv_a->latitude == priv_b->latitude &&
+                priv_a->altitude == priv_b->altitude &&
+                priv_a->accuracy == priv_b->accuracy &&
+                priv_a->timestamp == priv_b->timestamp &&
+                g_strcmp0 (priv_a->description, priv_b->description) == 0 &&
+                priv_a->crs == priv_b->crs);
 }
 
 static void
 geocode_location_set_latitude (GeocodeLocation *loc,
                                gdouble          latitude)
 {
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (latitude >= -90.0 && latitude <= 90.0);
 
-        loc->priv->latitude = latitude;
+        priv = geocode_location_get_instance_private (loc);
+        priv->latitude = latitude;
 }
 
 static void
 geocode_location_set_longitude (GeocodeLocation *loc,
                                 gdouble          longitude)
 {
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (longitude >= -180.0 && longitude <= 180.0);
 
-        loc->priv->longitude = longitude;
+        priv = geocode_location_get_instance_private (loc);
+        priv->longitude = longitude;
 }
 
 static void
 geocode_location_set_altitude (GeocodeLocation *loc,
                                gdouble          altitude)
 {
-        loc->priv->altitude = altitude;
+        GeocodeLocationPrivate *priv;
+
+        priv = geocode_location_get_instance_private (loc);
+        priv->altitude = altitude;
 }
 
 static void
 geocode_location_set_accuracy (GeocodeLocation *loc,
                                gdouble          accuracy)
 {
+
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (accuracy >= GEOCODE_LOCATION_ACCURACY_UNKNOWN);
 
-        loc->priv->accuracy = accuracy;
+        priv = geocode_location_get_instance_private (loc);
+        priv->accuracy = accuracy;
 }
 
 static void
 geocode_location_set_crs(GeocodeLocation   *loc,
                          GeocodeLocationCRS crs)
 {
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (GEOCODE_IS_LOCATION (loc));
 
-        loc->priv->crs = crs;
+        priv = geocode_location_get_instance_private (loc);
+        priv->crs = crs;
 }
 
 static void
 geocode_location_set_timestamp (GeocodeLocation *loc,
                                 guint64          timestamp)
 {
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (GEOCODE_IS_LOCATION (loc));
 
-        loc->priv->timestamp = timestamp;
+        priv = geocode_location_get_instance_private (loc);
+        priv->timestamp = timestamp;
 }
 
 static void
 geocode_location_constructed (GObject *object)
 {
         GeocodeLocation *location = GEOCODE_LOCATION (object);
+        GeocodeLocationPrivate *priv;
         GTimeVal tv;
 
-        if (location->priv->timestamp != 0)
+        priv = geocode_location_get_instance_private (location);
+
+        if (priv->timestamp != 0)
                 return;
 
         g_get_current_time (&tv);
@@ -271,13 +295,16 @@ parse_geo_uri_special_parameters (GeocodeLocation *loc,
                                   const char      *params,
                                   GError         **error)
 {
+        GeocodeLocationPrivate *priv;
         char *end_ptr;
         char *next_token;
         char *description;
         char *token_end;
         int description_len;
 
-        if (loc->priv->latitude != 0 || loc->priv->longitude != 0)
+        priv = geocode_location_get_instance_private (loc);
+
+        if (priv->latitude != 0 || priv->longitude != 0)
             goto err;
 
         if (strncmp (params, "q=", 2) != 0)
@@ -285,12 +312,12 @@ parse_geo_uri_special_parameters (GeocodeLocation *loc,
 
         next_token = ((char *)params) + 2;
 
-        loc->priv->latitude = g_ascii_strtod (next_token, &end_ptr);
+        priv->latitude = g_ascii_strtod (next_token, &end_ptr);
         if (*end_ptr != ',' || *end_ptr == *params)
                 goto err;
         next_token = end_ptr + 1;
 
-        loc->priv->longitude = g_ascii_strtod (next_token, &end_ptr);
+        priv->longitude = g_ascii_strtod (next_token, &end_ptr);
         if (*end_ptr == *next_token)
                 goto err;
 
@@ -332,6 +359,7 @@ parse_geo_uri_parameters (GeocodeLocation *loc,
                           const char      *params,
                           GError         **error)
 {
+        GeocodeLocationPrivate *priv;
         char **parameters;
         char *endptr;
         char *val;
@@ -340,6 +368,7 @@ parse_geo_uri_parameters (GeocodeLocation *loc,
         int i;
         int ret = TRUE;
 
+        priv = geocode_location_get_instance_private (loc);
         parameters = g_strsplit (params, ";", 256);
         if (parameters[0] == NULL)
                 goto err;
@@ -367,7 +396,7 @@ parse_geo_uri_parameters (GeocodeLocation *loc,
 
         if (u != NULL) {
                 val = u + 2; /* len of 'u=' */
-                loc->priv->accuracy = g_ascii_strtod (val, &endptr);
+                priv->accuracy = g_ascii_strtod (val, &endptr);
                 if (*endptr != '\0' && *endptr != ';')
                         goto err;
         }
@@ -436,11 +465,13 @@ parse_geo_uri (GeocodeLocation *loc,
                const char      *uri,
                GError         **error)
 {
+        GeocodeLocationPrivate *priv;
         const char *uri_part;
         char *end_ptr;
         char *next_token;
         const char *s;
 
+        priv = geocode_location_get_instance_private (loc);
         /* bail out if we encounter whitespace in uri */
         s = uri;
         while (*s) {
@@ -451,19 +482,19 @@ parse_geo_uri (GeocodeLocation *loc,
         uri_part = (const char *) uri + strlen("geo") + 1;
 
         /* g_ascii_strtod is locale safe */
-        loc->priv->latitude = g_ascii_strtod (uri_part, &end_ptr);
+        priv->latitude = g_ascii_strtod (uri_part, &end_ptr);
         if (*end_ptr != ',' || *end_ptr == *uri_part) {
                 goto err;
         }
         next_token = end_ptr + 1;
 
-        loc->priv->longitude = g_ascii_strtod (next_token, &end_ptr);
+        priv->longitude = g_ascii_strtod (next_token, &end_ptr);
         if (*end_ptr == *next_token) {
                 goto err;
         }
         if (*end_ptr == ',') {
                 next_token = end_ptr + 1;
-                loc->priv->altitude = g_ascii_strtod (next_token, &end_ptr);
+                priv->altitude = g_ascii_strtod (next_token, &end_ptr);
                 if (*end_ptr == *next_token) {
                         goto err;
                 }
@@ -526,8 +557,10 @@ static void
 geocode_location_finalize (GObject *glocation)
 {
         GeocodeLocation *location = (GeocodeLocation *) glocation;
+        GeocodeLocationPrivate *priv;
 
-        g_clear_pointer (&location->priv->description, g_free);
+        priv = geocode_location_get_instance_private (location);
+        g_clear_pointer (&priv->description, g_free);
 
         G_OBJECT_CLASS (geocode_location_parent_class)->finalize (glocation);
 }
@@ -543,8 +576,6 @@ geocode_location_class_init (GeocodeLocationClass *klass)
         glocation_class->set_property = geocode_location_set_property;
         glocation_class->constructed = geocode_location_constructed;
 
-        g_type_class_add_private (klass, sizeof (GeocodeLocationPrivate));
-
         /**
          * GeocodeLocation:description:
          *
@@ -660,13 +691,12 @@ geocode_location_class_init (GeocodeLocationClass *klass)
 static void
 geocode_location_init (GeocodeLocation *location)
 {
-        location->priv = G_TYPE_INSTANCE_GET_PRIVATE ((location),
-                                                      GEOCODE_TYPE_LOCATION,
-                                                      GeocodeLocationPrivate);
+        GeocodeLocationPrivate *priv;
 
-        location->priv->altitude = GEOCODE_LOCATION_ALTITUDE_UNKNOWN;
-        location->priv->accuracy = GEOCODE_LOCATION_ACCURACY_UNKNOWN;
-        location->priv->crs = GEOCODE_LOCATION_CRS_WGS84;
+        priv = geocode_location_get_instance_private (location);
+        priv->altitude = GEOCODE_LOCATION_ALTITUDE_UNKNOWN;
+        priv->accuracy = GEOCODE_LOCATION_ACCURACY_UNKNOWN;
+        priv->crs = GEOCODE_LOCATION_CRS_WGS84;
 }
 
 /**
@@ -756,10 +786,12 @@ void
 geocode_location_set_description (GeocodeLocation *loc,
                                   const char      *description)
 {
+        GeocodeLocationPrivate *priv;
         g_return_if_fail (GEOCODE_IS_LOCATION (loc));
 
-        g_free (loc->priv->description);
-        loc->priv->description = g_strdup (description);
+        priv = geocode_location_get_instance_private (loc);
+        g_free (priv->description);
+        priv->description = g_strdup (description);
 }
 
 /**
@@ -773,9 +805,11 @@ geocode_location_set_description (GeocodeLocation *loc,
 const char *
 geocode_location_get_description (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc), NULL);
 
-        return loc->priv->description;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->description;
 }
 
 /**
@@ -789,9 +823,11 @@ geocode_location_get_description (GeocodeLocation *loc)
 gdouble
 geocode_location_get_latitude (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc), 0.0);
 
-        return loc->priv->latitude;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->latitude;
 }
 
 /**
@@ -805,9 +841,11 @@ geocode_location_get_latitude (GeocodeLocation *loc)
 gdouble
 geocode_location_get_longitude (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc), 0.0);
 
-        return loc->priv->longitude;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->longitude;
 }
 
 /**
@@ -821,10 +859,12 @@ geocode_location_get_longitude (GeocodeLocation *loc)
 gdouble
 geocode_location_get_altitude (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc),
                               GEOCODE_LOCATION_ALTITUDE_UNKNOWN);
 
-        return loc->priv->altitude;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->altitude;
 }
 
 /**
@@ -838,10 +878,12 @@ geocode_location_get_altitude (GeocodeLocation *loc)
 gdouble
 geocode_location_get_accuracy (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc),
                               GEOCODE_LOCATION_ACCURACY_UNKNOWN);
 
-        return loc->priv->accuracy;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->accuracy;
 }
 
 /**
@@ -855,10 +897,12 @@ geocode_location_get_accuracy (GeocodeLocation *loc)
 GeocodeLocationCRS
 geocode_location_get_crs (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc),
                               GEOCODE_LOCATION_CRS_WGS84);
 
-        return loc->priv->crs;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->crs;
 }
 
 /**
@@ -873,9 +917,11 @@ geocode_location_get_crs (GeocodeLocation *loc)
 guint64
 geocode_location_get_timestamp (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc), 0);
 
-        return loc->priv->timestamp;
+        priv = geocode_location_get_instance_private (loc);
+        return priv->timestamp;
 }
 
 static gdouble
@@ -889,6 +935,7 @@ round_coord_n (gdouble coord, guint n)
 static char *
 geo_uri_from_location (GeocodeLocation *loc)
 {
+        GeocodeLocationPrivate *priv;
         guint precision = 6; /* 0.1 meter precision */
         char *uri;
         char *coords;
@@ -901,26 +948,27 @@ geo_uri_from_location (GeocodeLocation *loc)
 
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loc), NULL);
 
+        priv = geocode_location_get_instance_private (loc);
         g_ascii_formatd (lat,
                          G_ASCII_DTOSTR_BUF_SIZE,
                          "%.6f",
-                         round_coord_n (loc->priv->latitude, precision));
+                         round_coord_n (priv->latitude, precision));
         g_ascii_formatd (lon,
                          G_ASCII_DTOSTR_BUF_SIZE,
                          "%.6f",
-                         round_coord_n (loc->priv->longitude, precision));
+                         round_coord_n (priv->longitude, precision));
 
-        if (loc->priv->altitude != GEOCODE_LOCATION_ALTITUDE_UNKNOWN) {
+        if (priv->altitude != GEOCODE_LOCATION_ALTITUDE_UNKNOWN) {
                 g_ascii_dtostr (alt, G_ASCII_DTOSTR_BUF_SIZE,
-                                loc->priv->altitude);
+                                priv->altitude);
                 coords = g_strdup_printf ("%s,%s,%s", lat, lon, alt);
         } else {
                 coords = g_strdup_printf ("%s,%s", lat, lon);
         }
 
-        if (loc->priv->accuracy != GEOCODE_LOCATION_ACCURACY_UNKNOWN) {
+        if (priv->accuracy != GEOCODE_LOCATION_ACCURACY_UNKNOWN) {
                 g_ascii_dtostr (acc, G_ASCII_DTOSTR_BUF_SIZE,
-                                loc->priv->accuracy);
+                                priv->accuracy);
                 params = g_strdup_printf (";crs=%s;u=%s", crs, acc);
         } else {
                 params = g_strdup_printf (";crs=%s", crs);
@@ -967,20 +1015,25 @@ geocode_location_to_uri (GeocodeLocation *loc,
 double
 geocode_location_get_distance_from (GeocodeLocation *loca,
                                     GeocodeLocation *locb)
-{
+{       
+        GeocodeLocationPrivate *priv_a;
+        GeocodeLocationPrivate *priv_b;
         gdouble dlat, dlon, lat1, lat2;
         gdouble a, c;
 
         g_return_val_if_fail (GEOCODE_IS_LOCATION (loca), 0.0);
         g_return_val_if_fail (GEOCODE_IS_LOCATION (locb), 0.0);
 
+        priv_a = geocode_location_get_instance_private (loca);
+        priv_b = geocode_location_get_instance_private (locb);
+
         /* Algorithm from:
          * http://www.movable-type.co.uk/scripts/latlong.html */
 
-        dlat = (locb->priv->latitude - loca->priv->latitude) * M_PI / 180.0;
-        dlon = (locb->priv->longitude - loca->priv->longitude) * M_PI / 180.0;
-        lat1 = loca->priv->latitude * M_PI / 180.0;
-        lat2 = locb->priv->latitude * M_PI / 180.0;
+        dlat = (priv_b->latitude - priv_a->latitude) * M_PI / 180.0;
+        dlon = (priv_b->longitude - priv_a->longitude) * M_PI / 180.0;
+        lat1 = priv_a->latitude * M_PI / 180.0;
+        lat2 = priv_b->latitude * M_PI / 180.0;
 
         a = sin (dlat / 2) * sin (dlat / 2) +
             sin (dlon / 2) * sin (dlon / 2) * cos (lat1) * cos (lat2);
diff --git a/geocode-glib/geocode-place.c b/geocode-glib/geocode-place.c
index 1d4760c..c4177c3 100644
--- a/geocode-glib/geocode-place.c
+++ b/geocode-glib/geocode-place.c
@@ -84,7 +84,8 @@ enum {
         PROP_OSM_TYPE
 };
 
-G_DEFINE_TYPE (GeocodePlace, geocode_place, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_CODE (GeocodePlace, geocode_place, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GeocodePlace))
 
 static void
 geocode_place_get_property (GObject    *object,
@@ -203,18 +204,19 @@ geocode_place_set_property(GObject      *object,
                            GParamSpec   *pspec)
 {
         GeocodePlace *place = GEOCODE_PLACE (object);
+        GeocodePlacePrivate *priv = geocode_place_get_instance_private (place);
 
         switch (property_id) {
         case PROP_NAME:
-                place->priv->name = g_value_dup_string (value);
+                priv->name = g_value_dup_string (value);
                 break;
 
         case PROP_PLACE_TYPE:
-                place->priv->place_type = g_value_get_enum (value);
+                priv->place_type = g_value_get_enum (value);
                 break;
 
         case PROP_LOCATION:
-                place->priv->location = g_value_dup_object (value);
+                priv->location = g_value_dup_object (value);
                 break;
 
         case PROP_STREET_ADDRESS:
@@ -271,15 +273,15 @@ geocode_place_set_property(GObject      *object,
                 break;
 
         case PROP_BBOX:
-                place->priv->bbox = g_value_dup_object (value);
+                priv->bbox = g_value_dup_object (value);
                 break;
 
         case PROP_OSM_ID:
-                place->priv->osm_id = g_value_dup_string (value);
+                priv->osm_id = g_value_dup_string (value);
                 break;
 
         case PROP_OSM_TYPE:
-                place->priv->osm_type = g_value_get_enum (value);
+                priv->osm_type = g_value_get_enum (value);
                 break;
 
         default:
@@ -292,24 +294,25 @@ static void
 geocode_place_dispose (GObject *gplace)
 {
         GeocodePlace *place = (GeocodePlace *) gplace;
-
-        g_clear_object (&place->priv->location);
-        g_clear_object (&place->priv->bbox);
-
-        g_clear_pointer (&place->priv->name, g_free);
-        g_clear_pointer (&place->priv->osm_id, g_free);
-        g_clear_pointer (&place->priv->street_address, g_free);
-        g_clear_pointer (&place->priv->street, g_free);
-        g_clear_pointer (&place->priv->building, g_free);
-        g_clear_pointer (&place->priv->postal_code, g_free);
-        g_clear_pointer (&place->priv->area, g_free);
-        g_clear_pointer (&place->priv->town, g_free);
-        g_clear_pointer (&place->priv->county, g_free);
-        g_clear_pointer (&place->priv->state, g_free);
-        g_clear_pointer (&place->priv->admin_area, g_free);
-        g_clear_pointer (&place->priv->country_code, g_free);
-        g_clear_pointer (&place->priv->country, g_free);
-        g_clear_pointer (&place->priv->continent, g_free);
+        GeocodePlacePrivate *priv = geocode_place_get_instance_private (place);
+
+        g_clear_object (&priv->location);
+        g_clear_object (&priv->bbox);
+
+        g_clear_pointer (&priv->name, g_free);
+        g_clear_pointer (&priv->osm_id, g_free);
+        g_clear_pointer (&priv->street_address, g_free);
+        g_clear_pointer (&priv->street, g_free);
+        g_clear_pointer (&priv->building, g_free);
+        g_clear_pointer (&priv->postal_code, g_free);
+        g_clear_pointer (&priv->area, g_free);
+        g_clear_pointer (&priv->town, g_free);
+        g_clear_pointer (&priv->county, g_free);
+        g_clear_pointer (&priv->state, g_free);
+        g_clear_pointer (&priv->admin_area, g_free);
+        g_clear_pointer (&priv->country_code, g_free);
+        g_clear_pointer (&priv->country, g_free);
+        g_clear_pointer (&priv->continent, g_free);
 
         G_OBJECT_CLASS (geocode_place_parent_class)->dispose (gplace);
 }
@@ -324,8 +327,6 @@ geocode_place_class_init (GeocodePlaceClass *klass)
         gplace_class->get_property = geocode_place_get_property;
         gplace_class->set_property = geocode_place_set_property;
 
-        g_type_class_add_private (klass, sizeof (GeocodePlacePrivate));
-
         /**
          * GeocodePlace:name:
          *
@@ -580,11 +581,9 @@ geocode_place_class_init (GeocodePlaceClass *klass)
 static void
 geocode_place_init (GeocodePlace *place)
 {
-        place->priv = G_TYPE_INSTANCE_GET_PRIVATE ((place),
-                                                      GEOCODE_TYPE_PLACE,
-                                                      GeocodePlacePrivate);
-        place->priv->bbox = NULL;
-        place->priv->osm_type = GEOCODE_PLACE_OSM_TYPE_UNKNOWN;
+        GeocodePlacePrivate *priv = geocode_place_get_instance_private (place);
+        priv->bbox = NULL;
+        priv->osm_type = GEOCODE_PLACE_OSM_TYPE_UNKNOWN;
 }
 
 /**
@@ -666,27 +665,32 @@ gboolean
 geocode_place_equal (GeocodePlace *a,
                      GeocodePlace *b)
 {
+        GeocodePlacePrivate *priv_a;
+        GeocodePlacePrivate *priv_b;
         g_return_val_if_fail (GEOCODE_IS_PLACE (a), FALSE);
         g_return_val_if_fail (GEOCODE_IS_PLACE (b), FALSE);
 
-        return (g_strcmp0 (a->priv->name, b->priv->name) == 0 &&
-                a->priv->place_type == b->priv->place_type &&
-                location_equal0 (a->priv->location, b->priv->location) &&
-                bbox_equal0 (a->priv->bbox, b->priv->bbox) &&
-                g_strcmp0 (a->priv->street_address, b->priv->street_address) == 0 &&
-                g_strcmp0 (a->priv->street, b->priv->street) == 0 &&
-                g_strcmp0 (a->priv->building, b->priv->building) == 0 &&
-                g_strcmp0 (a->priv->postal_code, b->priv->postal_code) == 0 &&
-                g_strcmp0 (a->priv->area, b->priv->area) == 0 &&
-                g_strcmp0 (a->priv->town, b->priv->town) == 0 &&
-                g_strcmp0 (a->priv->county, b->priv->county) == 0 &&
-                g_strcmp0 (a->priv->state, b->priv->state) == 0 &&
-                g_strcmp0 (a->priv->admin_area, b->priv->admin_area) == 0 &&
-                g_strcmp0 (a->priv->country_code, b->priv->country_code) == 0 &&
-                g_strcmp0 (a->priv->country, b->priv->country) == 0 &&
-                g_strcmp0 (a->priv->continent, b->priv->continent) == 0 &&
-                g_strcmp0 (a->priv->osm_id, b->priv->osm_id) == 0 &&
-                a->priv->osm_type == b->priv->osm_type);
+        priv_a = geocode_place_get_instance_private (a);
+        priv_b = geocode_place_get_instance_private (b);
+
+        return (g_strcmp0 (priv_a->name, priv_b->name) == 0 &&
+                priv_a->place_type == priv_b->place_type &&
+                location_equal0 (priv_a->location, priv_b->location) &&
+                bbox_equal0 (priv_a->bbox, priv_b->bbox) &&
+                g_strcmp0 (priv_a->street_address, priv_b->street_address) == 0 &&
+                g_strcmp0 (priv_a->street, priv_b->street) == 0 &&
+                g_strcmp0 (priv_a->building, priv_b->building) == 0 &&
+                g_strcmp0 (priv_a->postal_code, priv_b->postal_code) == 0 &&
+                g_strcmp0 (priv_a->area, priv_b->area) == 0 &&
+                g_strcmp0 (priv_a->town, priv_b->town) == 0 &&
+                g_strcmp0 (priv_a->county, priv_b->county) == 0 &&
+                g_strcmp0 (priv_a->state, priv_b->state) == 0 &&
+                g_strcmp0 (priv_a->admin_area, priv_b->admin_area) == 0 &&
+                g_strcmp0 (priv_a->country_code, priv_b->country_code) == 0 &&
+                g_strcmp0 (priv_a->country, priv_b->country) == 0 &&
+                g_strcmp0 (priv_a->continent, priv_b->continent) == 0 &&
+                g_strcmp0 (priv_a->osm_id, priv_b->osm_id) == 0 &&
+                priv_a->osm_type == priv_b->osm_type);
 }
 
 /**
@@ -700,11 +704,13 @@ void
 geocode_place_set_name (GeocodePlace *place,
                         const char   *name)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (name != NULL);
 
-        g_free (place->priv->name);
-        place->priv->name = g_strdup (name);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->name);
+        priv->name = g_strdup (name);
 }
 
 /**
@@ -718,9 +724,11 @@ geocode_place_set_name (GeocodePlace *place,
 const char *
 geocode_place_get_name (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->name;
+        priv = geocode_place_get_instance_private (place);
+        return priv->name;
 
 }
 
@@ -735,10 +743,12 @@ geocode_place_get_name (GeocodePlace *place)
 GeocodePlaceType
 geocode_place_get_place_type (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place),
                               GEOCODE_PLACE_TYPE_UNKNOWN);
 
-        return place->priv->place_type;
+        priv = geocode_place_get_instance_private (place);
+        return priv->place_type;
 }
 
 /**
@@ -752,11 +762,13 @@ void
 geocode_place_set_location (GeocodePlace *place,
                             GeocodeLocation *location)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (GEOCODE_IS_LOCATION (location));
 
-        g_clear_object (&place->priv->location);
-        place->priv->location = g_object_ref (location);
+        priv = geocode_place_get_instance_private (place);
+        g_clear_object (&priv->location);
+        priv->location = g_object_ref (location);
 }
 
 /**
@@ -770,9 +782,11 @@ geocode_place_set_location (GeocodePlace *place,
 GeocodeLocation *
 geocode_place_get_location (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->location;
+        priv = geocode_place_get_instance_private (place);
+        return priv->location;
 }
 
 /**
@@ -786,11 +800,14 @@ void
 geocode_place_set_street_address (GeocodePlace *place,
                                   const char   *street_address)
 {
+        GeocodePlacePrivate *priv;
+
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (street_address != NULL);
 
-        g_free (place->priv->street_address);
-        place->priv->street_address = g_strdup (street_address);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->street_address);
+        priv->street_address = g_strdup (street_address);
 }
 
 /**
@@ -804,9 +821,11 @@ geocode_place_set_street_address (GeocodePlace *place,
 const char *
 geocode_place_get_street_address (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->street_address;
+        priv = geocode_place_get_instance_private (place);
+        return priv->street_address;
 }
 
 /**
@@ -820,11 +839,14 @@ void
 geocode_place_set_street (GeocodePlace *place,
                           const char   *street)
 {
+        GeocodePlacePrivate *priv;
+
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (street != NULL);
 
-        g_free (place->priv->street);
-        place->priv->street = g_strdup (street);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->street);
+        priv->street = g_strdup (street);
 }
 
 /**
@@ -838,9 +860,11 @@ geocode_place_set_street (GeocodePlace *place,
 const char *
 geocode_place_get_street (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->street;
+        priv = geocode_place_get_instance_private (place);
+        return priv->street;
 }
 
 /**
@@ -854,11 +878,13 @@ void
 geocode_place_set_building (GeocodePlace *place,
                             const char   *building)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (building != NULL);
 
-        g_free (place->priv->building);
-        place->priv->building = g_strdup (building);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->building);
+        priv->building = g_strdup (building);
 }
 
 /**
@@ -872,9 +898,11 @@ geocode_place_set_building (GeocodePlace *place,
 const char *
 geocode_place_get_building (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->building;
+        priv = geocode_place_get_instance_private (place);
+        return priv->building;
 }
 
 /**
@@ -888,11 +916,13 @@ void
 geocode_place_set_postal_code (GeocodePlace *place,
                                const char   *postal_code)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (postal_code != NULL);
 
-        g_free (place->priv->postal_code);
-        place->priv->postal_code = g_strdup (postal_code);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->postal_code);
+        priv->postal_code = g_strdup (postal_code);
 }
 
 /**
@@ -906,9 +936,11 @@ geocode_place_set_postal_code (GeocodePlace *place,
 const char *
 geocode_place_get_postal_code (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->postal_code;
+        priv = geocode_place_get_instance_private (place);
+        return priv->postal_code;
 }
 
 /**
@@ -922,11 +954,13 @@ void
 geocode_place_set_area (GeocodePlace *place,
                         const char   *area)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (area != NULL);
 
-        g_free (place->priv->area);
-        place->priv->area = g_strdup (area);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->area);
+        priv->area = g_strdup (area);
 }
 
 /**
@@ -940,9 +974,11 @@ geocode_place_set_area (GeocodePlace *place,
 const char *
 geocode_place_get_area (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->area;
+        priv = geocode_place_get_instance_private (place);
+        return priv->area;
 }
 
 /**
@@ -956,11 +992,14 @@ void
 geocode_place_set_town (GeocodePlace *place,
                         const char   *town)
 {
+        GeocodePlacePrivate *priv;
+
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (town != NULL);
 
-        g_free (place->priv->town);
-        place->priv->town = g_strdup (town);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->town);
+        priv->town = g_strdup (town);
 }
 
 /**
@@ -974,9 +1013,11 @@ geocode_place_set_town (GeocodePlace *place,
 const char *
 geocode_place_get_town (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->town;
+        priv = geocode_place_get_instance_private (place);
+        return priv->town;
 }
 
 /**
@@ -990,11 +1031,13 @@ void
 geocode_place_set_county (GeocodePlace *place,
                           const char   *county)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (county != NULL);
 
-        g_free (place->priv->county);
-        place->priv->county = g_strdup (county);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->county);
+        priv->county = g_strdup (county);
 }
 
 /**
@@ -1008,9 +1051,11 @@ geocode_place_set_county (GeocodePlace *place,
 const char *
 geocode_place_get_county (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->county;
+        priv = geocode_place_get_instance_private (place);
+        return priv->county;
 }
 
 /**
@@ -1024,11 +1069,13 @@ void
 geocode_place_set_state (GeocodePlace *place,
                          const char   *state)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (state != NULL);
 
-        g_free (place->priv->state);
-        place->priv->state = g_strdup (state);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->state);
+        priv->state = g_strdup (state);
 }
 
 /**
@@ -1042,9 +1089,11 @@ geocode_place_set_state (GeocodePlace *place,
 const char *
 geocode_place_get_state (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->state;
+        priv = geocode_place_get_instance_private (place);
+        return priv->state;
 }
 
 /**
@@ -1058,11 +1107,13 @@ void
 geocode_place_set_administrative_area (GeocodePlace *place,
                                        const char   *admin_area)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (admin_area != NULL);
 
-        g_free (place->priv->admin_area);
-        place->priv->admin_area = g_strdup (admin_area);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->admin_area);
+        priv->admin_area = g_strdup (admin_area);
 }
 
 /**
@@ -1076,9 +1127,11 @@ geocode_place_set_administrative_area (GeocodePlace *place,
 const char *
 geocode_place_get_administrative_area (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->admin_area;
+        priv = geocode_place_get_instance_private (place);
+        return priv->admin_area;
 }
 
 /**
@@ -1092,11 +1145,13 @@ void
 geocode_place_set_country_code (GeocodePlace *place,
                                 const char   *country_code)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (country_code != NULL);
 
-        g_free (place->priv->country_code);
-        place->priv->country_code = g_utf8_strup (country_code, -1);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->country_code);
+        priv->country_code = g_utf8_strup (country_code, -1);
 }
 
 /**
@@ -1109,10 +1164,12 @@ geocode_place_set_country_code (GeocodePlace *place,
  **/
 const char *
 geocode_place_get_country_code (GeocodePlace *place)
-{
+{       
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->country_code;
+        priv = geocode_place_get_instance_private (place);
+        return priv->country_code;
 }
 
 /**
@@ -1126,11 +1183,13 @@ void
 geocode_place_set_country (GeocodePlace *place,
                            const char   *country)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (country != NULL);
 
-        g_free (place->priv->country);
-        place->priv->country = g_strdup (country);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->country);
+        priv->country = g_strdup (country);
 }
 
 /**
@@ -1144,9 +1203,11 @@ geocode_place_set_country (GeocodePlace *place,
 const char *
 geocode_place_get_country (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->country;
+        priv = geocode_place_get_instance_private (place);
+        return priv->country;
 }
 
 /**
@@ -1160,11 +1221,13 @@ void
 geocode_place_set_continent (GeocodePlace *place,
                              const char   *continent)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (continent != NULL);
 
-        g_free (place->priv->continent);
-        place->priv->continent = g_strdup (continent);
+        priv = geocode_place_get_instance_private (place);
+        g_free (priv->continent);
+        priv->continent = g_strdup (continent);
 }
 
 /**
@@ -1178,15 +1241,18 @@ geocode_place_set_continent (GeocodePlace *place,
 const char *
 geocode_place_get_continent (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->continent;
+        priv = geocode_place_get_instance_private (place);
+        return priv->continent;
 }
 
 static const char *
 get_icon_name (GeocodePlace *place)
 {
-        switch ((int) place->priv->place_type) {
+        GeocodePlacePrivate *priv = geocode_place_get_instance_private (place);
+        switch ((int) priv->place_type) {
         case GEOCODE_PLACE_TYPE_BUILDING:
                 return "poi-building";
 
@@ -1257,9 +1323,11 @@ geocode_place_get_icon (GeocodePlace *place)
 GeocodeBoundingBox *
 geocode_place_get_bounding_box (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->bbox;
+        priv = geocode_place_get_instance_private (place);
+        return priv->bbox;
 }
 
 /**
@@ -1274,11 +1342,13 @@ void
 geocode_place_set_bounding_box (GeocodePlace       *place,
                                 GeocodeBoundingBox *bbox)
 {
+        GeocodePlacePrivate *priv;
         g_return_if_fail (GEOCODE_IS_PLACE (place));
         g_return_if_fail (GEOCODE_IS_BOUNDING_BOX (bbox));
 
-        g_clear_object (&place->priv->bbox);
-        place->priv->bbox = g_object_ref (bbox);
+        priv = geocode_place_get_instance_private (place);
+        g_clear_object (&priv->bbox);
+        priv->bbox = g_object_ref (bbox);
 }
 
 /**
@@ -1292,9 +1362,11 @@ geocode_place_set_bounding_box (GeocodePlace       *place,
 const char *
 geocode_place_get_osm_id (GeocodePlace *place)
 {
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), NULL);
 
-        return place->priv->osm_id;
+        priv = geocode_place_get_instance_private (place);
+        return priv->osm_id;
 }
 
 /**
@@ -1307,8 +1379,10 @@ geocode_place_get_osm_id (GeocodePlace *place)
  **/
 GeocodePlaceOsmType
 geocode_place_get_osm_type (GeocodePlace *place)
-{
+{       
+        GeocodePlacePrivate *priv;
         g_return_val_if_fail (GEOCODE_IS_PLACE (place), GEOCODE_PLACE_OSM_TYPE_UNKNOWN);
 
-        return place->priv->osm_type;
+        priv = geocode_place_get_instance_private (place);
+        return priv->osm_type;
 }
diff --git a/geocode-glib/geocode-reverse.c b/geocode-glib/geocode-reverse.c
index 4bfe0ea..29cf733 100644
--- a/geocode-glib/geocode-reverse.c
+++ b/geocode-glib/geocode-reverse.c
@@ -47,15 +47,19 @@ struct _GeocodeReversePrivate {
 	GeocodeBackend  *backend;
 };
 
-G_DEFINE_TYPE (GeocodeReverse, geocode_reverse, G_TYPE_OBJECT)
+G_DEFINE_TYPE_WITH_CODE (GeocodeReverse, geocode_reverse, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GeocodeReverse))
 
 static void
 geocode_reverse_finalize (GObject *gobject)
 {
 	GeocodeReverse *object = (GeocodeReverse *) gobject;
+	GeocodeReversePrivate *priv;
 
-	g_clear_object (&object->priv->location);
-	g_clear_object (&object->priv->backend);
+	priv = geocode_reverse_get_instance_private (object);
+
+	g_clear_object (&priv->location);
+	g_clear_object (&priv->backend);
 
 	G_OBJECT_CLASS (geocode_reverse_parent_class)->finalize (gobject);
 }
@@ -69,14 +73,11 @@ geocode_reverse_class_init (GeocodeReverseClass *klass)
 	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 
 	gobject_class->finalize = geocode_reverse_finalize;
-
-	g_type_class_add_private (klass, sizeof (GeocodeReversePrivate));
 }
 
 static void
 geocode_reverse_init (GeocodeReverse *object)
 {
-	object->priv = G_TYPE_INSTANCE_GET_PRIVATE ((object), GEOCODE_TYPE_REVERSE, GeocodeReversePrivate);
 }
 
 /**
@@ -92,11 +93,13 @@ GeocodeReverse *
 geocode_reverse_new_for_location (GeocodeLocation *location)
 {
 	GeocodeReverse *object;
+	GeocodeReversePrivate *priv;
 
 	g_return_val_if_fail (GEOCODE_IS_LOCATION (location), NULL);
 
 	object = g_object_new (GEOCODE_TYPE_REVERSE, NULL);
-	object->priv->location = g_object_ref (location);
+	priv = geocode_reverse_get_instance_private (object);
+	priv->location = g_object_ref (location);
 
 	return object;
 }
@@ -104,9 +107,12 @@ geocode_reverse_new_for_location (GeocodeLocation *location)
 static void
 ensure_backend (GeocodeReverse *object)
 {
+	GeocodeReversePrivate *priv;
+
+	priv = geocode_reverse_get_instance_private (object);
 	/* If no backend is specified, default to the GNOME Nominatim backend */
-	if (object->priv->backend == NULL)
-		object->priv->backend = GEOCODE_BACKEND (geocode_nominatim_get_gnome ());
+	if (priv->backend == NULL)
+		priv->backend = GEOCODE_BACKEND (geocode_nominatim_get_gnome ());
 }
 
 static GValue *
@@ -190,18 +196,20 @@ geocode_reverse_resolve_async (GeocodeReverse     *object,
                                gpointer            user_data)
 {
 	GTask *task;
+	GeocodeReversePrivate *priv;
 	g_autoptr (GHashTable) params = NULL;
 
 	g_return_if_fail (GEOCODE_IS_REVERSE (object));
 	g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
 
 	ensure_backend (object);
-	g_assert (object->priv->backend != NULL);
+	priv = geocode_reverse_get_instance_private (object);
+	g_assert (priv->backend != NULL);
 
-	params = _geocode_location_to_params (object->priv->location);
+	params = _geocode_location_to_params (priv->location);
 
 	task = g_task_new (object, cancellable, callback, user_data);
-	geocode_backend_reverse_resolve_async (object->priv->backend,
+	geocode_backend_reverse_resolve_async (priv->backend,
 	                                       params,
 	                                       cancellable,
 	                                       (GAsyncReadyCallback) backend_reverse_resolve_ready,
@@ -253,6 +261,7 @@ GeocodePlace *
 geocode_reverse_resolve (GeocodeReverse *object,
                          GError        **error)
 {
+	GeocodeReversePrivate *priv;
 	GList *places = NULL;  /* (element-type GeocodePlace) */
 	GeocodePlace *place = NULL;
 	g_autoptr (GHashTable) params = NULL;
@@ -260,11 +269,12 @@ geocode_reverse_resolve (GeocodeReverse *object,
 	g_return_val_if_fail (GEOCODE_IS_REVERSE (object), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
+	priv = geocode_reverse_get_instance_private (object);
 	ensure_backend (object);
-	g_assert (object->priv->backend != NULL);
+	g_assert (priv->backend != NULL);
 
-	params = _geocode_location_to_params (object->priv->location);
-	places = geocode_backend_reverse_resolve (object->priv->backend,
+	params = _geocode_location_to_params (priv->location);
+	places = geocode_backend_reverse_resolve (priv->backend,
 	                                          params,
 	                                          NULL,
 	                                          error);
@@ -292,8 +302,12 @@ void
 geocode_reverse_set_backend (GeocodeReverse *object,
                              GeocodeBackend *backend)
 {
+	GeocodeReversePrivate *priv;
+
 	g_return_if_fail (GEOCODE_IS_REVERSE (object));
 	g_return_if_fail (backend == NULL || GEOCODE_IS_BACKEND (backend));
 
-	g_set_object (&object->priv->backend, backend);
+	priv = geocode_reverse_get_instance_private (object);
+
+	g_set_object (&priv->backend, backend);
 }