summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/divelist.c387
-rw-r--r--core/divelist.h6
-rw-r--r--desktop-widgets/divelogimportdialog.cpp2
-rw-r--r--desktop-widgets/downloadfromdivecomputer.cpp4
-rw-r--r--desktop-widgets/mainwindow.cpp2
-rw-r--r--desktop-widgets/subsurfacewebservices.cpp2
-rw-r--r--mobile-widgets/qmlmanager.cpp2
-rw-r--r--qt-models/diveimportedmodel.cpp2
-rw-r--r--tests/testgitstorage.cpp2
-rw-r--r--tests/testmerge.cpp8
-rw-r--r--tests/testrenumber.cpp4
11 files changed, 218 insertions, 203 deletions
diff --git a/core/divelist.c b/core/divelist.c
index 79b116e06..3fec7af8b 100644
--- a/core/divelist.c
+++ b/core/divelist.c
@@ -1368,66 +1368,6 @@ int unsaved_changes()
return dive_list_changed;
}
-/*
- * When adding dives to the dive table, we try to renumber
- * the new dives based on any old dives in the dive table.
- *
- * But we only do it if:
- *
- * - there are no dives in the dive table
- *
- * OR
- *
- * - the last dive in the old dive table was numbered
- *
- * - all the new dives are strictly at the end (so the
- * "last dive" is at the same location in the dive table
- * after re-sorting the dives.
- *
- * - none of the new dives have any numbers
- *
- * This catches the common case of importing new dives from
- * a dive computer, and gives them proper numbers based on
- * your old dive list. But it tries to be very conservative
- * and not give numbers if there is *any* question about
- * what the numbers should be - in which case you need to do
- * a manual re-numbering.
- */
-static void try_to_renumber(int preexisting)
-{
- int i, nr;
- struct dive *last = get_dive(preexisting - 1);
-
- /*
- * If there was a last dive, but it didn't have
- * a number, give up.
- */
- if (last && !last->number)
- return;
-
- /*
- * If any of the new dives already had a number,
- * we'll have to do a manual renumbering.
- */
- for (i = preexisting; i < dive_table.nr; i++) {
- struct dive *dive = get_dive(i);
- if (dive->number)
- return;
- }
-
- /*
- * Ok, renumber..
- */
- if (last)
- nr = last->number;
- else
- nr = 0;
- for (i = preexisting; i < dive_table.nr; i++) {
- struct dive *dive = get_dive(i);
- dive->number = ++nr;
- }
-}
-
void process_loaded_dives()
{
int i;
@@ -1477,46 +1417,53 @@ static void merge_imported_dives(struct dive_table *table)
}
}
+static void insert_dive(struct dive_table *table, struct dive *d)
+{
+ int idx = dive_table_get_insertion_index(table, d);
+ add_to_dive_table(table, idx, d);
+}
+
+/*
+ * Clear a dive_table and a trip_table. Think about generating these with macros.
+ */
+void clear_table(struct dive_table *table)
+{
+ for (int i = 0; i < table->nr; i++)
+ free_dive(table->dives[i]);
+ table->nr = 0;
+}
+
+static void clear_trip_table(struct trip_table *table)
+{
+ for (int i = 0; i < table->nr; i++)
+ free_trip(table->trips[i]);
+ table->nr = 0;
+}
+
/*
* Try to merge a new dive into the dive at position idx. Return
- * true on success. On success, the old dive will be deleted. On failure,
- * it is unchanged.
- * If replace_in is not NULL, the original dive will also be replaced
- * by the merged dive in this dive table. If it is NULL it will be
- * replaced in the dive table of its trip. This is used for merging dive
- * in the trip table *and* the dive table.
+ * true on success. On success, the old dive will be added to the
+ * dives_to_remove table and the merged dive to the dives_to_add
+ * table. On failure everything stays unchanged.
* If "prefer_imported" is true, use data of the new dive.
*/
-static bool try_to_merge_into(struct dive *dive_to_add, int idx, struct dive_table *table,
- struct dive_table *replace_in, bool prefer_imported)
+static bool try_to_merge_into(struct dive *dive_to_add, int idx, struct dive_table *table, bool prefer_imported,
+ /* output parameters: */
+ struct dive_table *dives_to_add, struct dive_table *dives_to_remove)
{
struct dive *old_dive = table->dives[idx];
struct dive *merged = try_to_merge(old_dive, dive_to_add, prefer_imported);
if (!merged)
return false;
- /* Hack alert! If no replace_in table was passed, we are merging
- * a non-trip dive into a potentially in-trip dive. In this case
- * we also have to replace the merged dive for the old dive in the
- * trip list. This will be removed in a subsequent commit, when
- * the merging is done outside of processing */
- if (!replace_in && old_dive->divetrip)
- replace_in = &old_dive->divetrip->dives;
-
- merged->selected = old_dive->selected;
merged->divetrip = old_dive->divetrip;
- old_dive->divetrip = NULL;
- table->dives[idx] = merged;
- if (replace_in) {
- int idx2 = get_idx_in_dive_table(replace_in, old_dive);
- if (idx2 >= 0)
- replace_in->dives[idx2] = merged;
- }
- free_dive(old_dive);
+ insert_dive(dives_to_remove, old_dive);
+ insert_dive(dives_to_add, merged);
return true;
}
+/* Check if two trips overlap time-wise. */
static bool trips_overlap(const struct dive_trip *t1, const struct dive_trip *t2)
{
/* First, handle the empty-trip cases. */
@@ -1529,22 +1476,33 @@ static bool trips_overlap(const struct dive_trip *t1, const struct dive_trip *t2
return trip_enddate(t2) >= trip_date(t1);
}
-static bool insert_dive(struct dive_table *table, struct dive *d)
+/* Check if a dive is ranked after the last dive of the global dive list */
+static bool dive_is_after_last(struct dive *d)
{
- int idx = dive_table_get_insertion_index(table, d);
- add_to_dive_table(table, idx, d);
- return idx == table->nr - 1;
-}
-
-/* Merge dives from dives_from into dives_to. Overlapping dives will be merged,
- * non-overlapping dives will be moved. Optionally, if delete_from and add_to
- * are non-null, dives will be removed / added to these tables. This supposes that
- * all tables are sorted. */
+ if (dive_table.nr == 0)
+ return true;
+ return dive_less_than(dive_table.dives[dive_table.nr - 1], d);
+}
+
+/* Merge dives from "dives_from" into "dives_to". Overlapping dives will be merged,
+ * non-overlapping dives will be moved. The results will be added to the "dives_to_add"
+ * table. Dives that were merged are added to the "dives_to_remove" table.
+ * Any newly added (not merged) dive will be assigned to the trip from the "trip"
+ * paremeter. If "delete_from" is non-null dives will be removed from this table.
+ * This function supposes that all input tables are sorted.
+ * Returns true if any dive was added (not merged) that is not past the
+ * last dive of the global dive list (i.e. the sequence will change).
+ * The integer pointed to by "num_merged" will be increased for every
+ * merged dive that is added to "dives_to_add" */
static bool merge_dive_tables(struct dive_table *dives_from, struct dive_table *delete_from,
- struct dive_table *dives_to, struct dive_table *add_to,
- bool prefer_imported, struct dive_trip *trip)
+ struct dive_table *dives_to,
+ bool prefer_imported, struct dive_trip *trip,
+ /* output parameters: */
+ struct dive_table *dives_to_add, struct dive_table *dives_to_remove,
+ int *num_merged)
{
int i, j;
+ int last_merged_into = -1;
bool sequence_changed = false;
/* Merge newly imported dives into the dive table.
@@ -1567,47 +1525,40 @@ static bool merge_dive_tables(struct dive_table *dives_from, struct dive_table *
while (j < dives_to->nr && dive_less_than(dives_to->dives[j], dive_to_add))
j++;
- /* Try to merge into previous dive. */
- if (j > 0 && dive_endtime(dives_to->dives[j - 1]) > dive_to_add->when) {
- if (try_to_merge_into(dive_to_add, j - 1, dives_to, add_to, prefer_imported)) {
+ /* Try to merge into previous dive.
+ * We are extra-careful to not merge into the same dive twice, as that
+ * would put the merged-into dive twice onto the dives-to-delete list.
+ * In principle that shouldn't happen as all dives that compare equal
+ * by is_same_dive() were already merged, and is_same_dive() should be
+ * transitive. But let's just go *completely* sure for the odd corner-case. */
+ if (j > 0 && j - 1 > last_merged_into &&
+ dive_endtime(dives_to->dives[j - 1]) > dive_to_add->when) {
+ if (try_to_merge_into(dive_to_add, j - 1, dives_to, prefer_imported,
+ dives_to_add, dives_to_remove)) {
free_dive(dive_to_add);
+ last_merged_into = j - 1;
+ (*num_merged)++;
continue;
}
}
- /* That didn't merge into the previous dive. If we're
- * at the end of the dive table, quit the loop and add
- * all new dives at the end. */
- if (j >= dives_to->nr)
- break;
-
- /* Try to merge into next dive. */
- if (dive_endtime(dive_to_add) > dives_to->dives[j]->when) {
- if (try_to_merge_into(dive_to_add, j, dives_to, add_to, prefer_imported)) {
+ /* That didn't merge into the previous dive.
+ * Try to merge into next dive. */
+ if (j < dives_to->nr && j > last_merged_into &&
+ dive_endtime(dive_to_add) > dives_to->dives[j]->when) {
+ if (try_to_merge_into(dive_to_add, j, dives_to, prefer_imported,
+ dives_to_add, dives_to_remove)) {
free_dive(dive_to_add);
+ last_merged_into = j;
+ (*num_merged)++;
continue;
}
}
- /* We couldnt merge dives, add at the given position. */
- add_to_dive_table(dives_to, j, dive_to_add);
+ /* We couldnt merge dives, simply add to list of dives to-be-added. */
+ insert_dive(dives_to_add, dive_to_add);
+ sequence_changed |= !dive_is_after_last(dive_to_add);
dive_to_add->divetrip = trip;
- if (add_to)
- insert_dive(add_to, dive_to_add);
- j++;
- sequence_changed = true;
- }
-
- /* If there are still dives to add, add them at the end of the dive table. */
- for ( ; i < dives_from->nr; i++) {
- struct dive *dive_to_add = dives_from->dives[i];
- if (delete_from)
- remove_dive(delete_from, dive_to_add);
-
- dive_to_add->divetrip = trip;
- add_to_dive_table(dives_to, dives_to->nr, dive_to_add);
- if (add_to)
- sequence_changed |= !insert_dive(add_to, dive_to_add);
}
/* we took care of all dives, clean up the import table */
@@ -1619,56 +1570,105 @@ static bool merge_dive_tables(struct dive_table *dives_from, struct dive_table *
/* Merge the dives of the trip "from" and the dive_table "dives_from" into the trip "to"
* and dive_table "dives_to". If "prefer_imported" is true, dive data of "from" takes
* precedence */
-static bool merge_trips(struct dive_trip *from, struct dive_table *dives_from,
- struct dive_trip *to, struct dive_table *dives_to, bool prefer_imported)
-{
- return merge_dive_tables(&from->dives, dives_from, &to->dives, dives_to, prefer_imported, to);
-}
-
-static bool add_trip_to_table(struct dive_trip *trip, struct dive_table *dives_from,
- struct trip_table *table, struct dive_table *dives_to)
-{
- int i;
- struct dive *d;
- bool sequence_changed = false;
- for (i = 0; i < trip->dives.nr; i++) {
- d = trip->dives.dives[i];
+void add_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table,
+ bool prefer_imported, bool downloaded, bool merge_all_trips)
+{
+ int i, idx;
+ struct dive_table dives_to_add = { 0 };
+ struct dive_table dives_to_remove = { 0 };
+ struct trip_table trips_to_add = { 0 };
+
+ /* Process imported dives and generate lists of dives
+ * to-be-added and to-be-removed */
+ process_imported_dives(import_table, import_trip_table,
+ prefer_imported, downloaded, merge_all_trips,
+ &dives_to_add, &dives_to_remove, &trips_to_add);
+
+ /* Add new dives to trip, so that trips don't get deleted
+ * on deletion of old dives */
+ for (i = 0; i < dives_to_add.nr; i++) {
+ struct dive *d = dives_to_add.dives[i];
+ struct dive_trip *trip = d->divetrip;
+ if (!trip)
+ continue;
+ d->divetrip = NULL;
+ add_dive_to_trip(d, trip);
+ }
- /* Add dive to copy-to table */
- sequence_changed |= !insert_dive(dives_to, d);
+ /* Remove old dives */
+ for (i = 0; i < dives_to_remove.nr; i++) {
+ idx = get_divenr(dives_to_remove.dives[i]);
+ delete_single_dive(idx);
+ }
+ dives_to_remove.nr = 0;
- /* Remove dive from copy-from table */
- remove_dive(dives_from, d);
+ /* Add new dives */
+ for (i = 0; i < dives_to_add.nr; i++) {
+ idx = dive_table_get_insertion_index(&dive_table, dives_to_add.dives[i]);
+ add_single_dive(idx, dives_to_add.dives[i]);
}
+ dives_to_add.nr = 0;
- /* Add trip to list */
- insert_trip(trip, table);
+ /* Add new trips */
+ for (i = 0; i < trips_to_add.nr; i++)
+ insert_trip(trips_to_add.trips[i], &trip_table);
+ trips_to_add.nr = 0;
- return sequence_changed;
+ /* We might have deleted the old selected dive.
+ * Choose the newest dive as selected (if any) */
+ current_dive = dive_table.nr > 0 ? dive_table.dives[dive_table.nr - 1] : NULL;
+ mark_divelist_changed(true);
}
-/*
- * Add imported dive to global dive table. Overlapping dives will
- * be merged if possible. If prefer_imported is true, data of the
- * new dives are prioritized in such a case.
- * If downloaded is true, only the divecomputer of the first dive
+/* Process imported dives: take a table of dives to be imported and
+ * generate three lists:
+ * 1) Dives to be added
+ * 2) Dives to be removed
+ * 3) Trips to be added
+ * The dives to be added are owning (i.e. the caller is responsible
+ * for freeing them).
+ * The dives and trips in import_table and import_trip table are
+ * consumed. On return, both tables have size 0.
+ * The output parameters should be empty - if not, their content
+ * will be cleared!
+ *
+ * Note: The new dives will have their divetrip-field set, but will
+ * *not* be part of the trip. The caller has to add them to the trip.
+ *
+ * The lists are generated by merging dives if possible. This is
+ * performed trip-wise. If prefer_imported is true, data of the
+ * new dives are prioritized in such a case. If merge_all_trips is
+ * true, all overlapping trips will be merged, not only non-autogenerated
+ * trips. If downloaded is true, only the divecomputer of the first dive
* will be considered, as it is assumed that all dives come from
* the same computer.
- * If merge_all_trips is true, all trips are merged. This is used
- * when merging log files. If it is false, only autogenerated trips
- * are merged. This is used for download-from-dc. There, if the user
- * explicitly asked for a new trip, we don't want to merge into old
- * trips.
- * Note: the dives in import_table and the trips in import_trip_table
- * are consumed. On return both tables have size 0.
*/
void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table,
- bool prefer_imported, bool downloaded, bool merge_all_trips)
+ bool prefer_imported, bool downloaded, bool merge_all_trips,
+ /* output parameters: */
+ struct dive_table *dives_to_add, struct dive_table *dives_to_remove,
+ struct trip_table *trips_to_add)
{
- int i, j;
+ int i, j, nr, start_renumbering_at = 0;
struct dive_trip *trip_import, *trip_old;
int preexisting;
bool sequence_changed = false;
+ bool new_dive_has_number = false;
+
+ /* Make sure that output parameters don't contain garbage */
+ clear_table(dives_to_add);
+ clear_table(dives_to_remove);
+ clear_trip_table(trips_to_add);
+
+ /* Check if any of the new dives has a number. This will be
+ * important later to decide if we want to renumber the added
+ * dives */
+ for (int i = 0; i < import_table->nr; i++) {
+ if (import_table->dives[i]->number > 0) {
+ new_dive_has_number = true;
+ break;
+ }
+ }
/* If no dives were imported, don't bother doing anything */
if (!import_table->nr)
@@ -1704,31 +1704,52 @@ void process_imported_dives(struct dive_table *import_table, struct trip_table *
for (j = 0; j < trip_table.nr; j++) {
trip_old = trip_table.trips[j];
if (trips_overlap(trip_import, trip_old)) {
- sequence_changed |= merge_trips(trip_import, import_table, trip_old, &dive_table, prefer_imported);
+ sequence_changed |= merge_dive_tables(&trip_import->dives, import_table, &trip_old->dives,
+ prefer_imported, trip_old,
+ dives_to_add, dives_to_remove,
+ &start_renumbering_at);
free_trip(trip_import); /* All dives in trip have been consumed -> free */
break;
}
}
/* If no trip to merge-into was found, add trip as-is. */
- if (j == trip_table.nr)
- sequence_changed |= add_trip_to_table(trip_import, import_table, &trip_table, &dive_table);
- }
- import_trip_table->nr = 0; /* All trips were consumed */
+ if (j == trip_table.nr) {
+ /* Add dives to list of dives to add */
+ for (i = 0; i < trip_import->dives.nr; i++) {
+ struct dive *d = trip_import->dives.dives[i];
- sequence_changed |= merge_dive_tables(import_table, NULL, &dive_table, NULL, prefer_imported, NULL);
+ /* Add dive to list of dives to-be-added. */
+ insert_dive(dives_to_add, d);
+ sequence_changed |= !dive_is_after_last(d);
- /* If the sequence wasn't changed, renumber */
- if (!sequence_changed)
- try_to_renumber(preexisting);
+ remove_dive(import_table, d);
+ }
- /* Unlikely, but trip order may have changed owing to merging dives -
- * make sure that they are still ordered */
- sort_trip_table(&trip_table);
+ /* Add trip to list of trips to add */
+ insert_trip(trip_import, trips_to_add);
+ trip_import->dives.nr = 0; /* Caller is responsible for adding dives to trip */
+ }
+ }
+ import_trip_table->nr = 0; /* All trips were consumed */
- /* We might have deleted the old selected dive.
- * Choose the newest dive as selected (if any) */
- current_dive = dive_table.nr > 0 ? dive_table.dives[dive_table.nr - 1] : NULL;
- mark_divelist_changed(true);
+ /* The remaining dives in import_table are those that don't belong to
+ * a trip. Merge them into the global table. */
+ sequence_changed |= merge_dive_tables(import_table, NULL, &dive_table, prefer_imported, NULL,
+ dives_to_add, dives_to_remove, &start_renumbering_at);
+
+ /* If new dives were only added at the end, renumber the added dives.
+ * But only if
+ * - The last dive in the old dive table had a number itself.
+ * - None of the new dives has a number.
+ */
+ nr = dive_table.nr > 0 ? dive_table.dives[dive_table.nr - 1]->number : 0;
+ /* We counted the number of merged dives that were added to dives_to_add.
+ * Skip those. Since sequence_changed is false all added dives are *after*
+ * all merged dives. */
+ if (!sequence_changed && nr >= preexisting && !new_dive_has_number) {
+ for (i = start_renumbering_at; i < dives_to_add->nr; i++)
+ dives_to_add->dives[i]->number = ++nr;
+ }
}
/* return the number a dive gets when inserted at the given index.
@@ -1819,16 +1840,6 @@ void clear_dive_file_data()
saved_git_id = "";
}
-/*
- * Clear a dive_table
- */
-void clear_table(struct dive_table *table)
-{
- for (int i = 0; i < table->nr; i++)
- free_dive(table->dives[i]);
- table->nr = 0;
-}
-
bool dive_less_than(const struct dive *a, const struct dive *b)
{
return comp_dives(a, b) < 0;
diff --git a/core/divelist.h b/core/divelist.h
index 26bd1b3db..d94fedc38 100644
--- a/core/divelist.h
+++ b/core/divelist.h
@@ -18,8 +18,12 @@ extern int init_decompression(struct deco_state *ds, struct dive *dive);
/* divelist core logic functions */
extern void process_loaded_dives();
+extern void add_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table,
+ bool prefer_imported, bool downloaded, bool merge_all_trips);
extern void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table,
- bool prefer_imported, bool downloaded, bool merge_all_trips);
+ bool prefer_imported, bool downloaded, bool merge_all_trips,
+ struct dive_table *dives_to_add, struct dive_table *dives_to_remove,
+ struct trip_table *trips_to_add);
extern char *get_dive_gas_string(const struct dive *dive);
extern struct dive **grow_dive_table(struct dive_table *table);
diff --git a/desktop-widgets/divelogimportdialog.cpp b/desktop-widgets/divelogimportdialog.cpp
index a280a73ee..f8e44067d 100644
--- a/desktop-widgets/divelogimportdialog.cpp
+++ b/desktop-widgets/divelogimportdialog.cpp
@@ -1011,7 +1011,7 @@ void DiveLogImportDialog::on_buttonBox_accepted()
}
}
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
Command::clear();
MainWindow::instance()->refreshDisplay();
}
diff --git a/desktop-widgets/downloadfromdivecomputer.cpp b/desktop-widgets/downloadfromdivecomputer.cpp
index 50cbe223c..547c740c8 100644
--- a/desktop-widgets/downloadfromdivecomputer.cpp
+++ b/desktop-widgets/downloadfromdivecomputer.cpp
@@ -525,9 +525,9 @@ void DownloadFromDCWidget::on_ok_clicked()
// remember the last downloaded dive (on most dive computers this will be the chronologically
// first new dive) and select it again after processing all the dives
int uniqId = table->dives[table->nr - 1]->id;
- process_imported_dives(table, trips, preferDownloaded(), true, false);
+ add_imported_dives(table, trips, preferDownloaded(), true, false);
Command::clear();
- // after process_imported_dives does any merging or resorting needed, we need
+ // after add_imported_dives does any merging or resorting needed, we need
// to recreate the model for the dive list so we can select the newest dive
MainWindow::instance()->recreateDiveList();
int idx = get_idx_by_uniq_id(uniqId);
diff --git a/desktop-widgets/mainwindow.cpp b/desktop-widgets/mainwindow.cpp
index f18c8af7a..474ce0f55 100644
--- a/desktop-widgets/mainwindow.cpp
+++ b/desktop-widgets/mainwindow.cpp
@@ -1714,7 +1714,7 @@ void MainWindow::importFiles(const QStringList fileNames)
fileNamePtr = QFile::encodeName(fileNames.at(i));
parse_file(fileNamePtr.data(), &table, &trips);
}
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
Command::clear();
refreshDisplay();
}
diff --git a/desktop-widgets/subsurfacewebservices.cpp b/desktop-widgets/subsurfacewebservices.cpp
index 3a0dfb1e3..58806a75b 100644
--- a/desktop-widgets/subsurfacewebservices.cpp
+++ b/desktop-widgets/subsurfacewebservices.cpp
@@ -771,7 +771,7 @@ void DivelogsDeWebServices::buttonClicked(QAbstractButton *button)
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
parse_file(QFile::encodeName(zipFile.fileName()), &table, &trips);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
MainWindow::instance()->refreshDisplay();
/* store last entered user/pass in config */
diff --git a/mobile-widgets/qmlmanager.cpp b/mobile-widgets/qmlmanager.cpp
index 337a5f49f..3a38fb90d 100644
--- a/mobile-widgets/qmlmanager.cpp
+++ b/mobile-widgets/qmlmanager.cpp
@@ -341,7 +341,7 @@ void QMLManager::mergeLocalRepo()
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
parse_file(filename, &table, &trips);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
}
void QMLManager::copyAppLogToClipboard()
diff --git a/qt-models/diveimportedmodel.cpp b/qt-models/diveimportedmodel.cpp
index 3b792ee80..ac7e26c26 100644
--- a/qt-models/diveimportedmodel.cpp
+++ b/qt-models/diveimportedmodel.cpp
@@ -157,7 +157,7 @@ void DiveImportedModel::recordDives()
delete_dive_from_table(diveTable, j);
}
- process_imported_dives(diveTable, tripTable, true, true, false);
+ add_imported_dives(diveTable, tripTable, true, true, false);
}
QHash<int, QByteArray> DiveImportedModel::roleNames() const {
diff --git a/tests/testgitstorage.cpp b/tests/testgitstorage.cpp
index f6d0899cd..dfe64a3b3 100644
--- a/tests/testgitstorage.cpp
+++ b/tests/testgitstorage.cpp
@@ -137,7 +137,7 @@ void TestGitStorage::testGitStorageCloudOfflineSync()
// read the local repo from the previous test and add dive 10
QCOMPARE(parse_file(qPrintable(localCacheRepo), &dive_table, &trip_table), 0);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test10.xml", &dive_table, &trip_table), 0);
- // calling process_loaded_dives() sorts the table, but calling process_imported_dives()
+ // calling process_loaded_dives() sorts the table, but calling add_imported_dives()
// causes it to try to update the window title... let's not do that
process_loaded_dives();
// now save only to the local cache but not to the remote server
diff --git a/tests/testmerge.cpp b/tests/testmerge.cpp
index 7e32ba32e..130c91b6d 100644
--- a/tests/testmerge.cpp
+++ b/tests/testmerge.cpp
@@ -24,9 +24,9 @@ void TestMerge::testMergeEmpty()
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0);
QFile org(SUBSURFACE_TEST_DATA "/dives/test47+48.xml");
org.open(QFile::ReadOnly);
@@ -49,9 +49,9 @@ void TestMerge::testMergeBackwards()
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0);
QFile org(SUBSURFACE_TEST_DATA "/dives/test47+48.xml");
org.open(QFile::ReadOnly);
diff --git a/tests/testrenumber.cpp b/tests/testrenumber.cpp
index e6e802676..6d3ac7fa5 100644
--- a/tests/testrenumber.cpp
+++ b/tests/testrenumber.cpp
@@ -16,7 +16,7 @@ void TestRenumber::testMerge()
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47b.xml", &table, &trip_table), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(dive_table.nr, 1);
QCOMPARE(unsaved_changes(), 1);
mark_divelist_changed(false);
@@ -27,7 +27,7 @@ void TestRenumber::testMergeAndAppend()
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47c.xml", &table, &trip_table), 0);
- process_imported_dives(&table, &trips, false, false, true);
+ add_imported_dives(&table, &trips, false, false, true);
QCOMPARE(dive_table.nr, 2);
QCOMPARE(unsaved_changes(), 1);
struct dive *d = get_dive(1);
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-12-27 22:53:45 +0000