[geocode-glib/bilelmoussaoui/deprecated-api: 1/2] stop using g_type_class_add_private
- From: Bilal Elmoussaoui <bilelmoussaoui src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [geocode-glib/bilelmoussaoui/deprecated-api: 1/2] stop using g_type_class_add_private
- Date: Fri, 14 Jan 2022 15:07:06 +0000 (UTC)
commit 4a74a068d0908c7eaaadadd2297d6e47261b330c
Author: Bilal Elmoussaoui <bil elmoussaoui gmail com>
Date: Fri Jan 14 15:05:08 2022 +0100
stop using g_type_class_add_private
It was deprecated, replace it with using G_DEFINE_TYPE_WITH_CODE macro
geocode-glib/geocode-bounding-box.c | 55 ++++---
geocode-glib/geocode-forward.c | 92 +++++++-----
geocode-glib/geocode-location.c | 155 +++++++++++++-------
geocode-glib/geocode-place.c | 276 +++++++++++++++++++++++-------------
geocode-glib/geocode-reverse.c | 46 +++---
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);
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
