mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-28 05:00:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/core/divelog.cpp

61 lines
1.4 KiB
C++
Raw Normal View History

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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
// SPDX-License-Identifier: GPL-2.0
#include "divelog.h"
#include "divelist.h"
#include "divesite.h"
#include "device.h"
cleanup: replace fprintf to stderr by report_info() Let's try to unify debugging output! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-24 20:03:08 +00:00
#include "errorhelper.h"
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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
#include "filterpreset.h"
#include "trip.h"
struct divelog divelog;
divelog::divelog() :
divelog: turn owning-pointers into unique_ptr<>s Since everything is C++ now, we can use unique_ptr<>s. This makes the code significantly shorter, because we can now use the default move constructor and assignment operators. This has a semantic change when std::move()-ing the divelog: now not the contents of the tables are moved, but the pointers. That is, the moved-from object now has no more tables and must not be used anymore. This made it necessary to replace std::move()s by std::swap()s. In that regard, the old code was in principle broken: it used moved-from objects, which may work but usually doesn't. This commit adds a myriad of .get() function calls where the code expects a C-style pointer. The plan is to remove virtually all of them, when we move free-standing functions into the class it acts on. Or, replace C-style pointers by references where we don't support NULL. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 17:34:43 +00:00
dives(std::make_unique<dive_table>()),
trips(std::make_unique<trip_table>()),
sites(std::make_unique<dive_site_table>()),
filter_presets(std::make_unique<filter_preset_table>()),
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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
autogroup(false)
{
*dives = empty_dive_table;
}
divelog::~divelog()
{
divelog: turn owning-pointers into unique_ptr<>s Since everything is C++ now, we can use unique_ptr<>s. This makes the code significantly shorter, because we can now use the default move constructor and assignment operators. This has a semantic change when std::move()-ing the divelog: now not the contents of the tables are moved, but the pointers. That is, the moved-from object now has no more tables and must not be used anymore. This made it necessary to replace std::move()s by std::swap()s. In that regard, the old code was in principle broken: it used moved-from objects, which may work but usually doesn't. This commit adds a myriad of .get() function calls where the code expects a C-style pointer. The plan is to remove virtually all of them, when we move free-standing functions into the class it acts on. Or, replace C-style pointers by references where we don't support NULL. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 17:34:43 +00:00
if (dives)
clear_dive_table(dives.get());
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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
}
divelog: turn owning-pointers into unique_ptr<>s Since everything is C++ now, we can use unique_ptr<>s. This makes the code significantly shorter, because we can now use the default move constructor and assignment operators. This has a semantic change when std::move()-ing the divelog: now not the contents of the tables are moved, but the pointers. That is, the moved-from object now has no more tables and must not be used anymore. This made it necessary to replace std::move()s by std::swap()s. In that regard, the old code was in principle broken: it used moved-from objects, which may work but usually doesn't. This commit adds a myriad of .get() function calls where the code expects a C-style pointer. The plan is to remove virtually all of them, when we move free-standing functions into the class it acts on. Or, replace C-style pointers by references where we don't support NULL. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 17:34:43 +00:00
divelog::divelog(divelog &&) = default;
struct divelog &divelog::operator=(divelog &&) = default;
core: use divelog struct in downloader code Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-12 11:44:29 +00:00
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
/* this implements the mechanics of removing the dive from the
* dive log and the trip, but doesn't deal with updating dive trips, etc */
core: move freestanding functions into divelog class There were only two of them, from the time C-code had to access the divelog: clear_divelog() and delete_single_dive(). Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 04:17:07 +00:00
void divelog::delete_single_dive(int idx)
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
{
core: move freestanding functions into divelog class There were only two of them, from the time C-code had to access the divelog: clear_divelog() and delete_single_dive(). Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 04:17:07 +00:00
if (idx < 0 || idx > dives->nr) {
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
report_info("Warning: deleting unexisting dive with index %d", idx);
return;
}
core: move freestanding functions into divelog class There were only two of them, from the time C-code had to access the divelog: clear_divelog() and delete_single_dive(). Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 04:17:07 +00:00
struct dive *dive = dives->dives[idx];
core: turn trip-table into our own sorted_owning_table Since the sorted_owning_table depends on the fact that different elements never compare as equal, make the comparison function safer in that respect. If all failes, compare the pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-01 20:05:57 +00:00
struct dive_trip *trip = unregister_dive_from_trip(dive);
// Deleting a dive may change the order of trips!
if (trip)
trips->sort();
if (trip && trip->dives.nr == 0)
trips->pull(trip);
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
unregister_dive_from_dive_site(dive);
divelog: turn owning-pointers into unique_ptr<>s Since everything is C++ now, we can use unique_ptr<>s. This makes the code significantly shorter, because we can now use the default move constructor and assignment operators. This has a semantic change when std::move()-ing the divelog: now not the contents of the tables are moved, but the pointers. That is, the moved-from object now has no more tables and must not be used anymore. This made it necessary to replace std::move()s by std::swap()s. In that regard, the old code was in principle broken: it used moved-from objects, which may work but usually doesn't. This commit adds a myriad of .get() function calls where the code expects a C-style pointer. The plan is to remove virtually all of them, when we move free-standing functions into the class it acts on. Or, replace C-style pointers by references where we don't support NULL. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-13 17:34:43 +00:00
delete_dive_from_table(dives.get(), idx);
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
}
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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
void divelog::clear()
{
core: fix leak when clearing dive log 46cf2fc0867 fixed a bug where clearing of a divelog, such as the one used for import, would erase dives in the global(!) divelog. However, the new code used the function clear_dive_table(), which only cleared the table without unregistering the dives. In particular, the dives were not removed from the trips, which means that the trips were not free()d. This reinstates the old code, but now passes a divelog paremeter to delete_single_dive() instead of accessing the global divelog. Moreover, delete dives from the back to avoid unnecessary copying. An alternative and definitely simpler solution might be to just add a "clear_trip_table()" after "clear_dive_table()". Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-12 10:46:57 +00:00
while (dives->nr > 0)
core: turn trip-table into our own sorted_owning_table Since the sorted_owning_table depends on the fact that different elements never compare as equal, make the comparison function safer in that respect. If all failes, compare the pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-01 20:05:57 +00:00
delete_dive_from_table(dives.get(), dives->nr - 1);
core: replace divesite_table_t by a vector of std::unique_ptr<>s This is a long commit, because it introduces a new abstraction: a general std::vector<> of std::unique_ptrs<>. Moreover, it replaces a number of pointers by C++ references, when the callee does not suppoert null objects. This simplifies memory management and makes ownership more explicit. It is a proof-of-concept and a test-bed for the other core data structrures. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-11 09:47:45 +00:00
sites->clear();
core: turn trip-table into our own sorted_owning_table Since the sorted_owning_table depends on the fact that different elements never compare as equal, make the comparison function safer in that respect. If all failes, compare the pointers. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-01 20:05:57 +00:00
trips->clear();
core: remove device C access code This was used from C, so there was lots of access code, which is not necessary. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 05:08:54 +00:00
devices.clear();
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 <bstoeger@mail.tuwien.ac.at>
2022-11-08 20:31:08 +00:00
filter_presets->clear();
}
Reference in a new issue Copy permalink