mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

Dive site: add dive site table parameter to dive site functions

Browse source 
To enable undo of dive site functions, it is crucial to work
with different dive site tables. Therefore add a dive site table
parameter to dive site functions. For now, always pass the global
dive site table. Thus, this commit shouldn't alter any functionality.

After this change, a simple search for dive_site_table reveals all
places where the global dive site table is accessed.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2019-02-26 22:26:11 +01:00 • committed by Dirk Hohndel
parent 36644dc9f7
commit f6e7bdc5ef
22 changed files with 118 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

88
core/divesite.c
View file

@ -10,35 +10,35 @@
struct dive_site_table dive_site_table;
int get_divesite_idx(const struct dive_site *ds)
int get_divesite_idx(const struct dive_site *ds, struct dive_site_table *ds_table)
{
int i;
const struct dive_site *d;
// tempting as it may be, don't die when called with dive=NULL
if (ds)
for_each_dive_site(i, d) {
for_each_dive_site(i, d, ds_table) {
if (d->uuid == ds->uuid) // don't compare pointers, we could be passing in a copy of the dive
return i;
}
return -1;
}
struct dive_site *get_dive_site_by_uuid(uint32_t uuid)
struct dive_site *get_dive_site_by_uuid(uint32_t uuid, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;
for_each_dive_site (i, ds)
for_each_dive_site (i, ds, ds_table)
if (ds->uuid == uuid)
return get_dive_site(i);
return get_dive_site(i, ds_table);
return NULL;
}
/* there could be multiple sites of the same name - return the first one */
struct dive_site *get_dive_site_by_name(const char *name)
struct dive_site *get_dive_site_by_name(const char *name, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;
for_each_dive_site (i, ds) {
for_each_dive_site (i, ds, ds_table) {
if (same_string(ds->name, name))
return ds;
}
@ -46,11 +46,11 @@ struct dive_site *get_dive_site_by_name(const char *name)
}
/* there could be multiple sites at the same GPS fix - return the first one */
struct dive_site *get_dive_site_by_gps(const location_t *loc)
struct dive_site *get_dive_site_by_gps(const location_t *loc, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;
for_each_dive_site (i, ds) {
for_each_dive_site (i, ds, ds_table) {
if (same_location(loc, &ds->location))
return ds;
}
@ -60,11 +60,11 @@ struct dive_site *get_dive_site_by_gps(const location_t *loc)
/* 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 */
struct dive_site *get_dive_site_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, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;
for_each_dive_site (i, ds) {
for_each_dive_site (i, ds, ds_table) {
if (same_location(loc, &ds->location) && same_string(ds->name, name))
return ds;
}
@ -87,12 +87,12 @@ 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 */
struct dive_site *get_dive_site_by_gps_proximity(const location_t *loc, int distance)
struct dive_site *get_dive_site_by_gps_proximity(const location_t *loc, int distance, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds, *res = NULL;
unsigned int cur_distance, min_distance = distance;
for_each_dive_site (i, ds) {
for_each_dive_site (i, ds, ds_table) {
if (dive_site_has_gps_location(ds) &&
(cur_distance = get_distance(&ds->location, loc)) < min_distance) {
min_distance = cur_distance;
@ -103,11 +103,11 @@ struct dive_site *get_dive_site_by_gps_proximity(const location_t *loc, int dist
}
/* try to create a uniqe ID - fingers crossed */
static uint32_t dive_site_getUniqId()
static uint32_t dive_site_getUniqId(struct dive_site_table *ds_table)
{
uint32_t id = 0;
while (id == 0 || get_dive_site_by_uuid(id)) {
while (id == 0 || get_dive_site_by_uuid(id, ds_table)) {
id = rand() & 0xff;
id |= (rand() & 0xff) << 8;
id |= (rand() & 0xff) << 16;
@ -118,30 +118,30 @@ static uint32_t dive_site_getUniqId()
}
/* we never allow a second dive site with the same uuid */
struct dive_site *alloc_or_get_dive_site(uint32_t uuid)
struct dive_site *alloc_or_get_dive_site(uint32_t uuid, struct dive_site_table *ds_table)
{
struct dive_site *ds;
if (uuid && (ds = get_dive_site_by_uuid(uuid)) != NULL)
if (uuid && (ds = get_dive_site_by_uuid(uuid, ds_table)) != NULL)
return ds;
int nr = dive_site_table.nr;
int allocated = dive_site_table.allocated;
struct dive_site **sites = dive_site_table.dive_sites;
int nr = ds_table->nr;
int allocated = ds_table->allocated;
struct dive_site **sites = ds_table->dive_sites;
if (nr >= allocated) {
allocated = (nr + 32) * 3 / 2;
sites = realloc(sites, allocated * sizeof(struct dive_site *));
if (!sites)
exit(1);
dive_site_table.dive_sites = sites;
dive_site_table.allocated = allocated;
ds_table->dive_sites = sites;
ds_table->allocated = allocated;
}
ds = calloc(1, sizeof(*ds));
if (!ds)
exit(1);
sites[nr] = ds;
dive_site_table.nr = nr + 1;
ds_table->nr = nr + 1;
// we should always be called with a valid uuid except in the special
// case where we want to copy a dive site into the memory we allocated
// here - then we need to pass in 0 and create a temporary uuid here
@ -149,7 +149,7 @@ struct dive_site *alloc_or_get_dive_site(uint32_t uuid)
if (uuid)
ds->uuid = uuid;
else
ds->uuid = dive_site_getUniqId();
ds->uuid = dive_site_getUniqId(ds_table);
return ds;
}
@ -195,17 +195,17 @@ void free_dive_site(struct dive_site *ds)
}
}
void delete_dive_site(struct dive_site *ds)
void delete_dive_site(struct dive_site *ds, struct dive_site_table *ds_table)
{
int nr = dive_site_table.nr;
int nr = ds_table->nr;
for (int i = 0; i < nr; i++) {
if (ds == get_dive_site(i)) {
if (ds == get_dive_site(i, ds_table)) {
free_dive_site(ds);
if (nr - 1 > i)
memmove(&dive_site_table.dive_sites[i],
&dive_site_table.dive_sites[i+1],
(nr - 1 - i) * sizeof(dive_site_table.dive_sites[0]));
dive_site_table.nr = nr - 1;
memmove(&ds_table->dive_sites[i],
&ds_table->dive_sites[i+1],
(nr - 1 - i) * sizeof(ds_table->dive_sites[0]));
ds_table->nr = nr - 1;
break;
}
}
@ -229,19 +229,19 @@ static uint32_t create_divesite_uuid(const char *name, timestamp_t divetime)
}
/* allocate a new site and add it to the table */
struct dive_site *create_dive_site(const char *name, timestamp_t divetime)
struct dive_site *create_dive_site(const char *name, timestamp_t divetime, struct dive_site_table *ds_table)
{
uint32_t uuid = create_divesite_uuid(name, divetime);
struct dive_site *ds = alloc_or_get_dive_site(uuid);
struct dive_site *ds = alloc_or_get_dive_site(uuid, ds_table);
ds->name = copy_string(name);
return ds;
}
/* same as before, but with GPS data */
struct dive_site *create_dive_site_with_gps(const char *name, const location_t *loc, timestamp_t divetime)
struct dive_site *create_dive_site_with_gps(const char *name, const location_t *loc, timestamp_t divetime, struct dive_site_table *ds_table)
{
uint32_t uuid = create_divesite_uuid(name, divetime);
struct dive_site *ds = alloc_or_get_dive_site(uuid);
struct dive_site *ds = alloc_or_get_dive_site(uuid, ds_table);
ds->name = copy_string(name);
ds->location = *loc;
@ -323,32 +323,32 @@ void merge_dive_sites(struct dive_site *ref, struct dive_site *dive_sites[], int
for(i = 0; i < count; i++) {
if (dive_sites[i] == ref)
continue;
delete_dive_site(dive_sites[i]);
delete_dive_site(dive_sites[i], &dive_site_table);
}
mark_divelist_changed(true);
}
struct dive_site *find_or_create_dive_site_with_name(const char *name, timestamp_t divetime)
struct dive_site *find_or_create_dive_site_with_name(const char *name, timestamp_t divetime, struct dive_site_table *ds_table)
{
int i;
struct dive_site *ds;
for_each_dive_site(i,ds) {
for_each_dive_site(i,ds, ds_table) {
if (same_string(name, ds->name))
break;
}
if (ds)
return ds;
return create_dive_site(name, divetime);
return create_dive_site(name, divetime, ds_table);
}
void purge_empty_dive_sites()
void purge_empty_dive_sites(struct dive_site_table *ds_table)
{
int i, j;
struct dive *d;
struct dive_site *ds;
for (i = 0; i < dive_site_table.nr; i++) {
ds = get_dive_site(i);
for (i = 0; i < ds_table->nr; i++) {
ds = get_dive_site(i, ds_table);
if (!dive_site_is_empty(ds))
continue;
for_each_dive(j, d) {
@ -365,7 +365,7 @@ static int compare_sites(const void *_a, const void *_b)
return a->uuid > b->uuid ? 1 : a->uuid == b->uuid ? 0 : -1;
}
void dive_site_table_sort()
void dive_site_table_sort(struct dive_site_table *ds_table)
{
qsort(dive_site_table.dive_sites, dive_site_table.nr, sizeof(struct dive_site *), compare_sites);
qsort(ds_table->dive_sites, ds_table->nr, sizeof(struct dive_site *), compare_sites);
}