Dive site: return pointer to dive_site in get_dive_site_*()

As a first step in removing dive-site uuids, change the interface
of the get_dive_site_*() functions to return pointers instead
of uuids. This makes code a bit more complicated in places where
the uuid is extracted afterwards (needed NULL check). Nevertheless,
these places should disappear once pointers instead of uuids are
stored in the dive-structures.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>

7 files changed, 53 insertions, 63 deletions

diff --git a/core/datatrak.c b/core/datatrak.c
index 582fb512f..dbc79534c 100644
--- a/core/datatrak.c
+++ b/core/datatrak.c
@@ -156,6 +156,7 @@ unsigned char *dt_dive_parser(unsigned char *runner, struct dive *dt_dive)
 		      *compl_buffer,
 		      *membuf = runner;
 	char buffer[1024];
+	struct dive_site *ds;
 	device_data_t *devdata = calloc(1, sizeof(device_data_t));
 
 	/*
@@ -200,7 +201,8 @@ unsigned char *dt_dive_parser(unsigned char *runner, struct dive *dt_dive)
 	 * Locality and Dive points.
 	 */
 	snprintf(buffer, sizeof(buffer), "%s, %s", locality, dive_point);
-	dt_dive->dive_site_uuid = get_dive_site_uuid_by_name(buffer, NULL);
+	ds = get_dive_site_by_name(buffer);
+	dt_dive->dive_site_uuid = ds ? ds->uuid : 0;
 	if (dt_dive->dive_site_uuid == 0)
 		dt_dive->dive_site_uuid = create_dive_site(buffer, dt_dive->when);
 	free(locality);
diff --git a/core/divesite.c b/core/divesite.c
index ee394d9d1..bef505814 100644
--- a/core/divesite.c
+++ b/core/divesite.c
@@ -11,47 +11,41 @@
 struct dive_site_table dive_site_table;
 
 /* there could be multiple sites of the same name - return the first one */
-uint32_t get_dive_site_uuid_by_name(const char *name, struct dive_site **dsp)
+struct dive_site *get_dive_site_by_name(const char *name)
 {
 	int i;
 	struct dive_site *ds;
 	for_each_dive_site (i, ds) {
-		if (same_string(ds->name, name)) {
-			if (dsp)
-				*dsp = ds;
-			return ds->uuid;
-		}
+		if (same_string(ds->name, name))
+			return ds;
 	}
-	return 0;
+	return NULL;
 }
 
 /* there could be multiple sites at the same GPS fix - return the first one */
-uint32_t get_dive_site_uuid_by_gps(const location_t *loc, struct dive_site **dsp)
+struct dive_site *get_dive_site_by_gps(const location_t *loc)
 {
 	int i;
 	struct dive_site *ds;
 	for_each_dive_site (i, ds) {
-		if (same_location(loc, &ds->location)) {
-			if (dsp)
-				*dsp = ds;
-			return ds->uuid;
-		}
+		if (same_location(loc, &ds->location))
+			return ds;
 	}
-	return 0;
+	return NULL;
 }
 
 /* to avoid a bug where we have two dive sites with different name and the same GPS coordinates
  * and first get the gps coordinates (reading a V2 file) and happen to get back "the other" name,
  * this function allows us to verify if a very specific name/GPS combination already exists */
-uint32_t get_dive_site_uuid_by_gps_and_name(char *name, const location_t *loc)
+struct dive_site *get_dive_site_by_gps_and_name(char *name, const location_t *loc)
 {
 	int i;
 	struct dive_site *ds;
 	for_each_dive_site (i, ds) {
 		if (same_location(loc, &ds->location) && same_string(ds->name, name))
-			return ds->uuid;
+			return ds;
 	}
-	return 0;
+	return NULL;
 }
 
 // Calculate the distance in meters between two coordinates.
@@ -70,22 +64,19 @@ unsigned int get_distance(const location_t *loc1, const location_t *loc2)
 }
 
 /* find the closest one, no more than distance meters away - if more than one at same distance, pick the first */
-uint32_t get_dive_site_uuid_by_gps_proximity(const location_t *loc, int distance, struct dive_site **dsp)
+struct dive_site *get_dive_site_by_gps_proximity(const location_t *loc, int distance)
 {
 	int i;
-	int uuid = 0;
-	struct dive_site *ds;
+	struct dive_site *ds, *res = NULL;
 	unsigned int cur_distance, min_distance = distance;
 	for_each_dive_site (i, ds) {
 		if (dive_site_has_gps_location(ds) &&
 		    (cur_distance = get_distance(&ds->location, loc)) < min_distance) {
 			min_distance = cur_distance;
-			uuid = ds->uuid;
-			if (dsp)
-				*dsp = ds;
+			res = ds;
 		}
 	}
-	return uuid;
+	return res;
 }
 
 /* try to create a uniqe ID - fingers crossed */
diff --git a/core/divesite.h b/core/divesite.h
index d739c4520..d9e2881e4 100644
--- a/core/divesite.h
+++ b/core/divesite.h
@@ -61,10 +61,10 @@ void delete_dive_site(uint32_t id);
 uint32_t create_dive_site(const char *name, timestamp_t divetime);
 uint32_t create_dive_site_from_current_dive(const char *name);
 uint32_t create_dive_site_with_gps(const char *name, const location_t *, timestamp_t divetime);
-uint32_t get_dive_site_uuid_by_name(const char *name, struct dive_site **dsp);
-uint32_t get_dive_site_uuid_by_gps(const location_t *, struct dive_site **dsp);
-uint32_t get_dive_site_uuid_by_gps_and_name(char *name, const location_t *);
-uint32_t get_dive_site_uuid_by_gps_proximity(const location_t *, int distance, struct dive_site **dsp);
+struct dive_site *get_dive_site_by_name(const char *name);
+struct dive_site *get_dive_site_by_gps(const location_t *);
+struct dive_site *get_dive_site_by_gps_and_name(char *name, const location_t *);
+struct dive_site *get_dive_site_by_gps_proximity(const location_t *, int distance);
 bool dive_site_is_empty(struct dive_site *ds);
 void copy_dive_site_taxonomy(struct dive_site *orig, struct dive_site *copy);
 void copy_dive_site(struct dive_site *orig, struct dive_site *copy);
diff --git a/core/load-git.c b/core/load-git.c
index 2040d2f70..f040f9de6 100644
--- a/core/load-git.c
+++ b/core/load-git.c
@@ -151,17 +151,17 @@ static int get_hex(const char *line)
 static void parse_dive_gps(char *line, struct membuffer *str, void *_dive)
 {
 	UNUSED(str);
-	uint32_t uuid;
 	location_t location;
 	struct dive *dive = _dive;
 	struct dive_site *ds = get_dive_site_for_dive(dive);
 
 	parse_location(line, &location);
 	if (!ds) {
-		uuid = get_dive_site_uuid_by_gps(&location, NULL);
-		if (!uuid)
-			uuid = create_dive_site_with_gps("", &location, dive->when);
-		dive->dive_site_uuid = uuid;
+		ds = get_dive_site_by_gps(&location);
+		if (!ds)
+			dive->dive_site_uuid = create_dive_site_with_gps("", &location, dive->when);
+		else
+			dive->dive_site_uuid = ds->uuid;
 	} else {
 		if (dive_site_has_gps_location(ds) && !same_location(&ds->location, &location)) {
 			const char *coords = printGPSCoords(&location);
@@ -177,15 +177,15 @@ static void parse_dive_gps(char *line, struct membuffer *str, void *_dive)
 static void parse_dive_location(char *line, struct membuffer *str, void *_dive)
 {
 	UNUSED(line);
-	uint32_t uuid;
 	char *name = get_utf8(str);
 	struct dive *dive = _dive;
 	struct dive_site *ds = get_dive_site_for_dive(dive);
 	if (!ds) {
-		uuid = get_dive_site_uuid_by_name(name, NULL);
-		if (!uuid)
-			uuid = create_dive_site(name, dive->when);
-		dive->dive_site_uuid = uuid;
+		ds = get_dive_site_by_name(name);
+		if (!ds)
+			dive->dive_site_uuid = create_dive_site(name, dive->when);
+		else
+			dive->dive_site_uuid = ds->uuid;
 	} else {
 		// we already had a dive site linked to the dive
 		if (empty_string(ds->name)) {
diff --git a/core/parse-xml.c b/core/parse-xml.c
index 19a002568..c1d9fc2d5 100644
--- a/core/parse-xml.c
+++ b/core/parse-xml.c
@@ -968,6 +968,7 @@ static void try_to_fill_sample(struct sample *sample, const char *name, char *bu
 static void divinglog_place(char *place, uint32_t *uuid, struct parser_state *state)
 {
 	char buffer[1024];
+	struct dive_site *ds;
 
 	snprintf(buffer, sizeof(buffer),
 		 "%s%s%s%s%s",
@@ -976,8 +977,10 @@ static void divinglog_place(char *place, uint32_t *uuid, struct parser_state *st
 		 state->city ? state->city : "",
 		 state->country ? ", " : "",
 		 state->country ? state->country : "");
-	*uuid = get_dive_site_uuid_by_name(buffer, NULL);
-	if (*uuid == 0)
+	ds = get_dive_site_by_name(buffer);
+	if (ds)
+		*uuid = ds->uuid;
+	else
 		*uuid = create_dive_site(buffer, state->cur_dive->when);
 
 	// TODO: capture the country / city info in the taxonomy instead
@@ -1178,16 +1181,15 @@ static void gps_in_dive(char *buffer, struct dive *dive, struct parser_state *st
 	parse_location(buffer, &location);
 	if (uuid == 0) {
 		// check if we have a dive site within 20 meters of that gps fix
-		uuid = get_dive_site_uuid_by_gps_proximity(&location, 20, &ds);
+		ds = get_dive_site_by_gps_proximity(&location, 20);
 
 		if (ds) {
 			// found a site nearby; in case it turns out this one had a different name let's
 			// remember the original coordinates so we can create the correct dive site later
 			state->cur_location = location;
-			dive->dive_site_uuid = uuid;
+			dive->dive_site_uuid = ds->uuid;
 		} else {
 			dive->dive_site_uuid = create_dive_site_with_gps("", &location, dive->when);
-			ds = get_dive_site_by_uuid(dive->dive_site_uuid);
 		}
 	} else {
 		ds = get_dive_site_by_uuid(uuid);
diff --git a/core/parse.c b/core/parse.c
index bfb46e8a4..c0d127d0b 100644
--- a/core/parse.c
+++ b/core/parse.c
@@ -417,16 +417,10 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
 	char *to_free = NULL;
 	int size = trimspace(buffer);
 	if(size) {
-		uint32_t uuid = dive->dive_site_uuid;
-		struct dive_site *ds = get_dive_site_by_uuid(uuid);
-		if (uuid && !ds) {
-			// that's strange - we have a uuid but it doesn't exist - let's just ignore it
-			fprintf(stderr, "dive contains a non-existing dive site uuid %x\n", dive->dive_site_uuid);
-			uuid = 0;
-		}
-		if (!uuid) {
+		struct dive_site *ds = get_dive_site_by_uuid(dive->dive_site_uuid);
+		if (!ds) {
 			// if the dive doesn't have a uuid, check if there's already a dive site by this name
-			uuid = get_dive_site_uuid_by_name(buffer, &ds);
+			ds = get_dive_site_by_name(buffer);
 		}
 		if (ds) {
 			// we have a uuid, let's hope there isn't a different name
@@ -437,9 +431,9 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
 				// but wait, we could have gotten this one based on GPS coords and could
 				// have had two different names for the same site... so let's search the other
 				// way around
-				uint32_t exact_match_uuid = get_dive_site_uuid_by_gps_and_name(buffer, &ds->location);
-				if (exact_match_uuid) {
-					dive->dive_site_uuid = exact_match_uuid;
+				struct dive_site *exact_match = get_dive_site_by_gps_and_name(buffer, &ds->location);
+				if (exact_match) {
+					dive->dive_site_uuid = exact_match->uuid;
 				} else {
 					dive->dive_site_uuid = create_dive_site(buffer, dive->when);
 					struct dive_site *newds = get_dive_site_by_uuid(dive->dive_site_uuid);
@@ -453,7 +447,7 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state)
 				}
 			} else {
 				// add the existing dive site to the current dive
-				dive->dive_site_uuid = uuid;
+				dive->dive_site_uuid = ds->uuid;
 			}
 		} else {
 			dive->dive_site_uuid = create_dive_site(buffer, dive->when);
diff --git a/core/uemis-downloader.c b/core/uemis-downloader.c
index 18d8c280e..d80201fb5 100644
--- a/core/uemis-downloader.c
+++ b/core/uemis-downloader.c
@@ -124,15 +124,15 @@ static bool is_divespot_mappable(int divespot_id)
 	return false;
 }
 
-static uint32_t get_dive_site_uuid_by_divespot_id(int divespot_id)
+static struct dive_site *get_dive_site_by_divespot_id(int divespot_id)
 {
 	struct divespot_mapping *dm = divespot_mapping;
 	while (dm) {
 		if (dm->divespot_id == divespot_id)
-			return dm->dive_site_uuid;
+			return get_dive_site_by_uuid(dm->dive_site_uuid);
 		dm = dm->next;
 	}
-	return 0;
+	return NULL;
 }
 
 /* helper function to parse the Uemis data structures */
@@ -1177,18 +1177,19 @@ static void get_uemis_divespot(const char *mountpath, int divespot_id, struct di
 	struct dive_site *nds = get_dive_site_by_uuid(dive->dive_site_uuid);
 	
 	if (is_divespot_mappable(divespot_id)) {
-		dive->dive_site_uuid = get_dive_site_uuid_by_divespot_id(divespot_id);
+		struct dive_site *ds = get_dive_site_by_divespot_id(divespot_id);
+		dive->dive_site_uuid = ds ? ds->uuid : 0;
 	} else if (nds && nds->name && strstr(nds->name,"from Uemis")) {
 		if (load_uemis_divespot(mountpath, divespot_id)) {
 			/* get the divesite based on the diveid, this should give us
 			* the newly created site
 			*/
-			struct dive_site *ods = NULL;
+			struct dive_site *ods;
 			/* with the divesite name we got from parse_dive, that is called on load_uemis_divespot
 			 * we search all existing divesites if we have one with the same name already. The function
 			 * returns the first found which is luckily not the newly created.
 			 */
-			(void)get_dive_site_uuid_by_name(nds->name, &ods);
+			ods = get_dive_site_by_name(nds->name);
 			if (ods) {
 				/* if the uuid's are the same, the new site is a duplicate and can be deleted */
 				if (nds->uuid != ods->uuid) {