mirror of
https://github.com/subsurface/subsurface.git
synced 2024-11-28 13:10:19 +00:00
12a13d722a
In signals dives were sorted by date. This criterion is not be unique. Therefore sort by the dive_less_than() function of the core to avoid any inconsistencies between the Qt-models and the core data. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
69 lines
2.6 KiB
C++
69 lines
2.6 KiB
C++
// SPDX-License-Identifier: GPL-2.0
|
|
// Private definitions for the command-objects
|
|
|
|
#ifndef COMMAND_PRIVATE_H
|
|
#define COMMAND_PRIVATE_H
|
|
|
|
#include "core/dive.h"
|
|
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <QVector>
|
|
|
|
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.
|
|
// The dives are sorted by the dive_less_than() function defined in the core.
|
|
// 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 e1.first == e2.first ? dive_less_than(e1.second, e2.second) : e1.first < e2.first; });
|
|
|
|
// 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);
|
|
|
|
}
|
|
|
|
// Reset the selection to the dives of the "selection" vector and send the appropriate signals.
|
|
// Set the current dive to "currentDive". "currentDive" must be an element of "selection" (or
|
|
// null if "seletion" is empty). Return true if the selection or current dive changed.
|
|
bool setSelection(const std::vector<dive *> &selection, dive *currentDive);
|
|
|
|
// Get currently selectd dives
|
|
std::vector<dive *> getDiveSelection();
|
|
|
|
} // namespace Command
|
|
|
|
#endif // COMMAND_PRIVATE_H
|