mirror of
https://github.com/subsurface/subsurface.git
synced 2024-11-28 21:20:19 +00:00
cddd5942f8
The dive list was not updated automatically when an edit command was executed. There was already a signal to do that, viz. divesChanged(). But that signal worked by-trip and didn't have a dive-field specifier. The edit-commands used the divesEdited() signal that isn't by-trip but has a dive-field specifier. Unify these two signals to be by-trip and with dive-field specifier. This needs common code to generate the by-trip list that is moved to a command_private.h header. Since there might now be multiple signals (one per trip) actually check in the main-tab whether the current trip is affected to avoid multiple update of fields. This has the positive(?) effect of not doing any update if the current dive isn't changed. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
61 lines
2.1 KiB
C++
61 lines
2.1 KiB
C++
// SPDX-License-Identifier: GPL-2.0
|
|
// Private definitions for the command-objects
|
|
|
|
#ifndef COMMAND_PRIVATE_H
|
|
#define COMMAND_PRIVATE_H
|
|
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <QVector>
|
|
|
|
struct dive;
|
|
struct dive_trip;
|
|
|
|
namespace Command {
|
|
|
|
// Generally, signals are sent in batches per trip. To avoid writing the same loop
|
|
// again and again, this template takes a vector of trip / dive pairs, sorts it
|
|
// by trip and then calls a function-object with trip and a QVector of dives in that trip.
|
|
// Input parameters:
|
|
// - dives: a vector of trip,dive pairs, which will be sorted and processed in batches by trip.
|
|
// - action: a function object, taking a trip-pointer and a QVector of dives, which will be called for each batch.
|
|
template<typename Function>
|
|
void processByTrip(std::vector<std::pair<dive_trip *, dive *>> &dives, Function action)
|
|
{
|
|
// Use std::tie for lexicographical sorting of trip, then start-time
|
|
std::sort(dives.begin(), dives.end(),
|
|
[](const std::pair<dive_trip *, dive *> &e1, const std::pair<dive_trip *, dive *> &e2)
|
|
{ return std::tie(e1.first, e1.second->when) < std::tie(e2.first, e2.second->when); });
|
|
|
|
// Then, process the dives in batches by trip
|
|
size_t i, j; // Begin and end of batch
|
|
for (i = 0; i < dives.size(); i = j) {
|
|
dive_trip *trip = dives[i].first;
|
|
for (j = i + 1; j < dives.size() && dives[j].first == trip; ++j)
|
|
; // pass
|
|
// Copy dives into a QVector. Some sort of "range_view" would be ideal, but Qt doesn't work this way.
|
|
QVector<dive *> divesInTrip(j - i);
|
|
for (size_t k = i; k < j; ++k)
|
|
divesInTrip[k - i] = dives[k].second;
|
|
|
|
// Finally, emit the signal
|
|
action(trip, divesInTrip);
|
|
}
|
|
}
|
|
|
|
// The processByTrip() function above takes a vector if (trip, dive) pairs.
|
|
// This overload takes a vector of dives.
|
|
template<typename Vector, typename Function>
|
|
void processByTrip(Vector &divesIn, Function action)
|
|
{
|
|
std::vector<std::pair<dive_trip *, dive *>> dives;
|
|
dives.reserve(divesIn.size());
|
|
for (dive *d: divesIn)
|
|
dives.push_back({ d->divetrip, d });
|
|
processByTrip(dives, action);
|
|
|
|
}
|
|
|
|
} // namespace Command
|
|
|
|
#endif // COMMAND_PRIVATE_H
|