From 9c253ee6c5619edf754d3ec36974fd527b4aae76 Mon Sep 17 00:00:00 2001 From: Berthold Stoeger Date: Tue, 8 Nov 2022 21:31:08 +0100 Subject: [PATCH] core: introduce divelog structure The parser API was very annoying, as a number of tables to-be-filled were passed in as pointers. The goal of this commit is to collect all these tables in a single struct. This should make it (more or less) clear what is actually written into the divelog files. Moreover, it should now be rather easy to search for instances, where the global logfile is accessed (and it turns out that there are many!). The divelog struct does not contain the tables as substructs, but only collects pointers. The idea is that the "divelog.h" file can be included without all the other files describing the numerous tables. To make it easier to use from C++ parts of the code, the struct implements a constructor and a destructor. Sadly, we can't use smart pointers, since the pointers are accessed from C code. Therfore the constructor and destructor are quite complex. The whole commit is large, but was mostly an automatic conversion. One oddity of note: the divelog structure also contains the "autogroup" flag, since that is saved in the divelog. This actually fixes a bug: Before, when importing dives from a different log, the autogroup flag was overwritten. This was probably not intended and does not happen anymore. Signed-off-by: Berthold Stoeger --- Subsurface-mobile.pro | 2 + backend-shared/exportfuncs.cpp | 15 +-- commands/command_base.cpp | 3 +- commands/command_device.cpp | 7 +- commands/command_divelist.cpp | 49 ++++----- commands/command_divesite.cpp | 7 +- commands/command_edit.cpp | 5 +- core/CMakeLists.txt | 2 + core/cochran.c | 7 +- core/datatrak.c | 11 +- core/device.cpp | 4 +- core/device.h | 1 - core/dive.c | 7 +- core/divefilter.cpp | 8 +- core/divelist.c | 104 +++++++++---------- core/divelist.h | 6 +- core/divelog.cpp | 56 ++++++++++ core/divelog.h | 40 +++++++ core/divesite.c | 11 +- core/divesite.h | 2 - core/equipment.c | 5 +- core/file.c | 69 ++++++------ core/file.h | 22 ++-- core/filterpreset.cpp | 33 +++--- core/filterpreset.h | 2 - core/fulltext.cpp | 3 +- core/git-access.h | 10 +- core/import-cobalt.c | 13 ++- core/import-csv.c | 51 ++++----- core/import-csv.h | 15 +-- core/import-divinglog.c | 13 ++- core/import-seac.c | 13 ++- core/import-shearwater.c | 25 ++--- core/import-suunto.c | 25 ++--- core/libdivecomputer.c | 5 +- core/liquivision.c | 6 +- core/load-git.c | 14 +-- core/ostctools.c | 9 +- core/parse-xml.c | 26 +++-- core/parse.c | 2 - core/parse.h | 32 ++---- core/qthelper.cpp | 7 +- core/save-git.c | 17 +-- core/save-html.c | 5 +- core/save-xml.c | 13 +-- core/selection.cpp | 21 ++-- core/statistics.c | 11 +- core/trip.c | 13 ++- core/trip.h | 1 - core/uemis-downloader.c | 3 +- desktop-widgets/divelogimportdialog.cpp | 19 ++-- desktop-widgets/divesitelistview.cpp | 3 +- desktop-widgets/downloadfromdivecomputer.cpp | 3 +- desktop-widgets/locationinformation.cpp | 14 +-- desktop-widgets/mainwindow.cpp | 36 +++---- desktop-widgets/subsurfacewebservices.cpp | 14 +-- desktop-widgets/tripselectiondialog.cpp | 11 +- export-html.cpp | 3 +- mobile-widgets/qmlmanager.cpp | 50 ++++----- qt-models/divelocationmodel.cpp | 25 ++--- qt-models/diveplannermodel.cpp | 8 +- qt-models/divesiteimportmodel.cpp | 7 +- qt-models/divetripmodel.cpp | 9 +- qt-models/maplocationmodel.cpp | 5 +- smtk-import/smartrak.c | 19 ++-- smtk-import/smrtk2ssrfc_window.cpp | 3 +- smtk-import/smrtk2ssrfc_window.h | 3 +- smtk-import/smtk_standalone.cpp | 5 +- stats/statsvariables.cpp | 3 +- subsurface-desktop-main.cpp | 2 + subsurface-downloader-main.cpp | 9 +- subsurface-mobile-main.cpp | 2 + tests/testAirPressure.cpp | 7 +- tests/testdivesiteduplication.cpp | 9 +- tests/testgitstorage.cpp | 82 +++++---------- tests/testmerge.cpp | 35 +++---- tests/testparse.cpp | 95 ++++++++--------- tests/testparseperformance.cpp | 10 +- tests/testpicture.cpp | 5 +- tests/testprofile.cpp | 5 +- tests/testrenumber.cpp | 27 ++--- 81 files changed, 661 insertions(+), 698 deletions(-) create mode 100644 core/divelog.cpp create mode 100644 core/divelog.h diff --git a/Subsurface-mobile.pro b/Subsurface-mobile.pro index 3d66664ce..3e695ce98 100644 --- a/Subsurface-mobile.pro +++ b/Subsurface-mobile.pro @@ -55,6 +55,7 @@ SOURCES += subsurface-mobile-main.cpp \ core/filterconstraint.cpp \ core/filterpreset.cpp \ core/divelist.c \ + core/divelog.cpp \ core/gas-model.c \ core/gaspressures.c \ core/git-access.c \ @@ -227,6 +228,7 @@ HEADERS += \ core/filterconstraint.h \ core/filterpreset.h \ core/divelist.h \ + core/divelog.h \ core/divelogexportlogic.h \ core/divesitehelpers.h \ core/exif.h \ diff --git a/backend-shared/exportfuncs.cpp b/backend-shared/exportfuncs.cpp index 8c123b54f..385a84a37 100644 --- a/backend-shared/exportfuncs.cpp +++ b/backend-shared/exportfuncs.cpp @@ -2,6 +2,7 @@ #include "exportfuncs.h" #include "core/membuffer.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/gettextfromc.h" #include "core/tag.h" @@ -62,7 +63,7 @@ void exportProfile(QString filename, bool selected_only, ExportCallback &cb) filename = filename.append(".png"); QFileInfo fi(filename); - int todo = selected_only ? amount_selected : dive_table.nr; + int todo = selected_only ? amount_selected : divelog.dives->nr; int done = 0; auto profile = getPrintProfile(); for_each_dive (i, dive) { @@ -131,7 +132,7 @@ void export_TeX(const char *filename, bool selected_only, bool plain, ExportCall put_format(&buf, "\n%%%%%%%%%% Begin Dive Data: %%%%%%%%%%\n"); - int todo = selected_only ? amount_selected : dive_table.nr; + int todo = selected_only ? amount_selected : divelog.dives->nr; int done = 0; auto profile = getPrintProfile(); for_each_dive (i, dive) { @@ -330,9 +331,9 @@ std::vector getDiveSitesToExport(bool selectedOnly) return res; } - res.reserve(dive_site_table.nr); - for (int i = 0; i < dive_site_table.nr; i++) { - struct dive_site *ds = get_dive_site(i, &dive_site_table); + res.reserve(divelog.sites->nr); + for (int i = 0; i < divelog.sites->nr; i++) { + struct dive_site *ds = get_dive_site(i, divelog.sites); if (dive_site_is_empty(ds)) continue; if (selectedOnly && !is_dive_site_selected(ds)) @@ -343,8 +344,8 @@ std::vector getDiveSitesToExport(bool selectedOnly) /* walk the dive site list */ int i; const struct dive_site *ds; - for_each_dive_site (i, ds, &dive_site_table) - res.push_back(get_dive_site(i, &dive_site_table)); + for_each_dive_site (i, ds, divelog.sites) + res.push_back(get_dive_site(i, divelog.sites)); #endif return res; } diff --git a/commands/command_base.cpp b/commands/command_base.cpp index 34628ba4f..a33c31b86 100644 --- a/commands/command_base.cpp +++ b/commands/command_base.cpp @@ -2,6 +2,7 @@ #include "command.h" #include "command_base.h" +#include "core/divelog.h" #include "core/globals.h" #include "core/qthelper.h" // for updateWindowTitle() #include "core/subsurface-qt/divelistnotifier.h" @@ -65,7 +66,7 @@ QString diveNumberOrDate(struct dive *d) QString getListOfDives(const std::vector &dives) { QString listOfDives; - if ((int)dives.size() == dive_table.nr) + if ((int)dives.size() == divelog.dives->nr) return Base::tr("all dives"); int i = 0; for (dive *d: dives) { diff --git a/commands/command_device.cpp b/commands/command_device.cpp index a72a4340d..540e80adf 100644 --- a/commands/command_device.cpp +++ b/commands/command_device.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "command_device.h" +#include "core/divelog.h" #include "core/subsurface-qt/divelistnotifier.h" namespace Command { @@ -8,7 +9,7 @@ namespace Command { EditDeviceNickname::EditDeviceNickname(const struct divecomputer *dc, const QString &nicknameIn) : nickname(nicknameIn.toStdString()) { - index = get_or_add_device_for_dc(&device_table, dc); + index = get_or_add_device_for_dc(divelog.devices, dc); if (index == -1) return; @@ -17,12 +18,12 @@ EditDeviceNickname::EditDeviceNickname(const struct divecomputer *dc, const QStr bool EditDeviceNickname::workToBeDone() { - return get_device(&device_table, index) != nullptr; + return get_device(divelog.devices, index) != nullptr; } void EditDeviceNickname::redo() { - device *dev = get_device_mutable(&device_table, index); + device *dev = get_device_mutable(divelog.devices, index); if (!dev) return; std::swap(dev->nickName, nickname); diff --git a/commands/command_divelist.cpp b/commands/command_divelist.cpp index 6236dd438..c527757bf 100644 --- a/commands/command_divelist.cpp +++ b/commands/command_divelist.cpp @@ -2,6 +2,7 @@ #include "command_divelist.h" #include "core/divelist.h" +#include "core/divelog.h" #include "core/qthelper.h" #include "core/selection.h" #include "core/subsurface-qt/divelistnotifier.h" @@ -17,7 +18,7 @@ static void remove_trip_from_backend(dive_trip *trip) { if (trip->selected) deselect_trip(trip); - remove_trip(trip, &trip_table); // Remove trip from backend + remove_trip(trip, divelog.trips); // Remove trip from backend } // This helper function removes a dive, takes ownership of the dive and adds it to a DiveToAdd structure. @@ -77,9 +78,9 @@ dive *DiveListBase::addDive(DiveToAdd &d) // dives have been added, their status will be updated. res->hidden_by_filter = true; - int idx = dive_table_get_insertion_index(&dive_table, res); + int idx = dive_table_get_insertion_index(divelog.dives, res); fulltext_register(res); // Register the dive's fulltext cache - add_to_dive_table(&dive_table, idx, res); // Return ownership to backend + add_to_dive_table(divelog.dives, idx, res); // Return ownership to backend invalidate_dive_cache(res); // Ensure that dive is written in git_save() return res; @@ -210,7 +211,7 @@ DivesAndSitesToRemove DiveListBase::addDives(DivesAndTripsToAdd &toAdd) addedTrips.reserve(toAdd.trips.size()); for (OwningTripPtr &trip: toAdd.trips) { addedTrips.push_back(trip.get()); - insert_trip(trip.release(), &trip_table); // Return ownership to backend + insert_trip(trip.release(), divelog.trips); // Return ownership to backend } toAdd.trips.clear(); @@ -300,7 +301,7 @@ static void moveDivesBetweenTrips(DivesToTrip &dives) for (OwningTripPtr &trip: dives.tripsToAdd) { dive_trip *t = trip.release(); // Give up ownership createdTrips.push_back(t); - insert_trip(t, &trip_table); // Return ownership to backend + insert_trip(t, divelog.trips); // Return ownership to backend } dives.tripsToAdd.clear(); @@ -430,7 +431,7 @@ AddDive::AddDive(dive *d, bool autogroup, bool newNumber) allocTrip.reset(trip); } - int idx = dive_table_get_insertion_index(&dive_table, divePtr.get()); + int idx = dive_table_get_insertion_index(divelog.dives, divePtr.get()); if (newNumber) divePtr->number = get_dive_nr_at_idx(idx); @@ -451,7 +452,7 @@ void AddDive::redoit() currentDive = current_dive; divesAndSitesToRemove = addDives(divesToAdd); - sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips + sort_trip_table(divelog.trips); // Though unlikely, adding a dive may reorder trips // Select the newly added dive setSelection(divesAndSitesToRemove.dives, divesAndSitesToRemove.dives[0]); @@ -461,7 +462,7 @@ void AddDive::undoit() { // Simply remove the dive that was previously added... divesToAdd = removeDives(divesAndSitesToRemove); - sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips + sort_trip_table(divelog.trips); // Though unlikely, removing a dive may reorder trips // ...and restore the selection setSelection(selection, currentDive); @@ -517,9 +518,9 @@ ImportDives::ImportDives(struct dive_table *dives, struct trip_table *trips, str if (filter_presets) { for (const filter_preset &preset: *filter_presets) { QString name = preset.name; - auto it = std::find_if(filter_preset_table.begin(), filter_preset_table.end(), + auto it = std::find_if(divelog.filter_presets->begin(), divelog.filter_presets->end(), [&name](const filter_preset &preset) { return preset.name == name; }); - if (it != filter_preset_table.end() && it->data == preset.data) + if (it != divelog.filter_presets->end() && it->data == preset.data) continue; filterPresetsToAdd.emplace_back(preset.name, preset.data); } @@ -553,7 +554,7 @@ void ImportDives::redoit() // Add devices for (const device &dev: devicesToAddAndRemove.devices) - add_to_device_table(&device_table, &dev); + add_to_device_table(divelog.devices, &dev); // Add new filter presets for (auto &it: filterPresetsToAdd) { @@ -581,7 +582,7 @@ void ImportDives::undoit() // Remove devices for (const device &dev: devicesToAddAndRemove.devices) - remove_device(&device_table, &dev); + remove_device(divelog.devices, &dev); // Remove filter presets. Do this in reverse order. for (auto it = filterPresetsToRemove.rbegin(); it != filterPresetsToRemove.rend(); ++it) { @@ -610,7 +611,7 @@ bool DeleteDive::workToBeDone() void DeleteDive::undoit() { divesToDelete = addDives(divesToAdd); - sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips + sort_trip_table(divelog.trips); // Though unlikely, removing a dive may reorder trips // Select all re-added dives and make the first one current dive *currentDive = !divesToDelete.dives.empty() ? divesToDelete.dives[0] : nullptr; @@ -620,7 +621,7 @@ void DeleteDive::undoit() void DeleteDive::redoit() { divesToAdd = removeDives(divesToDelete); - sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips + sort_trip_table(divelog.trips); // Though unlikely, adding a dive may reorder trips // Deselect all dives and select dive that was close to the first deleted dive dive *newCurrent = nullptr; @@ -648,8 +649,8 @@ void ShiftTime::redoit() } // Changing times may have unsorted the dive and trip tables - sort_dive_table(&dive_table); - sort_trip_table(&trip_table); + sort_dive_table(divelog.dives); + sort_trip_table(divelog.trips); for (dive_trip *trip: trips) sort_dive_table(&trip->dives); // Keep the trip-table in order @@ -717,7 +718,7 @@ bool TripBase::workToBeDone() void TripBase::redoit() { moveDivesBetweenTrips(divesToMove); - sort_trip_table(&trip_table); // Though unlikely, moving dives may reorder trips + sort_trip_table(divelog.trips); // Though unlikely, moving dives may reorder trips // Select the moved dives std::vector dives; @@ -790,7 +791,7 @@ AutogroupDives::AutogroupDives() dive_trip *trip; bool alloc; int from, to; - for(int i = 0; (trip = get_dives_to_autogroup(&dive_table, i, &from, &to, &alloc)) != NULL; i = to) { + for(int i = 0; (trip = get_dives_to_autogroup(divelog.dives, i, &from, &to, &alloc)) != NULL; i = to) { // If this is an allocated trip, take ownership if (alloc) divesToMove.tripsToAdd.emplace_back(trip); @@ -1009,7 +1010,7 @@ MergeDives::MergeDives(const QVector &dives) // like the best option. int idx = get_divenr(dives[0]); int num = dives.count(); - if (idx < 0 || idx + num > dive_table.nr) { + if (idx < 0 || idx + num > divelog.dives->nr) { // It was the callers responsibility to pass only known dives. // Something is seriously wrong - give up. qWarning("Merging unknown dives"); @@ -1017,7 +1018,7 @@ MergeDives::MergeDives(const QVector &dives) } // std::equal compares two ranges. The parameters are (begin_range1, end_range1, begin_range2). // Here, we can compare C-arrays, because QVector guarantees contiguous storage. - if (std::equal(&dives[0], &dives[0] + num, &dive_table.dives[idx]) && + if (std::equal(&dives[0], &dives[0] + num, &divelog.dives->dives[idx]) && dives[0]->number && dives.last()->number && dives[0]->number < dives.last()->number) { // We have a consecutive set of dives. Rename all following dives according to the // number of erased dives. This considers that there might be missing numbers. @@ -1033,15 +1034,15 @@ MergeDives::MergeDives(const QVector &dives) // consecutive, and the difference will be 1, so the // above example is not supposed to be normal. int diff = dives.last()->number - dives[0]->number; - divesToRenumber.reserve(dive_table.nr - idx - num); + divesToRenumber.reserve(divelog.dives->nr - idx - num); int previousnr = dives[0]->number; - for (int i = idx + num; i < dive_table.nr; ++i) { - int newnr = dive_table.dives[i]->number - diff; + for (int i = idx + num; i < divelog.dives->nr; ++i) { + int newnr = divelog.dives->dives[i]->number - diff; // Stop renumbering if stuff isn't in order (see also core/divelist.c) if (newnr <= previousnr) break; - divesToRenumber.append(QPair(dive_table.dives[i], newnr)); + divesToRenumber.append(QPair(divelog.dives->dives[i], newnr)); previousnr = newnr; } } diff --git a/commands/command_divesite.cpp b/commands/command_divesite.cpp index 39e10e840..b89bb0b86 100644 --- a/commands/command_divesite.cpp +++ b/commands/command_divesite.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "command_divesite.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/subsurface-qt/divelistnotifier.h" #include "core/qthelper.h" @@ -154,8 +155,8 @@ void DeleteDiveSites::undo() PurgeUnusedDiveSites::PurgeUnusedDiveSites() { setText(Command::Base::tr("purge unused dive sites")); - for (int i = 0; i < dive_site_table.nr; ++i) { - dive_site *ds = dive_site_table.dive_sites[i]; + for (int i = 0; i < divelog.sites->nr; ++i) { + dive_site *ds = divelog.sites->dive_sites[i]; if (ds->dives.nr == 0) sitesToRemove.push_back(ds); } @@ -404,7 +405,7 @@ ApplyGPSFixes::ApplyGPSFixes(const std::vector &fixes) siteLocations.push_back({ ds, dl.location }); } } else { - ds = create_dive_site(qPrintable(dl.name), &dive_site_table); + ds = create_dive_site(qPrintable(dl.name), divelog.sites); ds->location = dl.location; add_dive_to_dive_site(dl.d, ds); dl.d->dive_site = nullptr; // This will be set on redo() diff --git a/commands/command_edit.cpp b/commands/command_edit.cpp index 09d7f40b9..981d9ec66 100644 --- a/commands/command_edit.cpp +++ b/commands/command_edit.cpp @@ -2,6 +2,7 @@ #include "command_edit.h" #include "core/divelist.h" +#include "core/divelog.h" #include "core/fulltext.h" #include "core/qthelper.h" // for copy_qstring #include "core/sample.h" @@ -1507,8 +1508,8 @@ void EditDive::exchangeDives() QVector dives = { oldDive }; timestamp_t delta = oldDive->when - newDive->when; if (delta != 0) { - sort_dive_table(&dive_table); - sort_trip_table(&trip_table); + sort_dive_table(divelog.dives); + sort_trip_table(divelog.trips); if (newDive->divetrip != oldDive->divetrip) qWarning("Command::EditDive::redo(): This command does not support moving between trips!"); if (oldDive->divetrip) diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt index 6c046fa61..ba5b2ee23 100644 --- a/core/CMakeLists.txt +++ b/core/CMakeLists.txt @@ -68,6 +68,8 @@ set(SUBSURFACE_CORE_LIB_SRCS divefilter.h divelist.c divelist.h + divelog.cpp + divelog.h divelogexportlogic.cpp divelogexportlogic.h divesite-helper.cpp diff --git a/core/cochran.c b/core/cochran.c index 4451ff8a2..7bc1f5fd6 100644 --- a/core/cochran.c +++ b/core/cochran.c @@ -22,6 +22,7 @@ #include "gettext.h" #include "cochran.h" #include "divelist.h" +#include "divelog.h" #include @@ -799,11 +800,9 @@ static void cochran_parse_dive(const unsigned char *decode, unsigned mod, free(buf); } -int try_to_open_cochran(const char *filename, struct memblock *mem, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites) +int try_to_open_cochran(const char *filename, struct memblock *mem, struct divelog *log) { UNUSED(filename); - UNUSED(trips); - UNUSED(sites); unsigned int i; unsigned int mod; unsigned int *offsets, dive1, dive2; @@ -832,7 +831,7 @@ int try_to_open_cochran(const char *filename, struct memblock *mem, struct dive_ break; cochran_parse_dive(decode, mod, mem->buffer + dive1, - dive2 - dive1, table); + dive2 - dive1, log->dives); } return 1; // no further processing needed diff --git a/core/datatrak.c b/core/datatrak.c index 01b03615d..caf48ca04 100644 --- a/core/datatrak.c +++ b/core/datatrak.c @@ -17,6 +17,7 @@ #include "file.h" #include "divesite.h" #include "dive.h" +#include "divelog.h" #include "errorhelper.h" #include "ssrf.h" #include "tag.h" @@ -679,10 +680,8 @@ static void wlog_compl_parser(struct memblock *wl_mem, struct dive *dt_dive, int * Main function call from file.c memblock is allocated (and freed) there. * If parsing is aborted due to errors, stores correctly parsed dives. */ -int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices) +int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct divelog *log) { - UNUSED(trips); unsigned char *runner; int i = 0, numdives = 0, rc = 0; @@ -712,7 +711,7 @@ int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct dive_t while ((i < numdives) && ((long) runner < maxbuf)) { struct dive *ptdive = alloc_dive(); - runner = dt_dive_parser(runner, ptdive, sites, devices, maxbuf); + runner = dt_dive_parser(runner, ptdive, log->sites, log->devices, maxbuf); if (wl_mem) wlog_compl_parser(wl_mem, ptdive, i); if (runner == NULL) { @@ -721,13 +720,13 @@ int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct dive_t rc = 1; goto out; } else { - record_dive_to_table(ptdive, table); + record_dive_to_table(ptdive, log->dives); } i++; } out: taglist_cleanup(&g_tag_list); - sort_dive_table(table); + sort_dive_table(log->dives); return rc; bail: return 1; diff --git a/core/device.cpp b/core/device.cpp index 61e62c938..1125c686f 100644 --- a/core/device.cpp +++ b/core/device.cpp @@ -2,12 +2,12 @@ #include "device.h" #include "dive.h" #include "divelist.h" +#include "divelog.h" #include "subsurface-string.h" #include "errorhelper.h" // for verbose flag #include "selection.h" #include "core/settings/qPrefDiveComputer.h" -struct device_table device_table; struct fingerprint_table fingerprint_table; static bool same_device(const device &dev1, const device &dev2) @@ -140,7 +140,7 @@ extern "C" int is_default_dive_computer_device(const char *name) const char *get_dc_nickname(const struct divecomputer *dc) { - const device *existNode = get_device_for_dc(&device_table, dc); + const device *existNode = get_device_for_dc(divelog.devices, dc); if (existNode && !existNode->nickName.empty()) return existNode->nickName.c_str(); diff --git a/core/device.h b/core/device.h index 147c94bc4..2abd0aa14 100644 --- a/core/device.h +++ b/core/device.h @@ -14,7 +14,6 @@ struct device_table; struct dive_table; // global device table -extern struct device_table device_table; extern struct fingerprint_table fingerprint_table; extern int create_device_node(struct device_table *table, const char *model, const char *serial, const char *nickname); diff --git a/core/dive.c b/core/dive.c index 5d43ce2d7..a196b398b 100644 --- a/core/dive.c +++ b/core/dive.c @@ -11,6 +11,7 @@ #include "libdivecomputer.h" #include "device.h" #include "divelist.h" +#include "divelog.h" #include "divesite.h" #include "errorhelper.h" #include "event.h" @@ -2859,7 +2860,7 @@ static int split_dive_at(const struct dive *dive, int a, int b, struct dive **ou * Otherwise the tail is unnumbered. */ if (d2->number) { - if (dive_table.nr == nr + 1) + if (divelog.dives->nr == nr + 1) d2->number++; else d2->number = 0; @@ -3331,9 +3332,9 @@ depth_t gas_mnd(struct gasmix mix, depth_t end, const struct dive *dive, int rou struct dive *get_dive(int nr) { - if (nr >= dive_table.nr || nr < 0) + if (nr >= divelog.dives->nr || nr < 0) return NULL; - return dive_table.dives[nr]; + return divelog.dives->dives[nr]; } struct dive_site *get_dive_site_for_dive(const struct dive *dive) diff --git a/core/divefilter.cpp b/core/divefilter.cpp index d9a8a48ae..48e16b48b 100644 --- a/core/divefilter.cpp +++ b/core/divefilter.cpp @@ -2,6 +2,7 @@ #include "divefilter.h" #include "divelist.h" +#include "divelog.h" #include "gettextfromc.h" #include "qthelper.h" #include "selection.h" @@ -73,7 +74,7 @@ void DiveFilter::reset() { int i; dive *d; - shown_dives = dive_table.nr; + shown_dives = divelog.dives->nr; for_each_dive(i, d) d->hidden_by_filter = false; updateAll(); @@ -201,10 +202,11 @@ bool DiveFilter::diveSiteMode() const QString DiveFilter::shownText() const { + int num = divelog.dives->nr; if (diveSiteMode() || filterData.validFilter()) - return gettextFromC::tr("%L1/%L2 shown").arg(shown_dives).arg(dive_table.nr); + return gettextFromC::tr("%L1/%L2 shown").arg(shown_dives).arg(num); else - return gettextFromC::tr("%L1 dives").arg(dive_table.nr); + return gettextFromC::tr("%L1 dives").arg(num); } int DiveFilter::shownDives() const diff --git a/core/divelist.c b/core/divelist.c index 811a80f00..1177d6b2c 100644 --- a/core/divelist.c +++ b/core/divelist.c @@ -5,8 +5,9 @@ #include "subsurface-string.h" #include "deco.h" #include "device.h" -#include "divesite.h" #include "dive.h" +#include "divelog.h" +#include "divesite.h" #include "event.h" #include "eventname.h" #include "filterpreset.h" @@ -226,7 +227,7 @@ static int calculate_cns(struct dive *dive) return dive->cns; divenr = get_divenr(dive); - i = divenr >= 0 ? divenr : dive_table.nr; + i = divenr >= 0 ? divenr : divelog.dives->nr; #if DECO_CALC_DEBUG & 2 if (i >= 0 && i < dive_table.nr) printf("\n\n*** CNS for dive #%d %d\n", i, get_dive(i)->number); @@ -234,7 +235,7 @@ static int calculate_cns(struct dive *dive) printf("\n\n*** CNS for dive #%d\n", i); #endif /* Look at next dive in dive list table and correct i when needed */ - while (i < dive_table.nr - 1) { + while (i < divelog.dives->nr - 1) { struct dive *pdive = get_dive(i); if (!pdive || pdive->when > dive->when) break; @@ -279,7 +280,7 @@ static int calculate_cns(struct dive *dive) #endif } /* Walk forward and add dives and surface intervals to CNS */ - while (++i < dive_table.nr) { + while (++i < divelog.dives->nr) { #if DECO_CALC_DEBUG & 2 printf("Check if dive #%d %d will be really added to CNS calc: ", i, get_dive(i)->number); #endif @@ -463,7 +464,7 @@ int init_decompression(struct deco_state *ds, const struct dive *dive, bool in_p return false; divenr = get_divenr(dive); - i = divenr >= 0 ? divenr : dive_table.nr; + i = divenr >= 0 ? divenr : divelog.dives->nr; #if DECO_CALC_DEBUG & 2 if (i >= 0 && i < dive_table.nr) printf("\n\n*** Init deco for dive #%d %d\n", i, get_dive(i)->number); @@ -471,7 +472,7 @@ int init_decompression(struct deco_state *ds, const struct dive *dive, bool in_p printf("\n\n*** Init deco for dive #%d\n", i); #endif /* Look at next dive in dive list table and correct i when needed */ - while (i < dive_table.nr - 1) { + while (i < divelog.dives->nr - 1) { struct dive *pdive = get_dive(i); if (!pdive || pdive->when > dive->when) break; @@ -516,7 +517,7 @@ int init_decompression(struct deco_state *ds, const struct dive *dive, bool in_p #endif } /* Walk forward an add dives and surface intervals to deco */ - while (++i < dive_table.nr) { + while (++i < divelog.dives->nr) { #if DECO_CALC_DEBUG & 2 printf("Check if dive #%d %d will be really added to deco calc: ", i, get_dive(i)->number); #endif @@ -767,7 +768,7 @@ struct dive *unregister_dive(int idx) /* When removing a dive from the global dive table, * we also have to unregister its fulltext cache. */ fulltext_unregister(dive); - remove_from_dive_table(&dive_table, idx); + remove_from_dive_table(divelog.dives, idx); if (dive->selected) amount_selected--; dive->selected = false; @@ -783,18 +784,18 @@ void delete_single_dive(int idx) return; /* this should never happen */ if (dive->selected) deselect_dive(dive); - remove_dive_from_trip(dive, &trip_table); + remove_dive_from_trip(dive, divelog.trips); unregister_dive_from_dive_site(dive); - delete_dive_from_table(&dive_table, idx); + delete_dive_from_table(divelog.dives, idx); } void process_loaded_dives() { - sort_dive_table(&dive_table); - sort_trip_table(&trip_table); + sort_dive_table(divelog.dives); + sort_trip_table(divelog.trips); /* Autogroup dives if desired by user. */ - autogroup_dives(&dive_table, &trip_table); + autogroup_dives(divelog.dives, divelog.trips); fulltext_populate(); @@ -876,9 +877,9 @@ static bool try_to_merge_into(struct dive *dive_to_add, int idx, struct dive_tab /* Check if a dive is ranked after the last dive of the global dive list */ static bool dive_is_after_last(struct dive *d) { - if (dive_table.nr == 0) + if (divelog.dives->nr == 0) return true; - return dive_less_than(dive_table.dives[dive_table.nr - 1], d); + return dive_less_than(divelog.dives->dives[divelog.dives->nr - 1], d); } /* Merge dives from "dives_from" into "dives_to". Overlapping dives will be merged, @@ -967,9 +968,7 @@ 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 */ -void add_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, - struct dive_site_table *import_sites_table, struct device_table *import_device_table, - int flags) +void add_imported_dives(struct divelog *import_log, int flags) { int i, idx; struct dive_table dives_to_add = empty_dive_table; @@ -980,7 +979,7 @@ void add_imported_dives(struct dive_table *import_table, struct trip_table *impo /* Process imported dives and generate lists of dives * to-be-added and to-be-removed */ - process_imported_dives(import_table, import_trip_table, import_sites_table, import_device_table, + process_imported_dives(import_log->dives, import_log->trips, import_log->sites, import_log->devices, flags, &dives_to_add, &dives_to_remove, &trips_to_add, &dive_sites_to_add, devices_to_add); @@ -1004,12 +1003,12 @@ void add_imported_dives(struct dive_table *import_table, struct trip_table *impo /* Add new dives */ for (i = 0; i < dives_to_add.nr; i++) - insert_dive(&dive_table, dives_to_add.dives[i]); + insert_dive(divelog.dives, dives_to_add.dives[i]); dives_to_add.nr = 0; /* Add new trips */ for (i = 0; i < trips_to_add.nr; i++) - insert_trip(trips_to_add.trips[i], &trip_table); + insert_trip(trips_to_add.trips[i], divelog.trips); trips_to_add.nr = 0; /* Add new dive sites */ @@ -1020,12 +1019,12 @@ void add_imported_dives(struct dive_table *import_table, struct trip_table *impo /* Add new devices */ for (i = 0; i < nr_devices(devices_to_add); i++) { const struct device *dev = get_device(devices_to_add, i); - add_to_device_table(&device_table, dev); + add_to_device_table(divelog.devices, dev); } /* 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; + current_dive = divelog.dives->nr > 0 ? divelog.dives->dives[divelog.dives->nr - 1] : NULL; free_device_table(devices_to_add); @@ -1051,8 +1050,8 @@ bool try_to_merge_trip(struct dive_trip *trip_import, struct dive_table *import_ int i; struct dive_trip *trip_old; - for (i = 0; i < trip_table.nr; i++) { - trip_old = trip_table.trips[i]; + for (i = 0; i < divelog.trips->nr; i++) { + trip_old = divelog.trips->trips[i]; if (trips_overlap(trip_import, trip_old)) { *sequence_changed |= merge_dive_tables(&trip_import->dives, import_table, &trip_old->dives, prefer_imported, trip_old, @@ -1144,7 +1143,7 @@ void process_imported_dives(struct dive_table *import_table, struct trip_table * /* Add only the devices that we don't know about yet. */ for (i = 0; i < nr_devices(import_device_table); i++) { const struct device *dev = get_device(import_device_table, i); - if (!device_exists(&device_table, dev)) + if (!device_exists(divelog.devices, dev)) add_to_device_table(devices_to_add, dev); } @@ -1237,7 +1236,7 @@ void process_imported_dives(struct dive_table *import_table, struct trip_table * /* The remaining dives in import_table are those that don't belong to * a trip and the caller does not want them to be associated to a * new trip. Merge them into the global table. */ - sequence_changed |= merge_dive_tables(import_table, NULL, &dive_table, flags & IMPORT_PREFER_IMPORTED, NULL, + sequence_changed |= merge_dive_tables(import_table, NULL, divelog.dives, flags & IMPORT_PREFER_IMPORTED, NULL, dives_to_add, dives_to_remove, &start_renumbering_at); } @@ -1246,13 +1245,13 @@ void process_imported_dives(struct dive_table *import_table, struct trip_table * * - The last dive in the old dive table had a number itself (if there is a last dive). * - None of the new dives has a number. */ - last_old_dive_is_numbered = dive_table.nr == 0 || dive_table.dives[dive_table.nr - 1]->number > 0; + last_old_dive_is_numbered = divelog.dives->nr == 0 || divelog.dives->dives[divelog.dives->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 && last_old_dive_is_numbered && !new_dive_has_number) { - nr = dive_table.nr > 0 ? dive_table.dives[dive_table.nr - 1]->number : 0; + nr = divelog.dives->nr > 0 ? divelog.dives->dives[divelog.dives->nr - 1]->number : 0; for (i = start_renumbering_at; i < dives_to_add->nr; i++) dives_to_add->dives[i]->number = ++nr; } @@ -1261,9 +1260,9 @@ void process_imported_dives(struct dive_table *import_table, struct trip_table * static struct dive *get_last_valid_dive() { int i; - for (i = dive_table.nr - 1; i >= 0; i--) { - if (!dive_table.dives[i]->invalid) - return dive_table.dives[i]; + for (i = divelog.dives->nr - 1; i >= 0; i--) { + if (!divelog.dives->dives[i]->invalid) + return divelog.dives->dives[i]; } return NULL; } @@ -1277,7 +1276,7 @@ static struct dive *get_last_valid_dive() */ int get_dive_nr_at_idx(int idx) { - if (idx < dive_table.nr) + if (idx < divelog.dives->nr) return 0; struct dive *last_dive = get_last_valid_dive(); if (!last_dive) @@ -1306,27 +1305,27 @@ void report_datafile_version(int version) int get_dive_id_closest_to(timestamp_t when) { int i; - int nr = dive_table.nr; + int nr = divelog.dives->nr; // deal with pathological cases if (nr == 0) return 0; else if (nr == 1) - return dive_table.dives[0]->id; + return divelog.dives->dives[0]->id; - for (i = 0; i < nr && dive_table.dives[i]->when <= when; i++) + for (i = 0; i < nr && divelog.dives->dives[i]->when <= when; i++) ; // nothing // again, capture the two edge cases first if (i == nr) - return dive_table.dives[i - 1]->id; + return divelog.dives->dives[i - 1]->id; else if (i == 0) - return dive_table.dives[0]->id; + return divelog.dives->dives[0]->id; - if (when - dive_table.dives[i - 1]->when < dive_table.dives[i]->when - when) - return dive_table.dives[i - 1]->id; + if (when - divelog.dives->dives[i - 1]->when < divelog.dives->dives[i]->when - when) + return divelog.dives->dives[i - 1]->id; else - return dive_table.dives[i]->id; + return divelog.dives->dives[i]->id; } void clear_dive_file_data() @@ -1334,20 +1333,11 @@ void clear_dive_file_data() fulltext_unregister_all(); select_single_dive(NULL); // This is propagate up to the UI and clears all the information. - while (dive_table.nr) - delete_single_dive(0); current_dive = NULL; - while (dive_site_table.nr) - delete_dive_site(get_dive_site(0, &dive_site_table), &dive_site_table); - if (trip_table.nr != 0) { - fprintf(stderr, "Warning: trip table not empty in clear_dive_file_data()!\n"); - trip_table.nr = 0; - } + clear_divelog(&divelog); clear_dive(&displayed_dive); - clear_device_table(&device_table); clear_event_names(); - clear_filter_presets(); reset_min_datafile_version(); clear_git_id(); @@ -1418,14 +1408,14 @@ timestamp_t get_surface_interval(timestamp_t when) timestamp_t prev_end; /* find previous dive. might want to use a binary search. */ - for (i = dive_table.nr - 1; i >= 0; --i) { - if (dive_table.dives[i]->when < when) + for (i = divelog.dives->nr - 1; i >= 0; --i) { + if (divelog.dives->dives[i]->when < when) break; } if (i < 0) return -1; - prev_end = dive_endtime(dive_table.dives[i]); + prev_end = dive_endtime(divelog.dives->dives[i]); if (prev_end > when) return 0; return when - prev_end; @@ -1437,11 +1427,11 @@ struct dive *find_next_visible_dive(timestamp_t when) { int i, j; - if (!dive_table.nr) + if (!divelog.dives->nr) return NULL; /* we might want to use binary search here */ - for (i = 0; i < dive_table.nr; i++) { + for (i = 0; i < divelog.dives->nr; i++) { if (when <= get_dive(i)->when) break; } @@ -1451,7 +1441,7 @@ struct dive *find_next_visible_dive(timestamp_t when) return get_dive(j); } - for (j = i; j < dive_table.nr; j++) { + for (j = i; j < divelog.dives->nr; j++) { if (!get_dive(j)->hidden_by_filter) return get_dive(j); } diff --git a/core/divelist.h b/core/divelist.h index 2876407ab..b084b988a 100644 --- a/core/divelist.h +++ b/core/divelist.h @@ -9,6 +9,7 @@ extern "C" { #endif struct dive; +struct divelog; struct trip_table; struct dive_site_table; struct device_table; @@ -19,7 +20,6 @@ struct dive_table { struct dive **dives; }; static const struct dive_table empty_dive_table = { 0, 0, (struct dive **)0 }; -extern struct dive_table dive_table; /* this is used for both git and xml format */ #define DATAFORMAT_VERSION 3 @@ -35,9 +35,7 @@ extern void process_loaded_dives(); #define IMPORT_IS_DOWNLOADED (1 << 1) #define IMPORT_MERGE_ALL_TRIPS (1 << 2) #define IMPORT_ADD_TO_NEW_TRIP (1 << 3) -extern void add_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, - struct dive_site_table *import_sites_table, struct device_table *devices_to_add, - int flags); +extern void add_imported_dives(struct divelog *log, int flags); extern void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, struct dive_site_table *import_sites_table, struct device_table *import_devices_table, int flags, diff --git a/core/divelog.cpp b/core/divelog.cpp new file mode 100644 index 000000000..4b3fb3483 --- /dev/null +++ b/core/divelog.cpp @@ -0,0 +1,56 @@ +// SPDX-License-Identifier: GPL-2.0 +#include "divelog.h" +#include "divelist.h" +#include "divesite.h" +#include "device.h" +#include "filterpreset.h" +#include "trip.h" + +struct divelog divelog; + +// We can't use smart pointers, since this is used from C +// and it would be bold to presume that std::unique_ptr<> +// and a plain pointer have the same memory layout. +divelog::divelog() : + dives(new dive_table), + trips(new trip_table), + sites(new dive_site_table), + devices(new device_table), + filter_presets(new filter_preset_table), + autogroup(false) +{ + *dives = empty_dive_table; + *trips = empty_trip_table; + *sites = empty_dive_site_table; +} + +divelog::~divelog() +{ + clear_dive_table(dives); + clear_trip_table(trips); + clear_dive_site_table(sites); + delete dives; + delete trips; + delete sites; + delete devices; + delete filter_presets; +} + +void divelog::clear() +{ + while (dives->nr) + delete_single_dive(0); + while (sites->nr) + delete_dive_site(get_dive_site(0, sites), sites); + if (trips->nr != 0) { + fprintf(stderr, "Warning: trip table not empty in divelog::clear()!\n"); + trips->nr = 0; + } + clear_device_table(devices); + filter_presets->clear(); +} + +extern "C" void clear_divelog(struct divelog *log) +{ + log->clear(); +} diff --git a/core/divelog.h b/core/divelog.h new file mode 100644 index 000000000..fd2ca014a --- /dev/null +++ b/core/divelog.h @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: GPL-2.0 +// A structure that contains all the values we save in a divelog file +#ifndef DIVELOG_H +#define DIVELOG_H + +struct dive_table; +struct trip_table; +struct dive_site_table; +struct device_table; +struct filter_preset_table; + +#include + +struct divelog { + struct dive_table *dives; + struct trip_table *trips; + struct dive_site_table *sites; + struct device_table *devices; + struct filter_preset_table *filter_presets; + bool autogroup; +#ifdef __cplusplus + void clear(); + divelog(); + ~divelog(); +#endif +}; + +extern struct divelog divelog; + +#ifdef __cplusplus +extern "C" { +#endif + +void clear_divelog(struct divelog *); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/core/divesite.c b/core/divesite.c index 89c894951..46aceb79a 100644 --- a/core/divesite.c +++ b/core/divesite.c @@ -2,16 +2,15 @@ /* divesite.c */ #include "divesite.h" #include "dive.h" -#include "subsurface-string.h" #include "divelist.h" +#include "divelog.h" #include "membuffer.h" +#include "subsurface-string.h" #include "table.h" #include "sha1.h" #include -struct dive_site_table dive_site_table; - int get_divesite_idx(const struct dive_site *ds, struct dive_site_table *ds_table) { int i; @@ -110,7 +109,7 @@ struct dive_site *get_dive_site_by_gps_proximity(const location_t *loc, int dist int register_dive_site(struct dive_site *ds) { - return add_dive_site_to_table(ds, &dive_site_table); + return add_dive_site_to_table(ds, divelog.sites); } static int compare_sites(const struct dive_site *a, const struct dive_site *b) @@ -232,7 +231,7 @@ void free_dive_site(struct dive_site *ds) int unregister_dive_site(struct dive_site *ds) { - return remove_dive_site(ds, &dive_site_table); + return remove_dive_site(ds, divelog.sites); } void delete_dive_site(struct dive_site *ds, struct dive_site_table *ds_table) @@ -319,7 +318,7 @@ struct dive_site *get_same_dive_site(const struct dive_site *site) { int i; struct dive_site *ds; - for_each_dive_site (i, ds, &dive_site_table) + for_each_dive_site (i, ds, divelog.sites) if (same_dive_site(ds, site)) return ds; return NULL; diff --git a/core/divesite.h b/core/divesite.h index b143ccef6..a5ddefd8d 100644 --- a/core/divesite.h +++ b/core/divesite.h @@ -33,8 +33,6 @@ typedef struct dive_site_table { static const dive_site_table_t empty_dive_site_table = { 0, 0, (struct dive_site **)0 }; -extern struct dive_site_table dive_site_table; - static inline struct dive_site *get_dive_site(int nr, struct dive_site_table *ds_table) { if (nr >= ds_table->nr || nr < 0) diff --git a/core/equipment.c b/core/equipment.c index 3b6936ade..285049571 100644 --- a/core/equipment.c +++ b/core/equipment.c @@ -15,6 +15,7 @@ #include "gettext.h" #include "dive.h" #include "divelist.h" +#include "divelog.h" #include "pref.h" #include "subsurface-string.h" #include "table.h" @@ -305,8 +306,8 @@ void reset_tank_info_table(struct tank_info_table *table) add_default_tank_infos(table); /* Add cylinders from dive list */ - for (int i = 0; i < dive_table.nr; ++i) { - const struct dive *dive = dive_table.dives[i]; + for (int i = 0; i < divelog.dives->nr; ++i) { + const struct dive *dive = divelog.dives->dives[i]; for (int j = 0; j < dive->cylinders.nr; j++) { const cylinder_t *cyl = get_cylinder(dive, j); add_cylinder_description(&cyl->type); diff --git a/core/file.c b/core/file.c index dbd51a7b9..cdd9676b4 100644 --- a/core/file.c +++ b/core/file.c @@ -11,6 +11,7 @@ #include #include "dive.h" +#include "divelog.h" #include "subsurface-string.h" #include "errorhelper.h" #include "file.h" @@ -76,8 +77,7 @@ out: } -static void zip_read(struct zip_file *file, const char *filename, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices, struct filter_preset_table *filter_presets) +static void zip_read(struct zip_file *file, const char *filename, struct divelog *log) { int size = 1024, n, read = 0; char *mem = malloc(size); @@ -88,12 +88,11 @@ static void zip_read(struct zip_file *file, const char *filename, struct dive_ta mem = realloc(mem, size); } mem[read] = 0; - (void) parse_xml_buffer(filename, mem, read, table, trips, sites, devices, filter_presets, NULL); + (void) parse_xml_buffer(filename, mem, read, log, NULL); free(mem); } -int try_to_open_zip(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +int try_to_open_zip(const char *filename, struct divelog *log) { int success = 0; /* Grr. libzip needs to re-open the file, it can't take a buffer */ @@ -108,7 +107,7 @@ int try_to_open_zip(const char *filename, struct dive_table *table, struct trip_ /* skip parsing the divelogs.de pictures */ if (strstr(zip_get_name(zip, index, 0), "pictures/")) continue; - zip_read(file, filename, table, trips, sites, devices, filter_presets); + zip_read(file, filename, log); zip_fclose(file); success++; } @@ -128,8 +127,7 @@ static int db_test_func(void *param, int columns, char **data, char **column) return *data[0] == '0'; } -static int try_to_open_db(const char *filename, struct memblock *mem, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices) +static int try_to_open_db(const char *filename, struct memblock *mem, struct divelog *log) { sqlite3 *handle; char dm4_test[] = "select count(*) from sqlite_master where type='table' and name='Dive' and sql like '%ProfileBlob%'"; @@ -151,7 +149,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Suunto DM5 database format */ retval = sqlite3_exec(handle, dm5_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_dm5_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_dm5_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -159,7 +157,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Suunto DM4 database format */ retval = sqlite3_exec(handle, dm4_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_dm4_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_dm4_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -167,7 +165,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Shearwater database format */ retval = sqlite3_exec(handle, shearwater_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_shearwater_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_shearwater_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -175,7 +173,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Shearwater cloud database format */ retval = sqlite3_exec(handle, shearwater_cloud_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_shearwater_cloud_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_shearwater_cloud_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -183,7 +181,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Atomic Cobalt database format */ retval = sqlite3_exec(handle, cobalt_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_cobalt_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_cobalt_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -191,7 +189,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Divinglog database format */ retval = sqlite3_exec(handle, divinglog_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_divinglog_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_divinglog_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -199,7 +197,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div /* Testing if DB schema resembles Seac database format */ retval = sqlite3_exec(handle, seacsync_test, &db_test_func, 0, NULL); if (!retval) { - retval = parse_seac_buffer(handle, filename, mem->buffer, mem->size, table, trips, sites, devices); + retval = parse_seac_buffer(handle, filename, mem->buffer, mem->size, log); sqlite3_close(handle); return retval; } @@ -226,9 +224,7 @@ static int try_to_open_db(const char *filename, struct memblock *mem, struct div * * Followed by the data values (all comma-separated, all one long line). */ -static int open_by_filename(const char *filename, const char *fmt, struct memblock *mem, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +static int open_by_filename(const char *filename, const char *fmt, struct memblock *mem, struct divelog *log) { // hack to be able to provide a comment for the translated string static char *csv_warning = QT_TRANSLATE_NOOP3("gettextFromC", @@ -237,40 +233,38 @@ static int open_by_filename(const char *filename, const char *fmt, struct memblo /* Suunto Dive Manager files: SDE, ZIP; divelogs.de files: DLD */ if (!strcasecmp(fmt, "SDE") || !strcasecmp(fmt, "ZIP") || !strcasecmp(fmt, "DLD")) - return try_to_open_zip(filename, table, trips, sites, devices, filter_presets); + return try_to_open_zip(filename, log); /* CSV files */ if (!strcasecmp(fmt, "CSV")) return report_error(translate("gettextFromC", csv_warning), filename); /* Truly nasty intentionally obfuscated Cochran Anal software */ if (!strcasecmp(fmt, "CAN")) - return try_to_open_cochran(filename, mem, table, trips, sites); + return try_to_open_cochran(filename, mem, log); /* Cochran export comma-separated-value files */ if (!strcasecmp(fmt, "DPT")) - return try_to_open_csv(mem, CSV_DEPTH, table, trips, sites); + return try_to_open_csv(mem, CSV_DEPTH, log); if (!strcasecmp(fmt, "LVD")) - return try_to_open_liquivision(filename, mem, table, trips, sites); + return try_to_open_liquivision(filename, mem, log); if (!strcasecmp(fmt, "TMP")) - return try_to_open_csv(mem, CSV_TEMP, table, trips, sites); + return try_to_open_csv(mem, CSV_TEMP, log); if (!strcasecmp(fmt, "HP1")) - return try_to_open_csv(mem, CSV_PRESSURE, table, trips, sites); + return try_to_open_csv(mem, CSV_PRESSURE, log); return 0; } -static int parse_file_buffer(const char *filename, struct memblock *mem, struct dive_table *table, - struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +static int parse_file_buffer(const char *filename, struct memblock *mem, struct divelog *log) { int ret; char *fmt = strrchr(filename, '.'); - if (fmt && (ret = open_by_filename(filename, fmt + 1, mem, table, trips, sites, devices, filter_presets)) != 0) + if (fmt && (ret = open_by_filename(filename, fmt + 1, mem, log)) != 0) return ret; if (!mem->size || !mem->buffer) return report_error("Out of memory parsing file %s\n", filename); - return parse_xml_buffer(filename, mem->buffer, mem->size, table, trips, sites, devices, filter_presets, NULL); + return parse_xml_buffer(filename, mem->buffer, mem->size, log, NULL); } bool remote_repo_uptodate(const char *filename, struct git_info *info) @@ -292,8 +286,7 @@ bool remote_repo_uptodate(const char *filename, struct git_info *info) return false; } -int parse_file(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +int parse_file(const char *filename, struct divelog *log) { struct git_info info; struct memblock mem; @@ -312,7 +305,7 @@ int parse_file(const char *filename, struct dive_table *table, struct trip_table } } - ret = git_load_dives(&info, table, trips, sites, devices, filter_presets); + ret = git_load_dives(&info, log); cleanup_git_info(&info); return ret; } @@ -329,7 +322,7 @@ int parse_file(const char *filename, struct dive_table *table, struct trip_table fmt = strrchr(filename, '.'); if (fmt && (!strcasecmp(fmt + 1, "DB") || !strcasecmp(fmt + 1, "BAK") || !strcasecmp(fmt + 1, "SQL"))) { - if (!try_to_open_db(filename, &mem, table, trips, sites, devices)) { + if (!try_to_open_db(filename, &mem, log)) { free(mem.buffer); return 0; } @@ -337,7 +330,7 @@ int parse_file(const char *filename, struct dive_table *table, struct trip_table /* Divesoft Freedom */ if (fmt && (!strcasecmp(fmt + 1, "DLF"))) { - ret = parse_dlf_buffer(mem.buffer, mem.size, table, trips, sites, devices); + ret = parse_dlf_buffer(mem.buffer, mem.size, log); free(mem.buffer); return ret; } @@ -351,9 +344,9 @@ int parse_file(const char *filename, struct dive_table *table, struct trip_table wl_name = strcat(wl_name, ".add"); if((ret = readfile(wl_name, &wl_mem)) < 0) { fprintf(stderr, "No file %s found. No WLog extensions.\n", wl_name); - ret = datatrak_import(&mem, NULL, table, trips, sites, devices); + ret = datatrak_import(&mem, NULL, log); } else { - ret = datatrak_import(&mem, &wl_mem, table, trips, sites, devices); + ret = datatrak_import(&mem, &wl_mem, log); free(wl_mem.buffer); } free(mem.buffer); @@ -364,11 +357,11 @@ int parse_file(const char *filename, struct dive_table *table, struct trip_table /* OSTCtools */ if (fmt && (!strcasecmp(fmt + 1, "DIVE"))) { free(mem.buffer); - ostctools_import(filename, table, trips, sites); + ostctools_import(filename, log); return 0; } - ret = parse_file_buffer(filename, &mem, table, trips, sites, devices, filter_presets); + ret = parse_file_buffer(filename, &mem, log); free(mem.buffer); return ret; } diff --git a/core/file.h b/core/file.h index f0e001d34..7edf4572f 100644 --- a/core/file.h +++ b/core/file.h @@ -12,26 +12,20 @@ struct memblock { size_t size; }; -struct trip_table; -struct device_table; -struct dive_site_table; -struct dive_table; +struct divelog; struct zip; #ifdef __cplusplus extern "C" { #endif -extern int try_to_open_cochran(const char *filename, struct memblock *mem, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites); -extern int try_to_open_liquivision(const char *filename, struct memblock *mem, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites); -extern int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -extern void ostctools_import(const char *file, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites); +extern int try_to_open_cochran(const char *filename, struct memblock *mem, struct divelog *log); +extern int try_to_open_liquivision(const char *filename, struct memblock *mem, struct divelog *log); +extern int datatrak_import(struct memblock *mem, struct memblock *wl_mem, struct divelog *log); +extern void ostctools_import(const char *file, struct divelog *log); extern int readfile(const char *filename, struct memblock *mem); -extern int parse_file(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets); -extern int try_to_open_zip(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets); +extern int parse_file(const char *filename, struct divelog *log); +extern int try_to_open_zip(const char *filename, struct divelog *log); // Platform specific functions extern int subsurface_rename(const char *path, const char *newpath); @@ -40,7 +34,7 @@ extern int subsurface_open(const char *path, int oflags, mode_t mode); extern FILE *subsurface_fopen(const char *path, const char *mode); extern void *subsurface_opendir(const char *path); extern int subsurface_access(const char *path, int mode); -extern int subsurface_stat(const char* path, struct stat* buf); +extern int subsurface_stat(const char *path, struct stat *buf); extern struct zip *subsurface_zip_open_readonly(const char *path, int flags, int *errorp); extern int subsurface_zip_close(struct zip *zip); diff --git a/core/filterpreset.cpp b/core/filterpreset.cpp index e7534cbc7..6969f9c68 100644 --- a/core/filterpreset.cpp +++ b/core/filterpreset.cpp @@ -1,18 +1,17 @@ // SPDX-License-Identifier: GPL-2.0 #include "filterpreset.h" +#include "divelog.h" #include "qthelper.h" #include "subsurface-string.h" -struct filter_preset_table filter_preset_table; - -extern "C" void clear_filter_presets(void) +static filter_preset_table &global_table() { - filter_preset_table.clear(); + return *divelog.filter_presets; } extern "C" int filter_presets_count(void) { - return (int)filter_preset_table.size(); + return (int)global_table().size(); } extern "C" char *filter_preset_name(int preset) @@ -22,12 +21,12 @@ extern "C" char *filter_preset_name(int preset) extern "C" char *filter_preset_fulltext_query(int preset) { - return copy_qstring(filter_preset_table[preset].data.fullText.originalQuery); + return copy_qstring(global_table()[preset].data.fullText.originalQuery); } extern "C" const char *filter_preset_fulltext_mode(int preset) { - switch (filter_preset_table[preset].data.fulltextStringMode) { + switch (global_table()[preset].data.fulltextStringMode) { default: case StringFilterMode::SUBSTRING: return "substring"; @@ -51,12 +50,12 @@ extern "C" void filter_preset_set_fulltext(struct filter_preset *preset, const c extern "C" int filter_preset_constraint_count(int preset) { - return (int)filter_preset_table[preset].data.constraints.size(); + return (int)global_table()[preset].data.constraints.size(); } extern "C" const filter_constraint *filter_preset_constraint(int preset, int constraint) { - return &filter_preset_table[preset].data.constraints[constraint]; + return &global_table()[preset].data.constraints[constraint]; } extern "C" struct filter_preset *alloc_filter_preset() @@ -113,33 +112,33 @@ extern "C" void filter_preset_add_constraint(struct filter_preset *preset, const int filter_preset_id(const QString &name) { - auto it = std::find_if(filter_preset_table.begin(), filter_preset_table.end(), + auto it = std::find_if(global_table().begin(), global_table().end(), [&name] (filter_preset &p) { return p.name == name; }); - return it != filter_preset_table.end() ? it - filter_preset_table.begin() : -1; + return it != global_table().end() ? it - global_table().begin() : -1; } QString filter_preset_name_qstring(int preset) { - return filter_preset_table[preset].name; + return global_table()[preset].name; } void filter_preset_set(int preset, const FilterData &data) { - filter_preset_table[preset].data = data; + global_table()[preset].data = data; } FilterData filter_preset_get(int preset) { - return filter_preset_table[preset].data; + return global_table()[preset].data; } int filter_preset_add(const QString &nameIn, const FilterData &d) { - QString name = get_unique_preset_name(nameIn, filter_preset_table); - return filter_preset_add_to_table(name, d, filter_preset_table); + QString name = get_unique_preset_name(nameIn, global_table()); + return filter_preset_add_to_table(name, d, global_table()); } void filter_preset_delete(int preset) { - filter_preset_table.erase(filter_preset_table.begin() + preset); + global_table().erase(global_table().begin() + preset); } diff --git a/core/filterpreset.h b/core/filterpreset.h index df9b0b9ef..77fef88b1 100644 --- a/core/filterpreset.h +++ b/core/filterpreset.h @@ -32,7 +32,6 @@ struct filter_preset_table : public std::vector { }; -extern struct filter_preset_table filter_preset_table; #else struct filter_preset; struct filter_preset_table; @@ -44,7 +43,6 @@ extern "C" { #endif // The C IO code accesses the filter presets via integer indices. -extern void clear_filter_presets(void); extern int filter_presets_count(void); extern char *filter_preset_name(int preset); // name of filter preset - caller must free the result. extern char *filter_preset_fulltext_query(int preset); // fulltext query of filter preset - caller must free the result. diff --git a/core/fulltext.cpp b/core/fulltext.cpp index 9f7a78a54..f7d12d200 100644 --- a/core/fulltext.cpp +++ b/core/fulltext.cpp @@ -2,6 +2,7 @@ #include "fulltext.h" #include "dive.h" +#include "divelog.h" #include "divesite.h" #include "tag.h" #include "trip.h" @@ -155,7 +156,7 @@ void FullText::populate() dive *d; for_each_dive(i, d) registerDive(d); - uiNotification(QObject::tr("%1 dives processed").arg(dive_table.nr)); + uiNotification(QObject::tr("%1 dives processed").arg(divelog.dives->nr)); } void FullText::registerDive(struct dive *d) diff --git a/core/git-access.h b/core/git-access.h index cad97cf01..54b15dd2c 100644 --- a/core/git-access.h +++ b/core/git-access.h @@ -5,9 +5,7 @@ #include "git2.h" #include "filterpreset.h" -struct dive_table; -struct dive_site_table; -struct trip_table; +struct dive_log; #ifdef __cplusplus extern "C" { @@ -26,7 +24,7 @@ enum remote_transport { RT_LOCAL, RT_HTTPS, RT_SSH, RT_OTHER }; struct git_oid; struct git_repository; -struct device_table; +struct divelog; struct git_info { const char *url; @@ -43,9 +41,7 @@ extern bool open_git_repository(struct git_info *info); extern bool remote_repo_uptodate(const char *filename, struct git_info *info); extern int sync_with_remote(struct git_info *); extern int git_save_dives(struct git_info *, bool select_only); -extern int git_load_dives(struct git_info *, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices, - struct filter_preset_table *filter_presets); +extern int git_load_dives(struct git_info *, struct divelog *log); extern const char *get_sha(git_repository *repo, const char *branch); extern int do_git_save(struct git_info *, bool select_only, bool create_empty); extern void cleanup_git_info(struct git_info *); diff --git a/core/import-cobalt.c b/core/import-cobalt.c index 1d00dea0f..61f5d36f4 100644 --- a/core/import-cobalt.c +++ b/core/import-cobalt.c @@ -12,6 +12,7 @@ #include "sample.h" #include "subsurface-string.h" #include "divelist.h" +#include "divelog.h" #include "device.h" #include "membuffer.h" #include "gettext.h" @@ -219,9 +220,7 @@ static int cobalt_dive(void *param, int columns, char **data, char **column) } -int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -230,10 +229,10 @@ int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buffer, in struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; char get_dives[] = "select Id,strftime('%s',DiveStartTime),LocationId,'buddy','notes',Units,(MaxDepthPressure*10000/SurfacePressure)-10000,DiveMinutes,SurfacePressure,SerialNumber,'model' from Dive where IsViewDeleted = 0"; diff --git a/core/import-csv.c b/core/import-csv.c index b23b13005..bdf19f3d0 100644 --- a/core/import-csv.c +++ b/core/import-csv.c @@ -8,6 +8,7 @@ #include "ssrf.h" #include "subsurface-string.h" #include "divelist.h" +#include "divelog.h" #include "file.h" #include "parse.h" #include "sample.h" @@ -106,9 +107,7 @@ static char *parse_dan_new_line(char *buf, const char *NL) } static int try_to_xslt_open_csv(const char *filename, struct memblock *mem, const char *tag); -static int parse_dan_format(const char *filename, struct xml_params *params, struct dive_table *table, - struct trip_table *trips, struct dive_site_table *sites, struct device_table *devices, - struct filter_preset_table *filter_presets) +static int parse_dan_format(const char *filename, struct xml_params *params, struct divelog *log) { int ret = 0, i; size_t end_ptr = 0; @@ -212,7 +211,7 @@ static int parse_dan_format(const char *filename, struct xml_params *params, str xml_params_add(params, "waterTemp", tmpbuf); } } - ret |= parse_xml_buffer(filename, "", 11, table, trips, sites, devices, filter_presets, params); + ret |= parse_xml_buffer(filename, "", 11, log, params); continue; } @@ -268,7 +267,7 @@ static int parse_dan_format(const char *filename, struct xml_params *params, str if (try_to_xslt_open_csv(filename, &mem_csv, "csv")) return -1; - ret |= parse_xml_buffer(filename, mem_csv.buffer, mem_csv.size, table, trips, sites, devices, filter_presets, params); + ret |= parse_xml_buffer(filename, mem_csv.buffer, mem_csv.size, log, params); free(mem_csv.buffer); } @@ -278,9 +277,7 @@ static int parse_dan_format(const char *filename, struct xml_params *params, str return ret; } -int parse_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +int parse_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, struct divelog *log) { int ret; struct memblock mem; @@ -300,7 +297,7 @@ int parse_csv_file(const char *filename, struct xml_params *params, const char * mem.size = 0; if (!strcmp("DL7", csvtemplate)) { - return parse_dan_format(filename, params, table, trips, sites, devices, filter_presets); + return parse_dan_format(filename, params, log); } else if (strcmp(xml_params_get_key(params, 0), "date")) { time(&now); timep = localtime(&now); @@ -332,7 +329,7 @@ int parse_csv_file(const char *filename, struct xml_params *params, const char * fprintf(stderr, "%s/xslt/%s -\n", SUBSURFACE_SOURCE, csvtemplate); } #endif - ret = parse_xml_buffer(filename, mem.buffer, mem.size, table, trips, sites, devices, filter_presets, params); + ret = parse_xml_buffer(filename, mem.buffer, mem.size, log, params); free(mem.buffer); @@ -409,9 +406,8 @@ static int try_to_xslt_open_csv(const char *filename, struct memblock *mem, cons return 0; } -int try_to_open_csv(struct memblock *mem, enum csv_format type, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites) +int try_to_open_csv(struct memblock *mem, enum csv_format type, struct divelog *log) { - UNUSED(sites); char *p = mem->buffer; char *header[8]; int i, time; @@ -460,7 +456,7 @@ int try_to_open_csv(struct memblock *mem, enum csv_format type, struct dive_tabl break; p = end + 1; } - record_dive_to_table(dive, table); + record_dive_to_table(dive, log->dives); return 1; } @@ -502,15 +498,12 @@ static char *next_mkvi_key(const char *haystack) return ret; } -int parse_txt_file(const char *filename, const char *csv, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices) +int parse_txt_file(const char *filename, const char *csv, struct divelog *log) { - UNUSED(sites); struct memblock memtxt, memcsv; - if (readfile(filename, &memtxt) < 0) { + if (readfile(filename, &memtxt) < 0) return report_error(translate("gettextFromC", "Failed to read '%s'"), filename); - } /* * MkVI stores some information in .txt file but the whole profile and events are stored in .csv file. First @@ -786,7 +779,7 @@ int parse_txt_file(const char *filename, const char *csv, struct dive_table *tab if (!lineptr || !*lineptr) break; } - record_dive_to_table(dive, table); + record_dive_to_table(dive, log->dives); return 1; } else { return 0; @@ -799,17 +792,14 @@ int parse_txt_file(const char *filename, const char *csv, struct dive_table *tab #define TIMESTR 6 #define SBPARAMS 40 -static int parse_seabear_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets); -int parse_seabear_log(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +static int parse_seabear_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, struct divelog *log); +int parse_seabear_log(const char *filename, struct divelog *log) { struct xml_params *params = alloc_xml_params(); int ret; parse_seabear_header(filename, params); - ret = parse_seabear_csv_file(filename, params, "csv", table, trips, sites, devices, filter_presets) < 0 ? -1 : 0; + ret = parse_seabear_csv_file(filename, params, "csv", log) < 0 ? -1 : 0; free_xml_params(params); @@ -817,9 +807,7 @@ int parse_seabear_log(const char *filename, struct dive_table *table, struct tri } -static int parse_seabear_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets) +static int parse_seabear_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, struct divelog *log) { int ret, i; struct memblock mem; @@ -937,14 +925,13 @@ static int parse_seabear_csv_file(const char *filename, struct xml_params *param fprintf(stderr, "xslt/csv2xml.xslt\n"); } - ret = parse_xml_buffer(filename, mem.buffer, mem.size, table, trips, sites, devices, filter_presets, params); + ret = parse_xml_buffer(filename, mem.buffer, mem.size, log, params); free(mem.buffer); return ret; } -int parse_manual_file(const char *filename, struct xml_params *params, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices, struct filter_preset_table *filter_presets) +int parse_manual_file(const char *filename, struct xml_params *params, struct divelog *log) { struct memblock mem; time_t now; @@ -980,7 +967,7 @@ int parse_manual_file(const char *filename, struct xml_params *params, struct di fprintf(stderr, "%s/xslt/manualcsv2xml.xslt -\n", SUBSURFACE_SOURCE); } #endif - ret = parse_xml_buffer(filename, mem.buffer, mem.size, table, trips, sites, devices, filter_presets, params); + ret = parse_xml_buffer(filename, mem.buffer, mem.size, log, params); free(mem.buffer); return ret; diff --git a/core/import-csv.h b/core/import-csv.h index d73b0fe04..38e413e9b 100644 --- a/core/import-csv.h +++ b/core/import-csv.h @@ -25,17 +25,12 @@ enum csv_format { extern "C" { #endif -int parse_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, struct dive_table *table, - struct trip_table *trips, struct dive_site_table *sites, struct device_table *devices, - struct filter_preset_table *filter_presets); -int try_to_open_csv(struct memblock *mem, enum csv_format type, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites); -int parse_txt_file(const char *filename, const char *csv, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); +int parse_csv_file(const char *filename, struct xml_params *params, const char *csvtemplate, struct divelog *log); +int try_to_open_csv(struct memblock *mem, enum csv_format type, struct divelog *log); +int parse_txt_file(const char *filename, const char *csv, struct divelog *log); -int parse_seabear_log(const char *filename, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets); -int parse_manual_file(const char *filename, struct xml_params *params, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices, struct filter_preset_table *filter_presets); +int parse_seabear_log(const char *filename, struct divelog *log); +int parse_manual_file(const char *filename, struct xml_params *params, struct divelog *log); #ifdef __cplusplus } diff --git a/core/import-divinglog.c b/core/import-divinglog.c index e60be025c..2bc974384 100644 --- a/core/import-divinglog.c +++ b/core/import-divinglog.c @@ -11,6 +11,7 @@ #include "subsurface-string.h" #include "parse.h" #include "divelist.h" +#include "divelog.h" #include "device.h" #include "membuffer.h" #include "gettext.h" @@ -390,9 +391,7 @@ static int divinglog_dive(void *param, int columns, char **data, char **column) } -int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -401,10 +400,10 @@ int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buffer, struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; char get_dives[] = "select Number,strftime('%s',Divedate || ' ' || ifnull(Entrytime,'00:00')),Country || ' - ' || City || ' - ' || Place,Buddy,Comments,Depth,Divetime,Divemaster,Airtemp,Watertemp,Weight,Divesuit,Computer,ID,Visibility,SupplyType from Logbook where UUID not in (select UUID from DeletedRecords)"; diff --git a/core/import-seac.c b/core/import-seac.c index d35abb742..a83d112e8 100644 --- a/core/import-seac.c +++ b/core/import-seac.c @@ -11,6 +11,7 @@ #include "subsurface-string.h" #include "parse.h" #include "divelist.h" +#include "divelog.h" #include "device.h" #include "membuffer.h" #include "gettext.h" @@ -262,9 +263,7 @@ static int seac_dive(void *param, int columns, char **data, char **column) * The callback function performs another SQL query on the other * table, to read in the sample values. */ -int parse_seac_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_seac_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -274,10 +273,10 @@ int parse_seac_buffer(sqlite3 *handle, const char *url, const char *buffer, int struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; const char *get_dives = "SELECT dive_number, device_sn, date, timezone, time, elapsed_surface_time, dive_type, start_mode, water_type, comment, total_dive_time, max_depth, firmware_version, dive_id FROM headers_dive"; diff --git a/core/import-shearwater.c b/core/import-shearwater.c index 21ae2282b..793dc36bb 100644 --- a/core/import-shearwater.c +++ b/core/import-shearwater.c @@ -10,6 +10,7 @@ #include "subsurface-string.h" #include "parse.h" #include "divelist.h" +#include "divelog.h" #include "device.h" #include "membuffer.h" #include "gettext.h" @@ -487,9 +488,7 @@ static int shearwater_cloud_dive(void *param, int columns, char **data, char **c return SQLITE_OK; } -int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -498,10 +497,10 @@ int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buffer struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; // So far have not seen any sample rate in Shearwater Desktop @@ -520,9 +519,7 @@ int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buffer return 0; } -int parse_shearwater_cloud_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_shearwater_cloud_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -531,10 +528,10 @@ int parse_shearwater_cloud_buffer(sqlite3 *handle, const char *url, const char * struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; char get_dives[] = "select l.number,strftime('%s', DiveDate),location||' / '||site,buddy,notes,imperialUnits,maxDepth,DiveLengthTime,startSurfacePressure,computerSerial,computerModel,d.diveId,l.sampleRateMs / 1000 FROM dive_details AS d JOIN dive_logs AS l ON d.diveId=l.diveId"; diff --git a/core/import-suunto.c b/core/import-suunto.c index 124e6e25f..c85adcdc0 100644 --- a/core/import-suunto.c +++ b/core/import-suunto.c @@ -10,6 +10,7 @@ #include "sample.h" #include "subsurface-string.h" #include "divelist.h" +#include "divelog.h" #include "device.h" #include "membuffer.h" #include "gettext.h" @@ -292,9 +293,7 @@ static int dm4_dive(void *param, int columns, char **data, char **column) return SQLITE_OK; } -int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -304,10 +303,10 @@ int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buffer, int s struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; /* StartTime is converted from Suunto's nano seconds to standard @@ -579,9 +578,7 @@ static int dm5_dive(void *param, int columns, char **data, char **column) return SQLITE_OK; } -int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices) +int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buffer, int size, struct divelog *log) { UNUSED(buffer); UNUSED(size); @@ -591,10 +588,10 @@ int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buffer, int s struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.sql_handle = handle; /* StartTime is converted from Suunto's nano seconds to standard diff --git a/core/libdivecomputer.c b/core/libdivecomputer.c index 1769f3de9..ec6835a24 100644 --- a/core/libdivecomputer.c +++ b/core/libdivecomputer.c @@ -13,6 +13,7 @@ #include #include #include "gettext.h" +#include "divelog.h" #include "divesite.h" #include "sample.h" #include "subsurface-float.h" @@ -512,8 +513,8 @@ static int find_dive(struct divecomputer *match) { int i; - for (i = dive_table.nr - 1; i >= 0; i--) { - struct dive *old = dive_table.dives[i]; + for (i = divelog.dives->nr - 1; i >= 0; i--) { + struct dive *old = divelog.dives->dives[i]; if (match_one_dive(match, old)) return 1; diff --git a/core/liquivision.c b/core/liquivision.c index d7cd100d0..b4faf4f1d 100644 --- a/core/liquivision.c +++ b/core/liquivision.c @@ -4,6 +4,7 @@ #include "ssrf.h" #include "divesite.h" #include "dive.h" +#include "divelog.h" #include "file.h" #include "sample.h" #include "strndup.h" @@ -436,10 +437,9 @@ static void parse_dives(int log_version, const unsigned char *buf, unsigned int free_dive(dive); } -int try_to_open_liquivision(const char *filename, struct memblock *mem, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites) +int try_to_open_liquivision(const char *filename, struct memblock *mem, struct divelog *log) { UNUSED(filename); - UNUSED(trips); const unsigned char *buf = mem->buffer; unsigned int buf_size = mem->size; unsigned int ptr; @@ -461,7 +461,7 @@ int try_to_open_liquivision(const char *filename, struct memblock *mem, struct d } ptr += 4; - parse_dives(log_version, buf + ptr, buf_size - ptr, table, sites); + parse_dives(log_version, buf + ptr, buf_size - ptr, log->dives, log->sites); return 1; } diff --git a/core/load-git.c b/core/load-git.c index 31554624e..edbf1ec01 100644 --- a/core/load-git.c +++ b/core/load-git.c @@ -15,6 +15,7 @@ #include "gettext.h" #include "dive.h" +#include "divelog.h" #include "divesite.h" #include "event.h" #include "errorhelper.h" @@ -1961,17 +1962,16 @@ const char *get_sha(git_repository *repo, const char *branch) * If it is a git repository, we return zero for success, * or report an error and return 1 if the load failed. */ -int git_load_dives(struct git_info *info, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices, struct filter_preset_table *filter_presets) +int git_load_dives(struct git_info *info, struct divelog *log) { int ret; struct git_parser_state state = { 0 }; state.repo = info->repo; - state.table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; - state.filter_presets = filter_presets; + state.table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; + state.filter_presets = log->filter_presets; if (!info->repo) return report_error("Unable to open git repository '%s[%s]'", info->url, info->branch); diff --git a/core/ostctools.c b/core/ostctools.c index 1ae04a763..72db14977 100644 --- a/core/ostctools.c +++ b/core/ostctools.c @@ -9,6 +9,7 @@ #include "gettext.h" #include "dive.h" #include "divelist.h" +#include "divelog.h" #include "extradata.h" #include "file.h" #include "libdivecomputer.h" @@ -39,10 +40,8 @@ static int ostc_prepare_data(int data_model, dc_family_t dc_fam, device_data_t * * each file. So it's not necessary to iterate once and again on a parsing * function. Actually there's only one kind of archive for every DC model. */ -void ostctools_import(const char *file, struct dive_table *divetable, struct trip_table *trips, struct dive_site_table *sites) +void ostctools_import(const char *file, struct divelog *log) { - UNUSED(trips); - UNUSED(sites); FILE *archive; device_data_t *devdata = calloc(1, sizeof(device_data_t)); dc_family_t dc_fam; @@ -184,8 +183,8 @@ void ostctools_import(const char *file, struct dive_table *divetable, struct tri } else { add_extra_data(&ostcdive->dc, "Serial", ostcdive->dc.serial); } - record_dive_to_table(ostcdive, divetable); - sort_dive_table(divetable); + record_dive_to_table(ostcdive, log->dives); + sort_dive_table(log->dives); close_out: fclose(archive); diff --git a/core/parse-xml.c b/core/parse-xml.c index 6212b9e4e..5bcd4b7e5 100644 --- a/core/parse-xml.c +++ b/core/parse-xml.c @@ -22,6 +22,7 @@ #include "gettext.h" #include "dive.h" +#include "divelog.h" #include "divesite.h" #include "errorhelper.h" #include "parse.h" @@ -1750,9 +1751,7 @@ static const char *preprocess_divelog_de(const char *buffer) return buffer; } -int parse_xml_buffer(const char *url, const char *buffer, int size, - struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets, +int parse_xml_buffer(const char *url, const char *buffer, int size, struct divelog *log, const struct xml_params *params) { UNUSED(size); @@ -1762,12 +1761,12 @@ int parse_xml_buffer(const char *url, const char *buffer, int size, struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; state.fingerprints = &fingerprint_table; // simply use the global table for now - state.filter_presets = filter_presets; + state.filter_presets = log->filter_presets; doc = xmlReadMemory(res, strlen(res), url, NULL, XML_PARSE_HUGE | XML_PARSE_RECOVER); if (!doc) doc = xmlReadMemory(res, strlen(res), url, "latin1", XML_PARSE_HUGE | XML_PARSE_RECOVER); @@ -1809,8 +1808,7 @@ static timestamp_t parse_dlf_timestamp(unsigned char *buffer) return offset + 946684800; } -int parse_dlf_buffer(unsigned char *buffer, size_t size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices) +int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log) { unsigned char *ptr = buffer; unsigned char event; @@ -1831,10 +1829,10 @@ int parse_dlf_buffer(unsigned char *buffer, size_t size, struct dive_table *tabl struct parser_state state; init_parser_state(&state); - state.target_table = table; - state.trips = trips; - state.sites = sites; - state.devices = devices; + state.target_table = log->dives; + state.trips = log->trips; + state.sites = log->sites; + state.devices = log->devices; // Check for the correct file magic if (ptr[0] != 'D' || ptr[1] != 'i' || ptr[2] != 'v' || ptr[3] != 'E') diff --git a/core/parse.c b/core/parse.c index fddcdeff4..657ff64ac 100644 --- a/core/parse.c +++ b/core/parse.c @@ -18,8 +18,6 @@ #include "device.h" #include "gettext.h" -struct dive_table dive_table; - void init_parser_state(struct parser_state *state) { memset(state, 0, sizeof(*state)); diff --git a/core/parse.h b/core/parse.h index 5beb45c38..2a3db59ca 100644 --- a/core/parse.h +++ b/core/parse.h @@ -14,6 +14,7 @@ #include struct xml_params; +struct divelog; typedef union { struct event event; @@ -105,10 +106,6 @@ extern "C" { void init_parser_state(struct parser_state *state); void free_parser_state(struct parser_state *state); -/* the dive table holds the overall dive list; target table points at - * the table we are currently filling */ -extern struct dive_table dive_table; - int trimspace(char *buffer); void start_match(const char *type, const char *name, char *buffer); void nonmatch(const char *type, const char *name, char *buffer); @@ -156,25 +153,16 @@ void add_dive_site(char *ds_name, struct dive *dive, struct parser_state *state) int atoi_n(char *ptr, unsigned int len); void parse_xml_init(void); -int parse_xml_buffer(const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, struct dive_site_table *sites, - struct device_table *devices, struct filter_preset_table *filter_presets, const struct xml_params *params); +int parse_xml_buffer(const char *url, const char *buf, int size, struct divelog *log, const struct xml_params *params); void parse_xml_exit(void); -int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_seac_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_shearwater_cloud_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); -int parse_dlf_buffer(unsigned char *buffer, size_t size, struct dive_table *table, struct trip_table *trips, - struct dive_site_table *sites, struct device_table *devices); +int parse_dm4_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_dm5_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_seac_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_shearwater_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_shearwater_cloud_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_cobalt_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_divinglog_buffer(sqlite3 *handle, const char *url, const char *buf, int size, struct divelog *log); +int parse_dlf_buffer(unsigned char *buffer, size_t size, struct divelog *log); #ifdef __cplusplus } #endif diff --git a/core/qthelper.cpp b/core/qthelper.cpp index 62f3f5755..09020aaf0 100644 --- a/core/qthelper.cpp +++ b/core/qthelper.cpp @@ -2,6 +2,7 @@ #include "qthelper.h" #include "dive.h" #include "divelist.h" +#include "divelog.h" #include "core/settings/qPrefLanguage.h" #include "core/settings/qPrefUpdateManager.h" #include "core/subsurface-qt/divelistnotifier.h" @@ -1025,12 +1026,14 @@ static QString get_dive_only_date_string(timestamp_t when) QString get_first_dive_date_string() { - return dive_table.nr > 0 ? get_dive_only_date_string(dive_table.dives[0]->when) : gettextFromC::tr("no dives"); + const dive_table *dives = divelog.dives; + return dives->nr > 0 ? get_dive_only_date_string(dives->dives[0]->when) : gettextFromC::tr("no dives"); } QString get_last_dive_date_string() { - return dive_table.nr > 0 ? get_dive_only_date_string(dive_table.dives[dive_table.nr - 1]->when) : gettextFromC::tr("no dives"); + const dive_table *dives = divelog.dives; + return dives->nr > 0 ? get_dive_only_date_string(dives->dives[dives->nr - 1]->when) : gettextFromC::tr("no dives"); } extern "C" char *get_current_date() diff --git a/core/save-git.c b/core/save-git.c index 42ee4f546..deb958603 100644 --- a/core/save-git.c +++ b/core/save-git.c @@ -17,6 +17,7 @@ #include #include "dive.h" +#include "divelog.h" #include "divesite.h" #include "filterconstraint.h" #include "filterpreset.h" @@ -883,8 +884,8 @@ static void save_settings(git_repository *repo, struct dir *tree) struct membuffer b = { 0 }; put_format(&b, "version %d\n", DATAFORMAT_VERSION); - for (int i = 0; i < nr_devices(&device_table); i++) - save_one_device(&b, get_device(&device_table, i)); + for (int i = 0; i < nr_devices(divelog.devices); i++) + save_one_device(&b, get_device(divelog.devices, i)); /* save the fingerprint data */ for (unsigned int i = 0; i < nr_fingerprints(&fingerprint_table); i++) save_one_fingerprint(&b, i); @@ -913,10 +914,10 @@ static void save_divesites(git_repository *repo, struct dir *tree) subdir = new_directory(repo, tree, &dirname); free_buffer(&dirname); - purge_empty_dive_sites(&dive_site_table); - for (int i = 0; i < dive_site_table.nr; i++) { + purge_empty_dive_sites(divelog.sites); + for (int i = 0; i < divelog.sites->nr; i++) { struct membuffer b = { 0 }; - struct dive_site *ds = get_dive_site(i, &dive_site_table); + struct dive_site *ds = get_dive_site(i, divelog.sites); struct membuffer site_file_name = { 0 }; put_format(&site_file_name, "Site-%08x", ds->uuid); show_utf8(&b, "name ", ds->name, "\n"); @@ -1029,8 +1030,8 @@ static int create_git_tree(git_repository *repo, struct dir *root, bool select_o save_divesites(repo, root); save_filter_presets(repo, root); - for (i = 0; i < trip_table.nr; ++i) - trip_table.trips[i]->saved = 0; + for (i = 0; i < divelog.trips->nr; ++i) + divelog.trips->trips[i]->saved = 0; /* save the dives */ git_storage_update_progress(translate("gettextFromC", "Start saving dives")); @@ -1140,7 +1141,7 @@ int get_authorship(git_repository *repo, git_signature **authorp) static void create_commit_message(struct membuffer *msg, bool create_empty) { - int nr = dive_table.nr; + int nr = divelog.dives->nr; struct dive *dive = get_dive(nr-1); char* changes_made = get_changes_made(); diff --git a/core/save-html.c b/core/save-html.c index 662f6c6df..acbec067a 100644 --- a/core/save-html.c +++ b/core/save-html.c @@ -6,6 +6,7 @@ #include "save-html.h" #include "dive.h" +#include "divelog.h" #include "qthelper.h" #include "gettext.h" #include "divesite.h" @@ -452,8 +453,8 @@ static void write_trips(struct membuffer *b, const char *photos_dir, bool select char sep_ = ' '; char *sep = &sep_; - for (i = 0; i < trip_table.nr; ++i) - trip_table.trips[i]->saved = 0; + for (i = 0; i < divelog.trips->nr; ++i) + divelog.trips->trips[i]->saved = 0; for_each_dive (i, dive) { trip = dive->divetrip; diff --git a/core/save-xml.c b/core/save-xml.c index f1498860b..979e9aa4d 100644 --- a/core/save-xml.c +++ b/core/save-xml.c @@ -13,6 +13,7 @@ #include #include "dive.h" +#include "divelog.h" #include "divesite.h" #include "errorhelper.h" #include "extradata.h" @@ -682,8 +683,8 @@ static void save_dives_buffer(struct membuffer *b, bool select_only, bool anonym put_format(b, "\n\n", DATAFORMAT_VERSION); /* save the dive computer nicknames, if any */ - for (int i = 0; i < nr_devices(&device_table); i++) { - const struct device *d = get_device(&device_table, i); + for (int i = 0; i < nr_devices(divelog.devices); i++) { + const struct device *d = get_device(divelog.devices, i); if (!select_only || device_used_by_selected_dive(d)) save_one_device(b, d); } @@ -697,8 +698,8 @@ static void save_dives_buffer(struct membuffer *b, bool select_only, bool anonym /* save the dive sites */ put_format(b, "\n"); - for (i = 0; i < dive_site_table.nr; i++) { - struct dive_site *ds = get_dive_site(i, &dive_site_table); + for (i = 0; i < divelog.sites->nr; i++) { + struct dive_site *ds = get_dive_site(i, divelog.sites); /* Don't export empty dive sites */ if (dive_site_is_empty(ds)) continue; @@ -726,8 +727,8 @@ static void save_dives_buffer(struct membuffer *b, bool select_only, bool anonym put_format(b, "\n"); } put_format(b, "\n\n"); - for (i = 0; i < trip_table.nr; ++i) - trip_table.trips[i]->saved = 0; + for (i = 0; i < divelog.trips->nr; ++i) + divelog.trips->trips[i]->saved = 0; /* save the filter presets */ save_filter_presets(b); diff --git a/core/selection.cpp b/core/selection.cpp index 4912735b2..cb716572a 100644 --- a/core/selection.cpp +++ b/core/selection.cpp @@ -3,6 +3,7 @@ #include "selection.h" #include "divelist.h" +#include "divelog.h" #include "trip.h" #include "subsurface-qt/divelistnotifier.h" @@ -40,7 +41,7 @@ extern "C" void deselect_dive(struct dive *dive) } } selected_dive = idx; - while (++selected_dive < dive_table.nr) { + while (++selected_dive < divelog.dives->nr) { dive = get_dive(selected_dive); if (dive && dive->selected) { current_dive = dive; @@ -163,8 +164,8 @@ void setSelection(const std::vector &selection, dive *currentDive) // Since we select only dives, there are no selected trips! amount_trips_selected = 0; - for (int i = 0; i < trip_table.nr; ++i) - trip_table.trips[i]->selected = false; + for (int i = 0; i < divelog.trips->nr; ++i) + divelog.trips->trips[i]->selected = false; // TODO: We might want to keep track of selected dives in a more efficient way! int i; @@ -233,8 +234,8 @@ std::vector getDiveSelection() // Select the first dive that is visible extern "C" void select_newest_visible_dive() { - for (int i = dive_table.nr - 1; i >= 0; --i) { - dive *d = dive_table.dives[i]; + for (int i = divelog.dives->nr - 1; i >= 0; --i) { + dive *d = divelog.dives->dives[i]; if (!d->hidden_by_filter) return select_single_dive(d); } @@ -263,9 +264,9 @@ extern "C" struct dive_trip *single_selected_trip() { if (amount_trips_selected != 1) return NULL; - for (int i = 0; i < trip_table.nr; ++i) { - if (trip_table.trips[i]->selected) - return trip_table.trips[i]; + for (int i = 0; i < divelog.trips->nr; ++i) { + if (divelog.trips->trips[i]->selected) + return divelog.trips->trips[i]; } fprintf(stderr, "warning: found no selected trip even though one should be selected\n"); return NULL; // shouldn't happen @@ -280,6 +281,6 @@ extern "C" void clear_selection(void) struct dive *dive; for_each_dive (i, dive) dive->selected = false; - for (int i = 0; i < trip_table.nr; ++i) - trip_table.trips[i]->selected = false; + for (int i = 0; i < divelog.trips->nr; ++i) + divelog.trips->trips[i]->selected = false; } diff --git a/core/statistics.c b/core/statistics.c index 5707e6c5e..c7517ef74 100644 --- a/core/statistics.c +++ b/core/statistics.c @@ -8,6 +8,7 @@ #include "statistics.h" #include "dive.h" +#include "divelog.h" #include "event.h" #include "gettext.h" #include "sample.h" @@ -105,17 +106,17 @@ void calculate_stats_summary(struct stats_summary *out, bool selected_only) size_t size, tsize, dsize, tmsize; stats_t stats = { 0 }; - if (dive_table.nr > 0) { - stats.shortest_time.seconds = dive_table.dives[0]->duration.seconds; - stats.min_depth.mm = dive_table.dives[0]->maxdepth.mm; - stats.selection_size = dive_table.nr; + if (divelog.dives->nr > 0) { + stats.shortest_time.seconds = divelog.dives->dives[0]->duration.seconds; + stats.min_depth.mm = divelog.dives->dives[0]->maxdepth.mm; + stats.selection_size = divelog.dives->nr; } /* allocate sufficient space to hold the worst * case (one dive per year or all dives during * one month) for yearly and monthly statistics*/ - size = sizeof(stats_t) * (dive_table.nr + 1); + size = sizeof(stats_t) * (divelog.dives->nr + 1); tsize = sizeof(stats_t) * (NUM_DIVEMODE + 1); dsize = sizeof(stats_t) * ((STATS_MAX_DEPTH / STATS_DEPTH_BUCKET) + 1); tmsize = sizeof(stats_t) * ((STATS_MAX_TEMP / STATS_TEMP_BUCKET) + 1); diff --git a/core/trip.c b/core/trip.c index 8f153d587..4e5da05e4 100644 --- a/core/trip.c +++ b/core/trip.c @@ -2,14 +2,13 @@ #include "trip.h" #include "dive.h" +#include "divelog.h" #include "subsurface-time.h" #include "subsurface-string.h" #include "selection.h" #include "table.h" #include "core/qthelper.h" -struct trip_table trip_table; - #ifdef DEBUG_TRIP void dump_trip_list(void) { @@ -17,9 +16,9 @@ void dump_trip_list(void) int i = 0; timestamp_t last_time = 0; - for (i = 0; i < trip_table.nr; ++i) { + for (i = 0; i < divelog.trips->nr; ++i) { struct tm tm; - trip = trip_table.trips[i]; + trip = divelog.trips->trips[i]; utc_mkdate(trip_date(trip), &tm); if (trip_date(trip) < last_time) printf("\n\ntrip_table OUT OF ORDER!!!\n\n\n"); @@ -203,9 +202,9 @@ dive_trip_t *get_trip_for_new_dive(struct dive *new_dive, bool *allocated) /* lookup of trip in main trip_table based on its id */ dive_trip_t *get_trip_by_uniq_id(int tripId) { - for (int i = 0; i < trip_table.nr; i++) { - if (trip_table.trips[i]->id == tripId) - return trip_table.trips[i]; + for (int i = 0; i < divelog.trips->nr; i++) { + if (divelog.trips->trips[i]->id == tripId) + return divelog.trips->trips[i]; } return NULL; } diff --git a/core/trip.h b/core/trip.h index 976275736..61b75719d 100644 --- a/core/trip.h +++ b/core/trip.h @@ -63,7 +63,6 @@ void clear_trip_table(struct trip_table *table); extern void dump_trip_list(void); #endif -extern struct trip_table trip_table; #ifdef __cplusplus } diff --git a/core/uemis-downloader.c b/core/uemis-downloader.c index 8b49516a4..33804fccb 100644 --- a/core/uemis-downloader.c +++ b/core/uemis-downloader.c @@ -25,6 +25,7 @@ #include "libdivecomputer.h" #include "uemis.h" #include "divelist.h" +#include "divelog.h" #include "divesite.h" #include "errorhelper.h" #include "file.h" @@ -1051,7 +1052,7 @@ static char *uemis_get_divenr(char *deviceidstr, struct dive_table *table, int f * Otherwise, use the global dive table. */ if (!force && !table->nr) - table = &dive_table; + table = divelog.dives; for (i = 0; i < table->nr; i++) { struct dive *d = table->dives[i]; diff --git a/desktop-widgets/divelogimportdialog.cpp b/desktop-widgets/divelogimportdialog.cpp index 28c7f0e98..78423079d 100644 --- a/desktop-widgets/divelogimportdialog.cpp +++ b/desktop-widgets/divelogimportdialog.cpp @@ -14,6 +14,7 @@ #include "core/filterpreset.h" #include "core/qthelper.h" #include "core/divesite.h" +#include "core/divelog.h" #include "core/device.h" #include "core/trip.h" #include "core/import-csv.h" @@ -879,19 +880,15 @@ void DiveLogImportDialog::parseTxtHeader(QString fileName, xml_params ¶ms) void DiveLogImportDialog::on_buttonBox_accepted() { - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; + struct divelog log; QStringList r = resultModel->result(); if (ui->knownImports->currentText() != "Manual import") { for (int i = 0; i < fileNames.size(); ++i) { if (ui->knownImports->currentText() == "Seabear CSV") { - parse_seabear_log(qPrintable(fileNames[i]), &table, &trips, &sites, &devices, &filter_presets); + parse_seabear_log(qPrintable(fileNames[i]), &log); } else if (ui->knownImports->currentText() == "Poseidon MkVI") { QPair pair = poseidonFileNames(fileNames[i]); - parse_txt_file(qPrintable(pair.second), qPrintable(pair.first), &table, &trips, &sites, &devices); + parse_txt_file(qPrintable(pair.second), qPrintable(pair.first), &log); } else { xml_params params; @@ -908,7 +905,7 @@ void DiveLogImportDialog::on_buttonBox_accepted() setup_csv_params(r, params); parse_csv_file(qPrintable(fileNames[i]), ¶ms, specialCSV.contains(ui->knownImports->currentIndex()) ? qPrintable(CSVApps[ui->knownImports->currentIndex()].name) : "csv", - &table, &trips, &sites, &devices, &filter_presets); + &log); } } } else { @@ -944,7 +941,7 @@ void DiveLogImportDialog::on_buttonBox_accepted() xml_params_add_int(¶ms, "visibilityField", r.indexOf(tr("Visibility"))); xml_params_add_int(¶ms, "ratingField", r.indexOf(tr("Rating"))); - parse_manual_file(qPrintable(fileNames[i]), ¶ms, &table, &trips, &sites, &devices, &filter_presets); + parse_manual_file(qPrintable(fileNames[i]), ¶ms, &log); } else { xml_params params; @@ -962,13 +959,13 @@ void DiveLogImportDialog::on_buttonBox_accepted() setup_csv_params(r, params); parse_csv_file(qPrintable(fileNames[i]), ¶ms, specialCSV.contains(ui->knownImports->currentIndex()) ? qPrintable(CSVApps[ui->knownImports->currentIndex()].name) : "csv", - &table, &trips, &sites, &devices, &filter_presets); + &log); } } } QString source = fileNames.size() == 1 ? fileNames[0] : tr("multiple files"); - Command::importDives(&table, &trips, &sites, &devices, nullptr, IMPORT_MERGE_ALL_TRIPS, source); + Command::importDives(log.dives, log.trips, log.sites, log.devices, nullptr, IMPORT_MERGE_ALL_TRIPS, source); } TagDragDelegate::TagDragDelegate(QObject *parent) : QStyledItemDelegate(parent) diff --git a/desktop-widgets/divesitelistview.cpp b/desktop-widgets/divesitelistview.cpp index 120ce0024..65e8c04c9 100644 --- a/desktop-widgets/divesitelistview.cpp +++ b/desktop-widgets/divesitelistview.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "divesitelistview.h" #include "core/subsurface-qt/divelistnotifier.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/divefilter.h" #include "qt-models/divelocationmodel.h" @@ -96,7 +97,7 @@ void DiveSiteListView::diveSiteAdded(struct dive_site *, int idx) void DiveSiteListView::diveSiteChanged(struct dive_site *ds, int field) { - int idx = get_divesite_idx(ds, &dive_site_table); + int idx = get_divesite_idx(ds, divelog.sites); if (idx < 0) return; QModelIndex globalIdx = LocationInformationModel::instance()->index(idx, field); diff --git a/desktop-widgets/downloadfromdivecomputer.cpp b/desktop-widgets/downloadfromdivecomputer.cpp index 527682431..5fec95ff5 100644 --- a/desktop-widgets/downloadfromdivecomputer.cpp +++ b/desktop-widgets/downloadfromdivecomputer.cpp @@ -3,6 +3,7 @@ #include "commands/command.h" #include "core/qthelper.h" #include "core/divelist.h" +#include "core/divelog.h" #include "core/settings/qPrefDiveComputer.h" #include "core/subsurface-float.h" #include "core/subsurface-string.h" @@ -423,7 +424,7 @@ void DownloadFromDCWidget::on_downloadCancelRetryButton_clicked() qPrefDiveComputer::set_device(data->devName()); // before we start, remember where the dive_table ended - previousLast = dive_table.nr; + previousLast = divelog.dives->nr; diveImportedModel->startDownload(); // FIXME: We should get the _actual_ device info instead of whatever diff --git a/desktop-widgets/locationinformation.cpp b/desktop-widgets/locationinformation.cpp index 9f11c3137..0206f9d5f 100644 --- a/desktop-widgets/locationinformation.cpp +++ b/desktop-widgets/locationinformation.cpp @@ -8,6 +8,7 @@ #include "desktop-widgets/mapwidget.h" #include "core/color.h" #include "core/divefilter.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/divesitehelpers.h" #include "desktop-widgets/modeldelegates.h" @@ -367,8 +368,8 @@ bool DiveLocationFilterProxyModel::lessThan(const QModelIndex &source_left, cons // If there is a current location, sort by that - otherwise use the provided column if (has_location(¤tLocation)) { // The dive sites are -2 because of the first two items. - struct dive_site *ds1 = get_dive_site(source_left.row() - 2, &dive_site_table); - struct dive_site *ds2 = get_dive_site(source_right.row() - 2, &dive_site_table); + struct dive_site *ds1 = get_dive_site(source_left.row() - 2, divelog.sites); + struct dive_site *ds2 = get_dive_site(source_right.row() - 2, divelog.sites); return get_distance(&ds1->location, ¤tLocation) < get_distance(&ds2->location, ¤tLocation); } return source_left.data().toString().compare(source_right.data().toString(), Qt::CaseInsensitive) < 0; @@ -407,7 +408,7 @@ QVariant DiveLocationModel::data(const QModelIndex &index, int role) const } // The dive sites are -2 because of the first two items. - struct dive_site *ds = get_dive_site(index.row() - 2, &dive_site_table); + struct dive_site *ds = get_dive_site(index.row() - 2, divelog.sites); return LocationInformationModel::getDiveSiteData(ds, index.column(), role); } @@ -418,7 +419,7 @@ int DiveLocationModel::columnCount(const QModelIndex&) const int DiveLocationModel::rowCount(const QModelIndex&) const { - return dive_site_table.nr + 2; + return divelog.sites->nr + 2; } Qt::ItemFlags DiveLocationModel::flags(const QModelIndex &index) const @@ -541,11 +542,10 @@ static struct dive_site *get_dive_site_name_start_which_str(const QString &str) { struct dive_site *ds; int i; - for_each_dive_site (i, ds, &dive_site_table) { + for_each_dive_site (i, ds, divelog.sites) { QString dsName(ds->name); - if (dsName.toLower().startsWith(str.toLower())) { + if (dsName.toLower().startsWith(str.toLower())) return ds; - } } return NULL; } diff --git a/desktop-widgets/mainwindow.cpp b/desktop-widgets/mainwindow.cpp index 2aeafeace..cdc777440 100644 --- a/desktop-widgets/mainwindow.cpp +++ b/desktop-widgets/mainwindow.cpp @@ -19,6 +19,7 @@ #include "core/color.h" #include "core/device.h" +#include "core/divelog.h" #include "core/divesitehelpers.h" #include "core/errorhelper.h" #include "core/file.h" @@ -413,7 +414,7 @@ void MainWindow::on_actionCloudstorageopen_triggered() showProgressBar(); QByteArray fileNamePtr = QFile::encodeName(filename); - if (!parse_file(fileNamePtr.data(), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table)) + if (!parse_file(fileNamePtr.data(), &divelog)) setCurrentFile(fileNamePtr.data()); process_loaded_dives(); hideProgressBar(); @@ -423,7 +424,7 @@ void MainWindow::on_actionCloudstorageopen_triggered() // Return whether saving to cloud is OK. If it isn't, show an error return false. static bool saveToCloudOK() { - if (!dive_table.nr) { + if (divelog.dives->nr) { report_error(qPrintable(gettextFromC::tr("Don't save an empty log to the cloud"))); return false; } @@ -1276,18 +1277,14 @@ void MainWindow::importFiles(const QStringList fileNames) return; QByteArray fileNamePtr; - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; + struct divelog log; for (int i = 0; i < fileNames.size(); ++i) { fileNamePtr = QFile::encodeName(fileNames.at(i)); - parse_file(fileNamePtr.data(), &table, &trips, &sites, &devices, &filter_presets); + parse_file(fileNamePtr.data(), &log); } QString source = fileNames.size() == 1 ? fileNames[0] : tr("multiple files"); - Command::importDives(&table, &trips, &sites, &devices, &filter_presets, IMPORT_MERGE_ALL_TRIPS, source); + Command::importDives(log.dives, log.trips, log.sites, log.devices, log.filter_presets, IMPORT_MERGE_ALL_TRIPS, source); } void MainWindow::loadFiles(const QStringList fileNames) @@ -1301,7 +1298,7 @@ void MainWindow::loadFiles(const QStringList fileNames) showProgressBar(); for (int i = 0; i < fileNames.size(); ++i) { fileNamePtr = QFile::encodeName(fileNames.at(i)); - if (!parse_file(fileNamePtr.data(), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table)) { + if (!parse_file(fileNamePtr.data(), &divelog)) { setCurrentFile(fileNamePtr.data()); addRecentFile(fileNamePtr, false); } @@ -1372,28 +1369,19 @@ void MainWindow::on_actionImportDiveSites_triggered() return; updateLastUsedDir(QFileInfo(fileNames[0]).dir().path()); - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; + struct divelog log; for (const QString &s: fileNames) { QByteArray fileNamePtr = QFile::encodeName(s); - parse_file(fileNamePtr.data(), &table, &trips, &sites, &devices, &filter_presets); + parse_file(fileNamePtr.data(), &log); } // The imported dive sites still have pointers to imported dives - remove them - for (int i = 0; i < sites.nr; ++i) - sites.dive_sites[i]->dives.nr = 0; - - // Now we can clear the imported dives and trips. - clear_dive_table(&table); - clear_trip_table(&trips); + for (int i = 0; i < log.sites->nr; ++i) + log.sites->dive_sites[i]->dives.nr = 0; QString source = fileNames.size() == 1 ? fileNames[0] : tr("multiple files"); - // sites table will be cleared by DivesiteImportDialog constructor - DivesiteImportDialog divesiteImport(sites, source, this); + DivesiteImportDialog divesiteImport(*log.sites, source, this); divesiteImport.exec(); } diff --git a/desktop-widgets/subsurfacewebservices.cpp b/desktop-widgets/subsurfacewebservices.cpp index b4bce58d8..a2b22485e 100644 --- a/desktop-widgets/subsurfacewebservices.cpp +++ b/desktop-widgets/subsurfacewebservices.cpp @@ -7,8 +7,8 @@ #include "desktop-widgets/mainwindow.h" #include "commands/command.h" #include "core/device.h" -#include "core/divesite.h" -#include "core/trip.h" +#include "core/divelist.h" // For IMPORT_MERGE_ALL_TRIPS +#include "core/divelog.h" #include "core/errorhelper.h" #include "core/file.h" #include "desktop-widgets/mapwidget.h" @@ -463,13 +463,9 @@ void DivelogsDeWebServices::buttonClicked(QAbstractButton *button) break; } /* parse file and import dives */ - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - parse_file(QFile::encodeName(zipFile.fileName()), &table, &trips, &sites, &devices, &filter_presets); - Command::importDives(&table, &trips, &sites, &devices, nullptr, IMPORT_MERGE_ALL_TRIPS, QStringLiteral("divelogs.de")); + struct divelog log; + parse_file(QFile::encodeName(zipFile.fileName()), &log); + Command::importDives(log.dives, log.trips, log.sites, log.devices, nullptr, IMPORT_MERGE_ALL_TRIPS, QStringLiteral("divelogs.de")); /* store last entered user/pass in config */ qPrefCloudStorage::set_divelogde_user(ui.userID->text()); diff --git a/desktop-widgets/tripselectiondialog.cpp b/desktop-widgets/tripselectiondialog.cpp index e7e87c724..e4eef72aa 100644 --- a/desktop-widgets/tripselectiondialog.cpp +++ b/desktop-widgets/tripselectiondialog.cpp @@ -1,5 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 #include "tripselectiondialog.h" +#include "core/divelog.h" #include "core/string-format.h" #include "core/trip.h" #include @@ -17,9 +18,9 @@ TripSelectionDialog::TripSelectionDialog(QWidget *parent) : QDialog(parent) // We could use a model, but it seems barely worth the hassle. QStringList list; - list.reserve(trip_table.nr); - for (int i = 0; i < trip_table.nr; ++i) - list.push_back(formatTripTitleWithDives(trip_table.trips[i])); + list.reserve(divelog.trips->nr); + for (int i = 0; i < divelog.trips->nr; ++i) + list.push_back(formatTripTitleWithDives(divelog.trips->trips[i])); ui.trips->addItems(list); } @@ -36,9 +37,9 @@ dive_trip *TripSelectionDialog::selectedTrip() const if (rows.size() != 1) return nullptr; int idx = rows[0].row(); - if (idx < 0 || idx >= trip_table.nr) + if (idx < 0 || idx >= divelog.trips->nr) return nullptr; - return trip_table.trips[idx]; + return divelog.trips->trips[idx]; } dive_trip *TripSelectionDialog::getTrip() diff --git a/export-html.cpp b/export-html.cpp index 81ebbde75..48c257c05 100644 --- a/export-html.cpp +++ b/export-html.cpp @@ -10,6 +10,7 @@ #include "core/qthelper.h" #include "core/file.h" #include "core/device.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/trip.h" #include "core/save-html.h" @@ -45,7 +46,7 @@ int main(int argc, char **argv) qDebug() << "need --source and --output"; exit(1); } - int ret = parse_file(qPrintable(source), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + int ret = parse_file(qPrintable(source), &divelog); if (ret) { fprintf(stderr, "parse_file returned %d\n", ret); exit(1); diff --git a/mobile-widgets/qmlmanager.cpp b/mobile-widgets/qmlmanager.cpp index d028383e8..81155c8cf 100644 --- a/mobile-widgets/qmlmanager.cpp +++ b/mobile-widgets/qmlmanager.cpp @@ -28,6 +28,7 @@ #include "core/errorhelper.h" #include "core/file.h" #include "core/divefilter.h" +#include "core/divelog.h" #include "core/filterconstraint.h" #include "core/qthelper.h" #include "core/qt-gui.h" @@ -377,7 +378,7 @@ void QMLManager::openLocalThenRemote(QString url) * we try to open this), parse_file (which is called by openAndMaybeSync) will ALWAYS connect * to the remote and populate the cache. * Otherwise parse_file will respect the git_local_only flag and only update if that isn't set */ - int error = parse_file(encodedFilename.constData(), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + int error = parse_file(encodedFilename.constData(), &divelog); if (error) { /* there can be 2 reasons for this: * 1) we have cloud credentials, but there is no local repo (yet). @@ -409,9 +410,9 @@ void QMLManager::openLocalThenRemote(QString url) qPrefTechnicalDetails::set_show_ccr_sensors(git_prefs.show_ccr_sensors); qPrefPartialPressureGas::set_po2(git_prefs.pp_graphs.po2); // the following steps can take a long time, so provide updates - setNotificationText(tr("Processing %1 dives").arg(dive_table.nr)); + setNotificationText(tr("Processing %1 dives").arg(divelog.dives->nr)); process_loaded_dives(); - setNotificationText(tr("%1 dives loaded from local dive data file").arg(dive_table.nr)); + setNotificationText(tr("%1 dives loaded from local dive data file").arg(divelog.dives->nr)); } if (qPrefCloudStorage::cloud_verification_status() == qPrefCloudStorage::CS_NEED_TO_VERIFY) { appendTextToLog(QStringLiteral("have cloud credentials, but still needs PIN")); @@ -472,13 +473,9 @@ static QString nocloud_localstorage() void QMLManager::mergeLocalRepo() { - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - parse_file(qPrintable(nocloud_localstorage()), &table, &trips, &sites, &devices, &filter_presets); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); + struct divelog log; + parse_file(qPrintable(nocloud_localstorage()), &log); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); mark_divelist_changed(true); } @@ -578,7 +575,7 @@ void QMLManager::finishSetup() qPrefCloudStorage::set_cloud_verification_status(qPrefCloudStorage::CS_NOCLOUD); saveCloudCredentials(qPrefCloudStorage::cloud_storage_email(), qPrefCloudStorage::cloud_storage_password(), qPrefCloudStorage::cloud_storage_pin()); appendTextToLog(tr("working in no-cloud mode")); - int error = parse_file(existing_filename, &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + int error = parse_file(existing_filename, &divelog); if (error) { // we got an error loading the local file setNotificationText(tr("Error parsing local storage, giving up")); @@ -587,7 +584,7 @@ void QMLManager::finishSetup() // successfully opened the local file, now add thigs to the dive list consumeFinishedLoad(); updateHaveLocalChanges(true); - appendTextToLog(QString("working in no-cloud mode, finished loading %1 dives from %2").arg(dive_table.nr).arg(existing_filename)); + appendTextToLog(QString("working in no-cloud mode, finished loading %1 dives from %2").arg(divelog.dives->nr).arg(existing_filename)); } } else { qPrefCloudStorage::set_cloud_verification_status(qPrefCloudStorage::CS_UNKNOWN); @@ -664,7 +661,7 @@ void QMLManager::saveCloudCredentials(const QString &newEmail, const QString &ne qPrefCloudStorage::set_cloud_storage_email(email); qPrefCloudStorage::set_cloud_storage_password(newPassword); - if (m_oldStatus == qPrefCloudStorage::CS_NOCLOUD && cloudCredentialsChanged && dive_table.nr) { + if (m_oldStatus == qPrefCloudStorage::CS_NOCLOUD && cloudCredentialsChanged && divelog.dives->nr) { // we came from NOCLOUD and are connecting to a cloud account; // since we already have dives in the table, let's remember that so we can keep them noCloudToCloud = true; @@ -795,10 +792,10 @@ void QMLManager::loadDivesWithValidCredentials() } if (info.repo) { appendTextToLog(QString("have repository and branch %1").arg(info.branch)); - error = git_load_dives(&info, &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + error = git_load_dives(&info, &divelog); } else { appendTextToLog(QString("didn't receive valid git repo, try again")); - error = parse_file(fileNamePrt.data(), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + error = parse_file(fileNamePrt.data(), &divelog); } setDiveListProcessing(false); if (!error) { @@ -822,7 +819,7 @@ void QMLManager::loadDivesWithValidCredentials() if (noCloudToCloud) { git_storage_update_progress(qPrintable(tr("Loading dives from local storage ('no cloud' mode)"))); mergeLocalRepo(); - appendTextToLog(QStringLiteral("%1 dives loaded after importing nocloud local storage").arg(dive_table.nr)); + appendTextToLog(QStringLiteral("%1 dives loaded after importing nocloud local storage").arg(divelog.dives->nr)); noCloudToCloud = false; mark_divelist_changed(true); emit syncStateChanged(); @@ -886,8 +883,8 @@ void QMLManager::consumeFinishedLoad() prefs.show_ccr_sensors = git_prefs.show_ccr_sensors; prefs.pp_graphs.po2 = git_prefs.pp_graphs.po2; process_loaded_dives(); - appendTextToLog(QStringLiteral("%1 dives loaded").arg(dive_table.nr)); - if (dive_table.nr == 0) + appendTextToLog(QStringLiteral("%1 dives loaded").arg(divelog.dives->nr)); + if (divelog.dives->nr == 0) setStartPageText(tr("Cloud storage open successfully. No dives in dive list.")); } @@ -1062,7 +1059,7 @@ bool QMLManager::checkLocation(DiveSiteChange &res, struct dive *d, QString loca bool changed = false; QString oldLocation = get_dive_location(d); if (oldLocation != location) { - ds = get_dive_site_by_name(qPrintable(location), &dive_site_table); + ds = get_dive_site_by_name(qPrintable(location), divelog.sites); if (!ds && !location.isEmpty()) { res.createdDs.reset(alloc_dive_site_with_name(qPrintable(location))); res.changed = true; @@ -1800,7 +1797,7 @@ QString QMLManager::getGpsFromSiteName(const QString &siteName) { struct dive_site *ds; - ds = get_dive_site_by_name(qPrintable(siteName), &dive_site_table); + ds = get_dive_site_by_name(qPrintable(siteName), divelog.sites); if (!ds) return QString(); return printGPSCoords(&ds->location); @@ -2347,15 +2344,11 @@ void QMLManager::setDiveListProcessing(bool value) void QMLManager::importCacheRepo(QString repo) { - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; + struct divelog log; QString repoPath = QString("%1/cloudstorage/%2").arg(system_default_directory()).arg(repo); appendTextToLog(QString("importing %1").arg(repoPath)); - parse_file(qPrintable(repoPath), &table, &trips, &sites, &devices, &filter_presets); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); + parse_file(qPrintable(repoPath), &log); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); changesNeedSaving(); } @@ -2370,9 +2363,8 @@ QStringList QMLManager::cloudCacheList() const if (dir == "localrepo") { result << QString("localrepo[master]"); } else { - foreach(QString branch, remote.entryList().filter(QRegularExpression("...+"))) { + foreach(QString branch, remote.entryList().filter(QRegularExpression("...+"))) result << QString("%1[%2]").arg(dir).arg(branch); - } } } return result; diff --git a/qt-models/divelocationmodel.cpp b/qt-models/divelocationmodel.cpp index f353e7832..ca84927de 100644 --- a/qt-models/divelocationmodel.cpp +++ b/qt-models/divelocationmodel.cpp @@ -4,6 +4,7 @@ #include "core/subsurface-qt/divelistnotifier.h" #include "core/qthelper.h" #include "core/divesite.h" +#include "core/divelog.h" #include "core/metrics.h" #ifndef SUBSURFACE_MOBILE #include "cleanertablemodel.h" // for trashIcon() and editIcon() @@ -36,7 +37,7 @@ int LocationInformationModel::columnCount(const QModelIndex &) const int LocationInformationModel::rowCount(const QModelIndex &) const { - return dive_site_table.nr; + return divelog.sites->nr; } QVariant LocationInformationModel::headerData(int section, Qt::Orientation orientation, int role) const @@ -124,7 +125,7 @@ QVariant LocationInformationModel::data(const QModelIndex &index, int role) cons if (!index.isValid()) return QVariant(); - struct dive_site *ds = get_dive_site(index.row(), &dive_site_table); + struct dive_site *ds = get_dive_site(index.row(), divelog.sites); return getDiveSiteData(ds, index.column(), role); } @@ -136,7 +137,7 @@ void LocationInformationModel::update() void LocationInformationModel::diveSiteDiveCountChanged(dive_site *ds) { - int idx = get_divesite_idx(ds, &dive_site_table); + int idx = get_divesite_idx(ds, divelog.sites); if (idx >= 0) dataChanged(createIndex(idx, NUM_DIVES), createIndex(idx, NUM_DIVES)); } @@ -161,7 +162,7 @@ void LocationInformationModel::diveSiteDeleted(struct dive_site *, int idx) void LocationInformationModel::diveSiteChanged(struct dive_site *ds, int field) { - int idx = get_divesite_idx(ds, &dive_site_table); + int idx = get_divesite_idx(ds, divelog.sites); if (idx < 0) return; dataChanged(createIndex(idx, field), createIndex(idx, field)); @@ -169,7 +170,7 @@ void LocationInformationModel::diveSiteChanged(struct dive_site *ds, int field) void LocationInformationModel::diveSiteDivesChanged(struct dive_site *ds) { - int idx = get_divesite_idx(ds, &dive_site_table); + int idx = get_divesite_idx(ds, divelog.sites); if (idx < 0) return; dataChanged(createIndex(idx, NUM_DIVES), createIndex(idx, NUM_DIVES)); @@ -180,9 +181,9 @@ bool DiveSiteSortedModel::filterAcceptsRow(int sourceRow, const QModelIndex &sou if (fullText.isEmpty()) return true; - if (sourceRow < 0 || sourceRow > dive_site_table.nr) + if (sourceRow < 0 || sourceRow > divelog.sites->nr) return false; - struct dive_site *ds = dive_site_table.dive_sites[sourceRow]; + struct dive_site *ds = divelog.sites->dive_sites[sourceRow]; QString text = QString(ds->name) + QString(ds->description) + QString(ds->notes); return text.contains(fullText, Qt::CaseInsensitive); } @@ -192,8 +193,8 @@ bool DiveSiteSortedModel::lessThan(const QModelIndex &i1, const QModelIndex &i2) // The source indices correspond to indices in the global dive site table. // Let's access them directly without going via the source model. // Kind of dirty, but less effort. - struct dive_site *ds1 = get_dive_site(i1.row(), &dive_site_table); - struct dive_site *ds2 = get_dive_site(i2.row(), &dive_site_table); + struct dive_site *ds1 = get_dive_site(i1.row(), divelog.sites); + struct dive_site *ds2 = get_dive_site(i2.row(), divelog.sites); if (!ds1 || !ds2) // Invalid dive sites compare as different return false; switch (i1.column()) { @@ -229,18 +230,18 @@ QStringList DiveSiteSortedModel::allSiteNames() const // This shouldn't happen, but if model and core get out of sync, // (more precisely: the core has more sites than the model is aware of), // we might get an invalid index. - if (idx < 0 || idx > dive_site_table.nr) { + if (idx < 0 || idx > divelog.sites->nr) { SSRF_INFO("DiveSiteSortedModel::allSiteNames(): invalid index"); continue; } - locationNames << QString(dive_site_table.dive_sites[idx]->name); + locationNames << QString(divelog.sites->dive_sites[idx]->name); } return locationNames; } struct dive_site *DiveSiteSortedModel::getDiveSite(const QModelIndex &idx) { - return get_dive_site(mapToSource(idx).row(), &dive_site_table); + return get_dive_site(mapToSource(idx).row(), divelog.sites); } #ifndef SUBSURFACE_MOBILE diff --git a/qt-models/diveplannermodel.cpp b/qt-models/diveplannermodel.cpp index 0e2be8e0a..b0738b373 100644 --- a/qt-models/diveplannermodel.cpp +++ b/qt-models/diveplannermodel.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "diveplannermodel.h" #include "core/divelist.h" +#include "core/divelog.h" #include "core/subsurface-string.h" #include "qt-models/cylindermodel.h" #include "core/planner.h" @@ -93,13 +94,12 @@ void DivePlannerPointsModel::setupStartTime() // if the latest dive is in the future, then start an hour after it ends // otherwise start an hour from now startTime = QDateTime::currentDateTimeUtc().addSecs(3600 + gettimezoneoffset()); - if (dive_table.nr) { - struct dive *d = get_dive(dive_table.nr - 1); + if (divelog.dives->nr > 0) { + struct dive *d = get_dive(divelog.dives->nr - 1); time_t ends = dive_endtime(d); time_t diff = ends - dateTimeToTimestamp(startTime); - if (diff > 0) { + if (diff > 0) startTime = startTime.addSecs(diff + 3600); - } } } diff --git a/qt-models/divesiteimportmodel.cpp b/qt-models/divesiteimportmodel.cpp index 2bd38d6b4..d8ffd6011 100644 --- a/qt-models/divesiteimportmodel.cpp +++ b/qt-models/divesiteimportmodel.cpp @@ -1,4 +1,5 @@ #include "divesiteimportmodel.h" +#include "core/divelog.h" #include "core/qthelper.h" #include "core/taxonomy.h" @@ -67,7 +68,7 @@ QVariant DivesiteImportedModel::data(const QModelIndex &index, int role) const // 40075000 is circumference of the earth in meters struct dive_site *nearest_ds = get_dive_site_by_gps_proximity(&ds->location, - 40075000, &dive_site_table); + 40075000, divelog.sites); if (nearest_ds) return nearest_ds->name; else @@ -77,7 +78,7 @@ QVariant DivesiteImportedModel::data(const QModelIndex &index, int role) const unsigned int distance = 0; struct dive_site *nearest_ds = get_dive_site_by_gps_proximity(&ds->location, - 40075000, &dive_site_table); + 40075000, divelog.sites); if (nearest_ds) distance = get_distance(&ds->location, &nearest_ds->location); @@ -134,7 +135,7 @@ void DivesiteImportedModel::repopulate(struct dive_site_table *sites) lastIndex = importedSitesTable->nr - 1; checkStates.resize(importedSitesTable->nr); for (int row = 0; row < importedSitesTable->nr; row++) - if (get_dive_site_by_gps(&importedSitesTable->dive_sites[row]->location, &dive_site_table)) + if (get_dive_site_by_gps(&importedSitesTable->dive_sites[row]->location, divelog.sites)) checkStates[row] = false; else checkStates[row] = true; diff --git a/qt-models/divetripmodel.cpp b/qt-models/divetripmodel.cpp index 965575484..32b643f40 100644 --- a/qt-models/divetripmodel.cpp +++ b/qt-models/divetripmodel.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "qt-models/divetripmodel.h" #include "core/divefilter.h" +#include "core/divelog.h" #ifdef SUBSURFACE_MOBILE #include "qt-models/mobilelistmodel.h" #endif @@ -711,7 +712,7 @@ void DiveTripModelTree::populate() // we want this to be two calls as the second text is overwritten below by the lines starting with "\r" uiNotification(QObject::tr("populate data model")); uiNotification(QObject::tr("start processing")); - for (int i = 0; i < dive_table.nr; ++i) { + for (int i = 0; i < divelog.dives->nr; ++i) { dive *d = get_dive(i); if (!d) // should never happen continue; @@ -741,7 +742,7 @@ void DiveTripModelTree::populate() // Remember the index of the current dive oldCurrent = current_dive; - uiNotification(QObject::tr("%1 dives processed").arg(dive_table.nr)); + uiNotification(QObject::tr("%1 dives processed").arg(divelog.dives->nr)); } int DiveTripModelTree::rowCount(const QModelIndex &parent) const @@ -1470,8 +1471,8 @@ void DiveTripModelList::populate() DiveFilter::instance()->reset(); // The data was reset - update filter status. TODO: should this really be done here? // Fill model - items.reserve(dive_table.nr); - for (int i = 0; i < dive_table.nr; ++i) { + items.reserve(divelog.dives->nr); + for (int i = 0; i < divelog.dives->nr; ++i) { dive *d = get_dive(i); if (!d || d->hidden_by_filter) continue; diff --git a/qt-models/maplocationmodel.cpp b/qt-models/maplocationmodel.cpp index 3ea24280a..8860217e9 100644 --- a/qt-models/maplocationmodel.cpp +++ b/qt-models/maplocationmodel.cpp @@ -3,6 +3,7 @@ #include "divelocationmodel.h" #include "core/divesite.h" #include "core/divefilter.h" +#include "core/divelog.h" #include "core/settings/qPrefDisplay.h" #if !defined(SUBSURFACE_MOBILE) && !defined(SUBSURFACE_DOWNLOADER) #include "qt-models/filtermodels.h" @@ -161,8 +162,8 @@ void MapLocationModel::reload(QObject *map) if (diveSiteMode) m_selectedDs = DiveFilter::instance()->filteredDiveSites(); #endif - for (int i = 0; i < dive_site_table.nr; ++i) { - struct dive_site *ds = dive_site_table.dive_sites[i]; + for (int i = 0; i < divelog.sites->nr; ++i) { + struct dive_site *ds = divelog.sites->dive_sites[i]; QGeoCoordinate dsCoord; // Don't show dive sites of hidden dives, unless we're in dive site edit mode. diff --git a/smtk-import/smartrak.c b/smtk-import/smartrak.c index 61c8d080a..c0909d765 100644 --- a/smtk-import/smartrak.c +++ b/smtk-import/smartrak.c @@ -27,6 +27,7 @@ #endif #include "core/dive.h" +#include "core/divelog.h" #include "core/subsurface-string.h" #include "core/gettext.h" #include "core/divelist.h" @@ -321,7 +322,7 @@ static void smtk_wreck_site(MdbHandle *mdb, char *site_idx, struct dive_site *ds * Location format: * | Idx | Text | Province | Country | Depth | */ -static void smtk_build_location(MdbHandle *mdb, char *idx, struct dive_site **location) +static void smtk_build_location(MdbHandle *mdb, char *idx, struct dive_site **location, struct divelog *log) { MdbTableDef *table; MdbColumn *col[MDB_MAX_COLS]; @@ -373,7 +374,7 @@ static void smtk_build_location(MdbHandle *mdb, char *idx, struct dive_site **lo do { rc = mdb_fetch_row(table); } while (strcasecmp(bound_values[0], loc_idx) && rc != 0); - if (rc == 0){ + if (rc == 0) { smtk_free(bound_values, table->num_cols); mdb_free_tabledef(table); if(notes) @@ -393,12 +394,12 @@ static void smtk_build_location(MdbHandle *mdb, char *idx, struct dive_site **lo str = smtk_concat_str(str, ", ", "%s", bound_values[1]); // Locality str = smtk_concat_str(str, ", ", "%s", site); - ds = get_dive_site_by_name(str, &dive_site_table); + ds = get_dive_site_by_name(str, log->sites); if (!ds) { if (!has_location(&loc)) - ds = create_dive_site(str, &dive_site_table); + ds = create_dive_site(str, log->sites); else - ds = create_dive_site_with_gps(str, &loc, &dive_site_table); + ds = create_dive_site_with_gps(str, &loc, log->sites); } *location = ds; smtk_free(bound_values, table->num_cols); @@ -928,7 +929,7 @@ static dc_status_t libdc_buffer_complete(device_data_t *dev_data, unsigned char * a single DB breaks binded row data, and so would break the top loop. */ -void smartrak_import(const char *file, struct dive_table *divetable) +void smartrak_import(const char *file, struct divelog *log) { MdbHandle *mdb, *mdb_clon; MdbTableDef *mdb_table; @@ -1097,7 +1098,7 @@ void smartrak_import(const char *file, struct dive_table *divetable) weightsystem_t ws = { {lrint(strtod(col[coln(WEIGHT)]->bind_ptr, NULL) * 1000)}, "", false }; add_cloned_weightsystem(&smtkdive->weightsystems, ws); smtkdive->suit = copy_string(suit_list[atoi(col[coln(SUITIDX)]->bind_ptr) - 1]); - smtk_build_location(mdb_clon, col[coln(SITEIDX)]->bind_ptr, &smtkdive->dive_site); + smtk_build_location(mdb_clon, col[coln(SITEIDX)]->bind_ptr, &smtkdive->dive_site, log); smtkdive->buddy = smtk_locate_buddy(mdb_clon, col[0]->bind_ptr, buddy_list); smtk_parse_relations(mdb_clon, smtkdive, col[0]->bind_ptr, "Type", "TypeRelation", type_list, true); smtk_parse_relations(mdb_clon, smtkdive, col[0]->bind_ptr, "Activity", "ActivityRelation", activity_list, false); @@ -1109,7 +1110,7 @@ void smartrak_import(const char *file, struct dive_table *divetable) smtk_parse_bookmarks(mdb_clon, smtkdive, col[0]->bind_ptr); smtkdive->notes = smtk_concat_str(smtkdive->notes, "\n", "%s", col[coln(REMARKS)]->bind_ptr); - record_dive_to_table(smtkdive, divetable); + record_dive_to_table(smtkdive, log->dives); device_data_free(devdata); } mdb_free_tabledef(mdb_table); @@ -1117,5 +1118,5 @@ void smartrak_import(const char *file, struct dive_table *divetable) mdb->catalog = NULL; mdb_close(mdb_clon); mdb_close(mdb); - sort_dive_table(divetable); + sort_dive_table(log->dives); } diff --git a/smtk-import/smrtk2ssrfc_window.cpp b/smtk-import/smrtk2ssrfc_window.cpp index a4d778437..78b9ef1c3 100644 --- a/smtk-import/smrtk2ssrfc_window.cpp +++ b/smtk-import/smrtk2ssrfc_window.cpp @@ -3,6 +3,7 @@ #include "ui_smrtk2ssrfc_window.h" #include "qt-models/filtermodels.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divelist.h" #include "core/errorhelper.h" #include "core/settings/qPrefDisplay.h" @@ -84,7 +85,7 @@ void Smrtk2ssrfcWindow::on_importButton_clicked() for (int i = 0; i < inputFiles.size(); ++i) { ui->progressBar->setValue(i); fileNamePtr = QFile::encodeName(inputFiles.at(i)); - smartrak_import(fileNamePtr.data(), &dive_table); + smartrak_import(fileNamePtr.data(), &divelog); ui->plainTextEdit->appendPlainText(error_buf); } ui->progressBar->setValue(inputFiles.size()); diff --git a/smtk-import/smrtk2ssrfc_window.h b/smtk-import/smrtk2ssrfc_window.h index c66653094..d17f8d098 100644 --- a/smtk-import/smrtk2ssrfc_window.h +++ b/smtk-import/smrtk2ssrfc_window.h @@ -6,7 +6,8 @@ #include #include -extern "C" void smartrak_import(const char *file, struct dive_table *divetable); +struct divelog; +extern "C" void smartrak_import(const char *file, struct divelog *log); namespace Ui { class Smrtk2ssrfcWindow; diff --git a/smtk-import/smtk_standalone.cpp b/smtk-import/smtk_standalone.cpp index 2ac4b62b8..bf3495460 100644 --- a/smtk-import/smtk_standalone.cpp +++ b/smtk-import/smtk_standalone.cpp @@ -3,12 +3,11 @@ #include #include "core/dive.h" #include "core/divelist.h" +#include "core/divelog.h" #include "smrtk2ssrfc_window.h" #include #include -extern "C" void smartrak_import(const char *file, struct dive_table *table); - /* * Simple command line interface to call directly smartrak_import() or launch * the GUI if called without arguments. @@ -48,7 +47,7 @@ int main(int argc, char *argv[]) for(i = 1; i < argc -1; i++) { infile = argv[i]; qDebug() << "\t" << infile << "\n"; - smartrak_import(infile, &dive_table); + smartrak_import(infile, &divelog); } qDebug() << "\n[Writing]\n\t" << outfile << "\n"; save_dives_logic(outfile, false, false); diff --git a/stats/statsvariables.cpp b/stats/statsvariables.cpp index a68fc398a..ad27c4404 100644 --- a/stats/statsvariables.cpp +++ b/stats/statsvariables.cpp @@ -2,6 +2,7 @@ #include "statsvariables.h" #include "statstranslations.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divemode.h" #include "core/divesite.h" #include "core/gas.h" @@ -1380,7 +1381,7 @@ struct DiveNrVariable : public StatsVariableTemplate binners() const override { - if (dive_table.nr > 1000) + if (divelog.dives->nr > 1000) return { &dive_nr_binner_20, &dive_nr_binner_50, &dive_nr_binner_100, &dive_nr_binner_200 }; else return { &dive_nr_binner_5, &dive_nr_binner_10, &dive_nr_binner_20, &dive_nr_binner_50 }; diff --git a/subsurface-desktop-main.cpp b/subsurface-desktop-main.cpp index 1b3483b20..918974f13 100644 --- a/subsurface-desktop-main.cpp +++ b/subsurface-desktop-main.cpp @@ -7,6 +7,7 @@ #include #include "core/downloadfromdcthread.h" // for fill_computer_list +#include "core/divelog.h" #include "core/errorhelper.h" #include "core/parse.h" #include "core/qt-gui.h" @@ -109,6 +110,7 @@ int main(int argc, char **argv) if (!quit) run_ui(); exit_ui(); + clear_divelog(&divelog); taglist_free(g_tag_list); parse_xml_exit(); free((void *)default_directory); diff --git a/subsurface-downloader-main.cpp b/subsurface-downloader-main.cpp index b8b65ffee..b9ec0c27a 100644 --- a/subsurface-downloader-main.cpp +++ b/subsurface-downloader-main.cpp @@ -8,6 +8,7 @@ #include "core/settings/qPref.h" #include "core/tag.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/subsurface-string.h" #include "core/file.h" #include "core/trip.h" @@ -40,10 +41,7 @@ int main(int argc, char **argv) QStringList files; QStringList importedFiles; QStringList arguments = QCoreApplication::arguments(); - struct dive_table dive_table = empty_dive_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table presets; + struct divelog log; // set a default logfile name for libdivecomputer so we always get a logfile logfile_name = strdup("subsurface-downloader.log"); @@ -95,7 +93,7 @@ int main(int argc, char **argv) filesOnCommandLine = !files.isEmpty() || !importedFiles.isEmpty(); if (!files.isEmpty()) { qDebug() << "loading dive data from" << files; - parse_file(qPrintable(files.first()), &dive_table, &trip_table, &sites, &devices, &presets); + parse_file(qPrintable(files.first()), &log); } print_files(); if (!quit) { @@ -106,6 +104,7 @@ int main(int argc, char **argv) } } save_dives(qPrintable(files.first())); + clear_divelog(&divelog); taglist_free(g_tag_list); parse_xml_exit(); free((void *)default_directory); diff --git a/subsurface-mobile-main.cpp b/subsurface-mobile-main.cpp index a23974154..d090fd6b9 100644 --- a/subsurface-mobile-main.cpp +++ b/subsurface-mobile-main.cpp @@ -7,6 +7,7 @@ #include #include "core/dive.h" +#include "core/divelog.h" #include "core/color.h" #include "core/downloadfromdcthread.h" #include "core/parse.h" @@ -93,6 +94,7 @@ int main(int argc, char **argv) if (!quit) run_mobile_ui(initial_font_size); exit_ui(); + clear_divelog(&divelog); taglist_free(g_tag_list); parse_xml_exit(); subsurface_console_exit(); diff --git a/tests/testAirPressure.cpp b/tests/testAirPressure.cpp index 2a29fe813..8cca009c7 100644 --- a/tests/testAirPressure.cpp +++ b/tests/testAirPressure.cpp @@ -2,6 +2,7 @@ #include "testAirPressure.h" #include "core/device.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/trip.h" #include "core/file.h" @@ -21,8 +22,7 @@ void TestAirPressure::get_dives() struct dive *dive; verbose = 1; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/TestAtmPress.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/TestAtmPress.xml", &divelog), 0); dive = get_dive(0); dive->selected = true; QVERIFY(dive != NULL); @@ -57,8 +57,7 @@ void TestAirPressure::testWriteReadBackAirPressure() dive->surface_pressure.mbar = ap; QCOMPARE(save_dives("./testout.ssrf"), 0); clear_dive_file_data(); - QCOMPARE(parse_file("./testout.ssrf", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file("./testout.ssrf", &divelog), 0); dive = get_dive(0); QVERIFY(dive != NULL); dive->selected = true; diff --git a/tests/testdivesiteduplication.cpp b/tests/testdivesiteduplication.cpp index d2b29a0f6..e905e3ee4 100644 --- a/tests/testdivesiteduplication.cpp +++ b/tests/testdivesiteduplication.cpp @@ -1,18 +1,15 @@ // SPDX-License-Identifier: GPL-2.0 #include "testdivesiteduplication.h" -#include "core/device.h" -#include "core/dive.h" +#include "core/divelog.h" #include "core/divesite.h" -#include "core/trip.h" #include "core/file.h" #include "core/pref.h" void TestDiveSiteDuplication::testReadV2() { prefs.cloud_base_url = strdup(default_prefs.cloud_base_url); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/TwoTimesTwo.ssrf", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(dive_site_table.nr, 2); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/TwoTimesTwo.ssrf", &divelog), 0); + QCOMPARE(divelog.sites->nr, 2); } QTEST_GUILESS_MAIN(TestDiveSiteDuplication) diff --git a/tests/testgitstorage.cpp b/tests/testgitstorage.cpp index b1518a17e..997b913dd 100644 --- a/tests/testgitstorage.cpp +++ b/tests/testgitstorage.cpp @@ -4,13 +4,13 @@ #include "core/device.h" #include "core/dive.h" -#include "core/divesite.h" +#include "core/divelist.h" +#include "core/divelog.h" #include "core/file.h" #include "core/qthelper.h" #include "core/subsurfacestartup.h" #include "core/settings/qPrefProxy.h" #include "core/settings/qPrefCloudStorage.h" -#include "core/trip.h" #include "core/git-access.h" #include @@ -152,8 +152,7 @@ void TestGitStorage::initTestCase() // cleanup local and remote branches localRemoteCleanup(); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); } void TestGitStorage::cleanupTestCase() @@ -185,8 +184,7 @@ void TestGitStorage::testGitStorageLocal() { // test writing and reading back from local git storage git_repository *repo; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/SampleDivesV2.ssrf", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/SampleDivesV2.ssrf", &divelog), 0); QFETCH(QString, testDirName); QFETCH(QString, prefixRead); QFETCH(QString, prefixWrite); @@ -199,8 +197,7 @@ void TestGitStorage::testGitStorageLocal() QCOMPARE(save_dives(qPrintable(repoNameWrite + "[test]")), 0); QCOMPARE(save_dives("./SampleDivesV3.ssrf"), 0); clear_dive_file_data(); - QCOMPARE(parse_file(qPrintable(repoNameRead + "[test]"), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(repoNameRead + "[test]"), &divelog), 0); QCOMPARE(save_dives("./SampleDivesV3viagit.ssrf"), 0); QFile org("./SampleDivesV3.ssrf"); org.open(QFile::ReadOnly); @@ -218,12 +215,10 @@ void TestGitStorage::testGitStorageCloud() // test writing and reading back from cloud storage // connect to the ssrftest repository on the cloud server // and repeat the same test as before with the local git storage - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/SampleDivesV2.ssrf", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/SampleDivesV2.ssrf", &divelog), 0); QCOMPARE(save_dives(qPrintable(cloudTestRepo)), 0); clear_dive_file_data(); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); QCOMPARE(save_dives("./SampleDivesV3viacloud.ssrf"), 0); QFile org("./SampleDivesV3.ssrf"); org.open(QFile::ReadOnly); @@ -241,10 +236,8 @@ void TestGitStorage::testGitStorageCloudOfflineSync() // make a change to local cache repo (pretending that we did some offline changes) // and then open the remote one again and check that things were propagated correctly // read the local repo from the previous test and add dive 10 - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test10.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test10.xml", &divelog), 0); // 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(); @@ -255,8 +248,7 @@ void TestGitStorage::testGitStorageCloudOfflineSync() clear_dive_file_data(); // now pretend that we are online again and open the cloud storage and compare git_local_only = false; - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); QCOMPARE(save_dives("./SampleDivesV3plus10viacloud.ssrf"), 0); QFile org("./SampleDivesV3plus10local.ssrf"); org.open(QFile::ReadOnly); @@ -271,8 +263,7 @@ void TestGitStorage::testGitStorageCloudOfflineSync() QCOMPARE(save_dives(qPrintable(cloudTestRepo)), 0); clear_dive_file_data(); moveDir(localCacheDir, localCacheDir + "save"); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); QCOMPARE(save_dives("./SampleDivesV3plus10fromcloud.ssrf"), 0); org.close(); org.open(QFile::ReadOnly); @@ -301,10 +292,8 @@ void TestGitStorage::testGitStorageCloudMerge() // (1) open the repo, add dive test11 and save to the cloud git_local_only = false; - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test11.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test11.xml", &divelog), 0); process_loaded_dives(); QCOMPARE(save_dives(qPrintable(cloudTestRepo)), 0); clear_dive_file_data(); @@ -315,34 +304,27 @@ void TestGitStorage::testGitStorageCloudMerge() // (3) open the repo from the old cache and add dive test12 while offline git_local_only = true; - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test12.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test12.xml", &divelog), 0); process_loaded_dives(); QCOMPARE(save_dives(qPrintable(cloudTestRepo)), 0); clear_dive_file_data(); // (4) now take things back online git_local_only = false; - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); clear_dive_file_data(); // (5) now we should have all the dives in our repo on the second client // first create the reference data from the xml files: - QCOMPARE(parse_file("./SampleDivesV3plus10local.ssrf", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test11.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test12.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file("./SampleDivesV3plus10local.ssrf", &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test11.xml", &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test12.xml", &divelog), 0); process_loaded_dives(); QCOMPARE(save_dives("./SampleDivesV3plus10-11-12.ssrf"), 0); // then load from the cloud clear_dive_file_data(); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); QCOMPARE(save_dives("./SampleDivesV3plus10-11-12-merged.ssrf"), 0); // finally compare what we have @@ -359,8 +341,7 @@ void TestGitStorage::testGitStorageCloudMerge() // (6) move ourselves back to the first client and compare data there moveDir(localCacheDir + "client1", localCacheDir); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); QCOMPARE(save_dives("./SampleDivesV3plus10-11-12-merged-client1.ssrf"), 0); QFile client1("./SampleDivesV3plus10-11-12-merged-client1.ssrf"); @@ -376,8 +357,7 @@ void TestGitStorage::testGitStorageCloudMerge2() // edit the same dive in the cloud repo // merge // (1) open repo, delete second dive, save offline - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); struct dive *dive = get_dive(1); delete_single_dive(1); @@ -391,8 +371,7 @@ void TestGitStorage::testGitStorageCloudMerge2() moveDir(localCacheDir, localCacheDir + "save"); // (3) now we open the cloud storage repo and modify that second dive - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); dive = get_dive(1); QVERIFY(dive != NULL); @@ -404,8 +383,7 @@ void TestGitStorage::testGitStorageCloudMerge2() // (4) move the saved local cache backinto place and try to open the cloud repo // -> this forces a merge moveDir(localCacheDir + "save", localCacheDir); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); QCOMPARE(save_dives("./SampleDivesMinus1-merged.ssrf"), 0); QCOMPARE(save_dives(qPrintable(cloudTestRepo)), 0); QFile org("./SampleDivesMinus1-merged.ssrf"); @@ -428,8 +406,7 @@ void TestGitStorage::testGitStorageCloudMerge3() // (1) open repo, edit notes of first three dives - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); struct dive *dive; QVERIFY((dive = get_dive(0)) != 0); @@ -445,8 +422,7 @@ void TestGitStorage::testGitStorageCloudMerge3() clear_dive_file_data(); // (2) make different edits offline - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); QVERIFY((dive = get_dive(0)) != 0); free(dive->notes); @@ -465,8 +441,7 @@ void TestGitStorage::testGitStorageCloudMerge3() // (3) simulate a second system by moving the cache away and open the cloud storage repo and modify // those first dive notes differently while online moveDir(localCacheDir, localCacheDir + "save"); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); process_loaded_dives(); QVERIFY((dive = get_dive(0)) != 0); free(dive->notes); @@ -482,8 +457,7 @@ void TestGitStorage::testGitStorageCloudMerge3() // (4) move the saved local cache back into place and open the cloud repo -> this forces a merge moveDir(localCacheDir + "save", localCacheDir); - QCOMPARE(parse_file(qPrintable(cloudTestRepo), &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(qPrintable(cloudTestRepo), &divelog), 0); QCOMPARE(save_dives("./SampleDivesMerge3.ssrf"), 0); // we are not trying to compare this to a pre-determined result... what this test // checks is that there are no parsing errors with the merge diff --git a/tests/testmerge.cpp b/tests/testmerge.cpp index 06d82e870..bc7fe1db7 100644 --- a/tests/testmerge.cpp +++ b/tests/testmerge.cpp @@ -2,6 +2,7 @@ #include "testmerge.h" #include "core/device.h" #include "core/dive.h" // for save_dives() +#include "core/divelog.h" #include "core/divesite.h" #include "core/file.h" #include "core/trip.h" @@ -25,15 +26,11 @@ void TestMerge::testMergeEmpty() /* * check that we correctly merge mixed cylinder dives */ - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); + struct divelog log; + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0); QFile org(SUBSURFACE_TEST_DATA "/dives/test47+48.xml"); org.open(QFile::ReadOnly); @@ -43,9 +40,8 @@ void TestMerge::testMergeEmpty() QTextStream outS(&out); QStringList readin = orgS.readAll().split("\n"); QStringList written = outS.readAll().split("\n"); - while (readin.size() && written.size()) { + while (readin.size() && written.size()) QCOMPARE(written.takeFirst().trimmed(), readin.takeFirst().trimmed()); - } } void TestMerge::testMergeBackwards() @@ -53,15 +49,11 @@ void TestMerge::testMergeBackwards() /* * check that we correctly merge mixed cylinder dives */ - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); + struct divelog log; + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0); QFile org(SUBSURFACE_TEST_DATA "/dives/test48+47.xml"); org.open(QFile::ReadOnly); @@ -71,9 +63,8 @@ void TestMerge::testMergeBackwards() QTextStream outS(&out); QStringList readin = orgS.readAll().split("\n"); QStringList written = outS.readAll().split("\n"); - while (readin.size() && written.size()) { + while (readin.size() && written.size()) QCOMPARE(written.takeFirst().trimmed(), readin.takeFirst().trimmed()); - } } QTEST_GUILESS_MAIN(TestMerge) diff --git a/tests/testparse.cpp b/tests/testparse.cpp index c3446712b..ab07c14b0 100644 --- a/tests/testparse.cpp +++ b/tests/testparse.cpp @@ -2,6 +2,7 @@ #include "testparse.h" #include "core/device.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/errorhelper.h" #include "core/trip.h" @@ -85,19 +86,18 @@ int TestParse::parseCSV(int units, std::string file) xml_params_add_int(¶ms, "airtempField", -1); xml_params_add_int(¶ms, "watertempField", -1); - return parse_manual_file(file.c_str(), ¶ms, &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + return parse_manual_file(file.c_str(), ¶ms, &divelog); } int TestParse::parseDivingLog() { // Parsing of DivingLog import from SQLite database - struct dive_site *ds = alloc_or_get_dive_site(0xdeadbeef, &dive_site_table); + struct dive_site *ds = alloc_or_get_dive_site(0xdeadbeef, divelog.sites); ds->name = copy_string("Suomi - - Hälvälä"); int ret = sqlite3_open(SUBSURFACE_TEST_DATA "/dives/TestDivingLog4.1.1.sql", &_sqlite3_handle); if (ret == 0) - ret = parse_divinglog_buffer(_sqlite3_handle, 0, 0, 0, &dive_table, &trip_table, &dive_site_table, &device_table); + ret = parse_divinglog_buffer(_sqlite3_handle, 0, 0, 0, &divelog); else fprintf(stderr, "Can't open sqlite3 db: " SUBSURFACE_TEST_DATA "/dives/TestDivingLog4.1.1.sql"); @@ -107,30 +107,28 @@ int TestParse::parseDivingLog() int TestParse::parseV2NoQuestion() { // parsing of a V2 file should work - return parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + return parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &divelog); } int TestParse::parseV3() { // parsing of a V3 files should succeed - return parse_file(SUBSURFACE_TEST_DATA "/dives/test42.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + return parse_file(SUBSURFACE_TEST_DATA "/dives/test42.xml", &divelog); } void TestParse::testParse() { QCOMPARE(parseCSV(0, SUBSURFACE_TEST_DATA "/dives/test41.csv"), 0); - fprintf(stderr, "number of dives %d \n", dive_table.nr); + fprintf(stderr, "number of dives %d \n", divelog.dives->nr); QCOMPARE(parseDivingLog(), 0); - fprintf(stderr, "number of dives %d \n", dive_table.nr); + fprintf(stderr, "number of dives %d \n", divelog.dives->nr); QCOMPARE(parseV2NoQuestion(), 0); - fprintf(stderr, "number of dives %d \n", dive_table.nr); + fprintf(stderr, "number of dives %d \n", divelog.dives->nr); QCOMPARE(parseV3(), 0); - fprintf(stderr, "number of dives %d \n", dive_table.nr); + fprintf(stderr, "number of dives %d \n", divelog.dives->nr); QCOMPARE(save_dives("./testout.ssrf"), 0); FILE_COMPARE("./testout.ssrf", @@ -140,7 +138,7 @@ void TestParse::testParse() void TestParse::testParseDM4() { QCOMPARE(sqlite3_open(SUBSURFACE_TEST_DATA "/dives/TestDiveDM4.db", &_sqlite3_handle), 0); - QCOMPARE(parse_dm4_buffer(_sqlite3_handle, 0, 0, 0, &dive_table, &trip_table, &dive_site_table, &device_table), 0); + QCOMPARE(parse_dm4_buffer(_sqlite3_handle, 0, 0, 0, &divelog), 0); QCOMPARE(save_dives("./testdm4out.ssrf"), 0); FILE_COMPARE("./testdm4out.ssrf", @@ -150,7 +148,7 @@ void TestParse::testParseDM4() void TestParse::testParseDM5() { QCOMPARE(sqlite3_open(SUBSURFACE_TEST_DATA "/dives/TestDiveDM5.db", &_sqlite3_handle), 0); - QCOMPARE(parse_dm5_buffer(_sqlite3_handle, 0, 0, 0, &dive_table, &trip_table, &dive_site_table, &device_table), 0); + QCOMPARE(parse_dm5_buffer(_sqlite3_handle, 0, 0, 0, &divelog), 0); QCOMPARE(save_dives("./testdm5out.ssrf"), 0); FILE_COMPARE("./testdm5out.ssrf", @@ -179,18 +177,17 @@ void TestParse::testParseHUDC() xml_params_add(¶ms, "hw", "\"DC text\""); QCOMPARE(parse_csv_file(SUBSURFACE_TEST_DATA "/dives/TestDiveSeabearHUDC.csv", - ¶ms, "csv", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table), + ¶ms, "csv", &divelog), 0); - QCOMPARE(dive_table.nr, 1); + QCOMPARE(divelog.dives->nr, 1); /* * CSV import uses time and date stamps relative to current * time, thus we need to use a static (random) timestamp */ - if (dive_table.nr > 0) { - struct dive *dive = dive_table.dives[dive_table.nr - 1]; + if (divelog.dives->nr > 0) { + struct dive *dive = divelog.dives->dives[divelog.dives->nr - 1]; dive->when = 1255152761; dive->dc.when = 1255152761; } @@ -225,13 +222,12 @@ void TestParse::testParseNewFormat() "/dives/") .append(files.at(i)) .toLatin1() - .data(), &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table), + .data(), &divelog), 0); - QCOMPARE(dive_table.nr, i + 1); + QCOMPARE(divelog.dives->nr, i + 1); } - fprintf(stderr, "number of dives %d \n", dive_table.nr); + fprintf(stderr, "number of dives %d \n", divelog.dives->nr); QCOMPARE(save_dives("./testsbnewout.ssrf"), 0); // Currently the CSV parse fails @@ -245,9 +241,9 @@ void TestParse::testParseDLD() QString filename = SUBSURFACE_TEST_DATA "/dives/TestDiveDivelogsDE.DLD"; QVERIFY(readfile(filename.toLatin1().data(), &mem) > 0); - QVERIFY(try_to_open_zip(filename.toLatin1().data(), &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table) > 0); + QVERIFY(try_to_open_zip(filename.toLatin1().data(), &divelog) > 0); - fprintf(stderr, "number of dives from DLD: %d \n", dive_table.nr); + fprintf(stderr, "number of dives from DLD: %d \n", divelog.dives->nr); // Compare output QCOMPARE(save_dives("./testdldout.ssrf"), 0); @@ -260,10 +256,8 @@ void TestParse::testParseMerge() /* * check that we correctly merge mixed cylinder dives */ - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/ostc.xml", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table), 0); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/vyper.xml", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/ostc.xml", &divelog), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/vyper.xml", &divelog), 0); QCOMPARE(save_dives("./testmerge.ssrf"), 0); FILE_COMPARE("./testmerge.ssrf", SUBSURFACE_TEST_DATA "/dives/mergedVyperOstc.xml"); @@ -303,22 +297,20 @@ int TestParse::parseCSVmanual(int units, std::string file) xml_params_add_int(¶ms, "datefmt", 2); xml_params_add_int(¶ms, "durationfmt", 2); xml_params_add_int(¶ms, "units", units); - return parse_manual_file(file.c_str(), ¶ms, &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + return parse_manual_file(file.c_str(), ¶ms, &divelog); } void TestParse::exportCSVDiveDetails() { int saved_sac = 0; - parse_file(SUBSURFACE_TEST_DATA "/dives/test25.xml", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/test25.xml", &divelog); export_dives_xslt("testcsvexportmanual.csv", 0, 0, "xml2manualcsv.xslt", false); export_dives_xslt("testcsvexportmanualimperial.csv", 0, 1, "xml2manualcsv.xslt", false); - if (dive_table.nr > 0) { - struct dive *dive = dive_table.dives[dive_table.nr - 1]; + if (divelog.dives->nr > 0) { + struct dive *dive = divelog.dives->dives[divelog.dives->nr - 1]; saved_sac = dive->sac; } clear_dive_file_data(); @@ -326,8 +318,8 @@ void TestParse::exportCSVDiveDetails() parseCSVmanual(1, "testcsvexportmanualimperial.csv"); // We do not currently support reading SAC, thus faking it - if (dive_table.nr > 0) { - struct dive *dive = dive_table.dives[dive_table.nr - 1]; + if (divelog.dives->nr > 0) { + struct dive *dive = divelog.dives->dives[divelog.dives->nr - 1]; dive->sac = saved_sac; } @@ -347,14 +339,13 @@ void TestParse::exportSubsurfaceCSV() xml_params params; /* Test SubsurfaceCSV with multiple cylinders */ - parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &divelog); export_dives_xslt("testcsvexportmanual-cyl.csv", 0, 0, "xml2manualcsv.xslt", false); export_dives_xslt("testcsvexportmanualimperial-cyl.csv", 0, 1, "xml2manualcsv.xslt", false); - if (dive_table.nr > 0) { - struct dive *dive = dive_table.dives[dive_table.nr - 1]; + if (divelog.dives->nr > 0) { + struct dive *dive = divelog.dives->dives[divelog.dives->nr - 1]; saved_sac = dive->sac; } @@ -362,12 +353,11 @@ void TestParse::exportSubsurfaceCSV() xml_params_add_int(¶ms, "separatorIndex", 0); xml_params_add_int(¶ms, "units", 1); - parse_csv_file("testcsvexportmanualimperial-cyl.csv", ¶ms, "SubsurfaceCSV", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + parse_csv_file("testcsvexportmanualimperial-cyl.csv", ¶ms, "SubsurfaceCSV", &divelog); // We do not currently support reading SAC, thus faking it - if (dive_table.nr > 0) { - struct dive *dive = dive_table.dives[dive_table.nr - 1]; + if (divelog.dives->nr > 0) { + struct dive *dive = divelog.dives->dives[divelog.dives->nr - 1]; dive->sac = saved_sac; } @@ -396,14 +386,12 @@ int TestParse::parseCSVprofile(int units, std::string file) xml_params_add_int(¶ms, "datefmt", 2); xml_params_add_int(¶ms, "units", units); - return parse_csv_file(file.c_str(), ¶ms, "csv", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + return parse_csv_file(file.c_str(), ¶ms, "csv", &divelog); } void TestParse::exportCSVDiveProfile() { - parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &divelog); export_dives_xslt("testcsvexportprofile.csv", 0, 0, "xml2csv.xslt", false); export_dives_xslt("testcsvexportprofileimperial.csv", 0, 1, "xml2csv.xslt", false); @@ -421,14 +409,13 @@ void TestParse::exportCSVDiveProfile() void TestParse::exportUDDF() { - parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/test40.xml", &divelog); export_dives_xslt("testuddfexport.uddf", 0, 1, "uddf-export.xslt", false); clear_dive_file_data(); - parse_file("testuddfexport.uddf", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + parse_file("testuddfexport.uddf", &divelog); export_dives_xslt("testuddfexport2.uddf", 0, 1, "uddf-export.xslt", false); FILE_COMPARE("testuddfexport.uddf", @@ -472,9 +459,9 @@ void TestParse::parseDL7() clear_dive_file_data(); QCOMPARE(parse_csv_file(SUBSURFACE_TEST_DATA "/dives/DL7.zxu", - ¶ms, "DL7", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table), + ¶ms, "DL7", &divelog), 0); - QCOMPARE(dive_table.nr, 3); + QCOMPARE(divelog.dives->nr, 3); QCOMPARE(save_dives("./testdl7out.ssrf"), 0); FILE_COMPARE("./testdl7out.ssrf", diff --git a/tests/testparseperformance.cpp b/tests/testparseperformance.cpp index 378982b83..ec28540e0 100644 --- a/tests/testparseperformance.cpp +++ b/tests/testparseperformance.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "testparseperformance.h" #include "core/device.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/trip.h" #include "core/file.h" @@ -65,8 +66,7 @@ void TestParsePerformance::parseSsrf() return; } QBENCHMARK { - parse_file(SUBSURFACE_TEST_DATA "/dives/large-anon.ssrf", &dive_table, &trip_table, - &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/large-anon.ssrf", &divelog); } } @@ -77,14 +77,12 @@ void TestParsePerformance::parseGit() // first parse this once to populate the local cache - this way network // effects don't dominate the parse time - parse_file(LARGE_TEST_REPO "[git]", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table); + parse_file(LARGE_TEST_REPO "[git]", &divelog); cleanup(); QBENCHMARK { - parse_file(LARGE_TEST_REPO "[git]", &dive_table, &trip_table, &dive_site_table, - &device_table, &filter_preset_table); + parse_file(LARGE_TEST_REPO "[git]", &divelog); } } diff --git a/tests/testpicture.cpp b/tests/testpicture.cpp index 0bf72b0ff..3c92ce4c0 100644 --- a/tests/testpicture.cpp +++ b/tests/testpicture.cpp @@ -2,10 +2,9 @@ #include "testpicture.h" #include "core/device.h" #include "core/dive.h" -#include "core/divesite.h" +#include "core/divelog.h" #include "core/errorhelper.h" #include "core/picture.h" -#include "core/trip.h" #include "core/file.h" #include "core/pref.h" #include @@ -29,7 +28,7 @@ void TestPicture::addPicture() struct picture *pic1, *pic2; verbose = 1; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test44.xml", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test44.xml", &divelog), 0); dive = get_dive(0); // Pictures will be added to selected dives dive->selected = true; diff --git a/tests/testprofile.cpp b/tests/testprofile.cpp index 246a12463..6dd9e898e 100644 --- a/tests/testprofile.cpp +++ b/tests/testprofile.cpp @@ -1,6 +1,7 @@ // SPDX-License-Identifier: GPL-2.0 #include "testprofile.h" #include "core/device.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/trip.h" #include "core/file.h" @@ -34,7 +35,7 @@ void TestProfile::init() void TestProfile::testProfileExport() { prefs.planner_deco_mode = BUEHLMANN; - parse_file(SUBSURFACE_TEST_DATA "/dives/abitofeverything.ssrf", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/abitofeverything.ssrf", &divelog); save_profiledata("exportprofile.csv", false); QFile org(SUBSURFACE_TEST_DATA "/dives/exportprofilereference.csv"); QCOMPARE(org.open(QFile::ReadOnly), true); @@ -50,7 +51,7 @@ void TestProfile::testProfileExport() void TestProfile::testProfileExportVPMB() { prefs.planner_deco_mode = VPMB; - parse_file(SUBSURFACE_TEST_DATA "/dives/abitofeverything.ssrf", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table); + parse_file(SUBSURFACE_TEST_DATA "/dives/abitofeverything.ssrf", &divelog); save_profiledata("exportprofileVPMB.csv", false); QFile org(SUBSURFACE_TEST_DATA "/dives/exportprofilereferenceVPMB.csv"); QCOMPARE(org.open(QFile::ReadOnly), true); diff --git a/tests/testrenumber.cpp b/tests/testrenumber.cpp index 1796928cb..dfe8f5e18 100644 --- a/tests/testrenumber.cpp +++ b/tests/testrenumber.cpp @@ -2,6 +2,7 @@ #include "testrenumber.h" #include "core/device.h" #include "core/dive.h" +#include "core/divelog.h" #include "core/divesite.h" #include "core/trip.h" #include "core/file.h" @@ -11,32 +12,24 @@ void TestRenumber::setup() { prefs.cloud_base_url = strdup(default_prefs.cloud_base_url); - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &dive_table, &trip_table, &dive_site_table, &device_table, &filter_preset_table), 0); + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &divelog), 0); process_loaded_dives(); } void TestRenumber::testMerge() { - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47b.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); - QCOMPARE(dive_table.nr, 1); + struct divelog log; + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47b.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); + QCOMPARE(divelog.dives->nr, 1); } void TestRenumber::testMergeAndAppend() { - struct dive_table table = empty_dive_table; - struct trip_table trips = empty_trip_table; - struct dive_site_table sites = empty_dive_site_table; - struct device_table devices; - struct filter_preset_table filter_presets; - QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47c.xml", &table, &trips, &sites, &devices, &filter_presets), 0); - add_imported_dives(&table, &trips, &sites, &devices, IMPORT_MERGE_ALL_TRIPS); - QCOMPARE(dive_table.nr, 2); + struct divelog log; + QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47c.xml", &log), 0); + add_imported_dives(&log, IMPORT_MERGE_ALL_TRIPS); + QCOMPARE(divelog.dives->nr, 2); struct dive *d = get_dive(1); QVERIFY(d != NULL); if (d)