1187 lines
38 KiB
C++
1187 lines
38 KiB
C++
/************************************************************************
|
|
MeOS - Orienteering Software
|
|
Copyright (C) 2009-2020 Melin Software HB
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License fro more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
Melin Software HB - software@melin.nu - www.melin.nu
|
|
Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
|
|
|
|
************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include <vector>
|
|
#include <set>
|
|
#include <cassert>
|
|
#include <algorithm>
|
|
#include <limits>
|
|
|
|
#include "oEvent.h"
|
|
#include "oDataContainer.h"
|
|
|
|
#include "meosException.h"
|
|
#include "TabBase.h"
|
|
#include "meos.h"
|
|
#include "meos_util.h"
|
|
#include "generalresult.h"
|
|
#include "metalist.h"
|
|
#include "TabList.h"
|
|
#include "listeditor.h"
|
|
|
|
template<typename T> struct ResultCalcData {
|
|
int groupId;
|
|
int score;
|
|
bool operator<(const ResultCalcData<T> &c) const {
|
|
if (groupId != c.groupId)
|
|
return groupId < c.groupId;
|
|
else
|
|
return score < c.score;
|
|
}
|
|
T *dst;
|
|
|
|
ResultCalcData() {}
|
|
ResultCalcData(int g, int s, T* d) : groupId(g), score(s), dst(d) {}
|
|
};
|
|
|
|
template<typename T, typename Apply> void calculatePlace(vector<ResultCalcData<T>> &data, Apply apply) {
|
|
int groupId = -1;
|
|
int cPlace = 0, vPlace = 0, cScore = 0;
|
|
bool invalidClass = false;
|
|
bool useResults = true;
|
|
sort(data.begin(), data.end());
|
|
for (auto &it : data) {
|
|
// Start new "class"
|
|
if (groupId != it.groupId) {
|
|
groupId = it.groupId;
|
|
cPlace = 0;
|
|
vPlace = 0;
|
|
cScore = 0;
|
|
pClass cls = it.dst->getClassRef(true);
|
|
useResults = true;// cls ? cls->getNoTiming() == false : true;
|
|
invalidClass = cls ? cls->getClassStatus() != oClass::ClassStatus::Normal : false;
|
|
}
|
|
|
|
if (invalidClass) {
|
|
apply(it, 0);
|
|
}
|
|
else {
|
|
int tPlace = 0;
|
|
if (it.score > 0) {
|
|
cPlace++;
|
|
if (it.score > cScore)
|
|
vPlace = cPlace;
|
|
|
|
cScore = it.score;
|
|
if (useResults)
|
|
tPlace = vPlace;
|
|
}
|
|
else
|
|
tPlace = 0;
|
|
|
|
apply(it, tPlace);
|
|
}
|
|
}
|
|
}
|
|
|
|
void oEvent::calculateSplitResults(int controlIdFrom, int controlIdTo) {
|
|
oRunnerList::iterator it;
|
|
|
|
for (it=Runners.begin(); it!=Runners.end(); ++it) {
|
|
int st = 0;
|
|
if (controlIdFrom > 0 && controlIdFrom != oPunch::PunchStart) {
|
|
RunnerStatus stat;
|
|
it->getSplitTime(controlIdFrom, stat, st);
|
|
if (stat != StatusOK) {
|
|
it->tempStatus = stat;
|
|
it->tempRT = 0;
|
|
continue;
|
|
}
|
|
}
|
|
if (controlIdTo == 0 || controlIdTo == oPunch::PunchFinish) {
|
|
it->tempRT = max(0, it->FinishTime - (st + it->tStartTime) );
|
|
if (it->tempRT > 0)
|
|
it->tempRT += it->getTimeAdjustment();
|
|
it->tempStatus = it->tStatus;
|
|
}
|
|
else {
|
|
int ft = 0;
|
|
it->getSplitTime(controlIdTo, it->tempStatus, ft);
|
|
if (it->tempStatus==StatusOK && it->tStatus > StatusOK)
|
|
it->tempStatus=it->tStatus;
|
|
|
|
it->tempRT = max(0, ft - st);
|
|
}
|
|
}
|
|
|
|
Runners.sort(oRunner::sortSplit);
|
|
int cClassId=-1;
|
|
int cPlace=0;
|
|
int vPlace=0;
|
|
int cTime=0;
|
|
|
|
for (it=Runners.begin(); it != Runners.end(); ++it){
|
|
if (it->getClassId(true)!=cClassId){
|
|
cClassId=it->getClassId(true);
|
|
cPlace=0;
|
|
vPlace=0;
|
|
cTime=0;
|
|
it->Class->tLegLeaderTime=9999999;
|
|
}
|
|
|
|
if (it->tempStatus==StatusOK) {
|
|
cPlace++;
|
|
|
|
if (it->Class)
|
|
it->Class->tLegLeaderTime=min(it->tempRT, it->Class->tLegLeaderTime);
|
|
|
|
if (it->tempRT>cTime)
|
|
vPlace=cPlace;
|
|
|
|
cTime=it->tempRT;
|
|
|
|
it->tPlace.update(*this, vPlace, false); // XXX User other result container
|
|
}
|
|
else
|
|
it->tPlace.update(*this, 0, false);
|
|
}
|
|
}
|
|
|
|
void oEvent::calculateResults(const set<int> &classes, ResultType resultType, bool includePreliminary) const {
|
|
static bool resultCalculationLock = false;
|
|
|
|
if (resultCalculationLock) {
|
|
assert(resultType == ResultType::ClassResultDefault || resultType == ResultType::TotalResultDefault);
|
|
return;
|
|
}
|
|
|
|
if (resultType == ResultType::PreliminarySplitResults) {
|
|
computePreliminarySplitResults(classes);
|
|
return;
|
|
}
|
|
|
|
const bool defaultResult = resultType == ResultType::ClassResultDefault || resultType == ResultType::TotalResultDefault;
|
|
const bool standardResults = resultType == ResultType::ClassResult || resultType == ResultType::TotalResult;
|
|
|
|
const bool individualResults = resultType == ResultType::ClassResult;
|
|
const bool totalResults = resultType == ResultType::TotalResult || resultType == ResultType::TotalResultDefault;
|
|
const bool courseResults = resultType == ResultType::CourseResult;
|
|
const bool classCourseResults = resultType == ResultType::ClassCourseResult;
|
|
const bool specialResult = classCourseResults || courseResults;
|
|
|
|
bool all = classes.empty() || specialResult;
|
|
vector<pair<string, vector<oRunner *>>> runnersByResultModule;
|
|
set<int> clsWithResultModule;
|
|
map<int, int> classToResultModule;
|
|
set<int> rgClasses;
|
|
|
|
map<string, int> resultModuleToIndex;
|
|
for (auto &cls : Classes) {
|
|
if (!cls.isRemoved() && (all || classes.count(cls.getId()))) {
|
|
|
|
if (cls.isRogaining() && cls.getResultModuleTag().empty())
|
|
rgClasses.insert(cls.getId());
|
|
|
|
string t;
|
|
if (!defaultResult)
|
|
t = cls.getResultModuleTag();
|
|
|
|
if (!t.empty() && !specialResult) {
|
|
if (!resultModuleToIndex.count(t)) {
|
|
resultModuleToIndex[t] = runnersByResultModule.size();
|
|
pair<string, vector<oRunner *>> empty(t, {});
|
|
runnersByResultModule.emplace_back(empty);
|
|
}
|
|
classToResultModule[cls.getId()] = resultModuleToIndex[t];
|
|
}
|
|
else {
|
|
classToResultModule[cls.getId()] = -1;
|
|
|
|
if (!t.empty()) // For special resultr
|
|
clsWithResultModule.insert(cls.getId());
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<const oRunner *> runners;
|
|
{
|
|
vector<pRunner> runnersCls;
|
|
if (all)
|
|
getRunners({}, runnersCls);
|
|
else
|
|
getRunners(classes, runnersCls);
|
|
|
|
runners.reserve(runnersCls.size());
|
|
bool resOK = true;
|
|
|
|
for (auto it : runnersCls) {
|
|
oRunner &r = *it;
|
|
int cid = r.getClassId(true);
|
|
auto c = classToResultModule.find(cid);
|
|
if (c != classToResultModule.end() && c->second != -1) {
|
|
runnersByResultModule[c->second].second.push_back(&r);
|
|
}
|
|
runners.push_back(&r);
|
|
|
|
if (resOK) {
|
|
if (courseResults && r.tCoursePlace.isOld(*this))
|
|
resOK = false;
|
|
else if (classCourseResults && r.tCourseClassPlace.isOld(*this))
|
|
resOK = false;
|
|
else if (totalResults && r.tTotalPlace.isOld(*this))
|
|
resOK = false;
|
|
else if (r.tPlace.isOld(*this))
|
|
resOK = false;
|
|
}
|
|
}
|
|
|
|
if (resOK)
|
|
return;
|
|
}
|
|
// Reset computed status/time
|
|
|
|
bool useComputedResult = false;
|
|
if (specialResult && !clsWithResultModule.empty()) {
|
|
// Calculate standard results and setup computed time/status. This is for coursewise result etc.
|
|
calculateResults(clsWithResultModule, oEvent::ResultType::ClassResult, includePreliminary);
|
|
runnersByResultModule.clear();
|
|
useComputedResult = true;
|
|
}
|
|
else {
|
|
// Reset leader times
|
|
for (auto &cls : Classes) {
|
|
if (!cls.isRemoved() && (all || classes.count(cls.getId()))) {
|
|
for (unsigned leg = 0; leg < cls.getNumStages(); leg++)
|
|
cls.getLeaderInfo(oClass::AllowRecompute::No,leg).resetComputed(oClass::LeaderInfo::Type::Leg);
|
|
}
|
|
}
|
|
|
|
for (auto r : runners) {
|
|
r->tComputedPoints = -1;
|
|
r->tComputedTime = r->getRunningTime(false);
|
|
r->tComputedStatus = r->getStatus();
|
|
}
|
|
}
|
|
|
|
calculateRunnerResults(resultType, rgClasses, runners, useComputedResult, includePreliminary);
|
|
|
|
if (!runnersByResultModule.empty()) {
|
|
oEvent::ResultType otherType = totalResults ? oEvent::ResultType::ClassResult : oEvent::ResultType::TotalResult;
|
|
calculateRunnerResults(otherType, rgClasses, runners, false, includePreliminary);
|
|
|
|
resultCalculationLock = true;
|
|
try {
|
|
for (auto &resCalc : runnersByResultModule) {
|
|
wstring dmy;
|
|
auto &ge = oe->getGeneralResult(resCalc.first, dmy);
|
|
ge->calculateIndividualResults(resCalc.second, true, oListInfo::ResultType::Classwise, false, 0);
|
|
|
|
for (pRunner r : resCalc.second) {
|
|
r->updateComputedResultFromTemp();
|
|
r->tPlace.update(*oe, r->getTempResult().getPlace(), false);
|
|
if (r->tComputedStatus == StatusOK && r->tComputedTime>0) {
|
|
pClass cls = r->getClassRef(true);
|
|
cls->getLeaderInfo(oClass::AllowRecompute::No,
|
|
cls->mapLeg(r->getLegNumber())).updateComputed(r->tComputedTime, oClass::LeaderInfo::Type::Leg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (...) {
|
|
resultCalculationLock = false;
|
|
throw;
|
|
}
|
|
resultCalculationLock = false;
|
|
}
|
|
}
|
|
|
|
void oEvent::calculateRunnerResults(ResultType resultType,
|
|
const set<int> &rgClasses,
|
|
vector<const oRunner*> &runners,
|
|
bool useComputedResult,
|
|
bool includePreliminary) const {
|
|
|
|
const bool individualResults = resultType == ResultType::ClassResult;
|
|
const bool totalResults = resultType == ResultType::TotalResult || resultType == ResultType::TotalResultDefault;
|
|
const bool courseResults = resultType == ResultType::CourseResult;
|
|
const bool classCourseResults = resultType == ResultType::ClassCourseResult;
|
|
|
|
typedef ResultCalcData<const oRunner> DT;
|
|
vector<DT> resData;
|
|
resData.reserve(runners.size());
|
|
int groupId, score;
|
|
for (auto it : runners) {
|
|
int clsId = it->getClassId(true);
|
|
if (classCourseResults) {
|
|
const pCourse crs = it->getCourse(false);
|
|
groupId = it->getClassId(true) * 997 + (crs ? crs->getId() : 0);
|
|
}
|
|
else if (courseResults) {
|
|
const pCourse crs = it->getCourse(false);
|
|
groupId = crs ? crs->getId() : 0;
|
|
}
|
|
else {
|
|
groupId = clsId * 100 + (it->tDuplicateLeg + 10 * it->tLegEquClass);
|
|
}
|
|
|
|
if (rgClasses.count(clsId)) {
|
|
RunnerStatus st;
|
|
if (totalResults)
|
|
st = useComputedResult ? it->getStatusComputed() : it->getStatus();
|
|
else
|
|
st = it->getTotalStatus();
|
|
|
|
if (st == StatusOK)
|
|
score = numeric_limits<int>::max() - (3600 * 24 * 7 * max(1, 1 + it->getRogainingPoints(useComputedResult, totalResults)) - it->getRunningTime(false));
|
|
else
|
|
score = -1;
|
|
}
|
|
else if (!totalResults) {
|
|
RunnerStatus st = useComputedResult ? it->getStatusComputed() : it->getStatus();
|
|
if (st == StatusOK || (includePreliminary && st == StatusUnknown && it->FinishTime > 0))
|
|
score = it->getRunningTime(useComputedResult) + it->getNumShortening() * 3600 * 24 * 8;
|
|
else
|
|
score = -1;
|
|
}
|
|
else {
|
|
int tt = it->getTotalRunningTime(it->FinishTime, useComputedResult, true);
|
|
RunnerStatus totStat = it->getTotalStatus();
|
|
if (totStat == StatusOK || (includePreliminary && totStat == StatusUnknown && it->inputStatus == StatusOK) && tt > 0)
|
|
score = tt;
|
|
else
|
|
score = -1;
|
|
}
|
|
|
|
resData.emplace_back(groupId, score, it);
|
|
}
|
|
|
|
bool useStdResultCtr = resultType == ResultType::ClassResultDefault || resultType == ResultType::TotalResultDefault;
|
|
|
|
if (courseResults)
|
|
calculatePlace(resData, [this, useStdResultCtr](DT &res, int value) {res.dst->tCoursePlace.update(*this, value, useStdResultCtr); });
|
|
else if (classCourseResults)
|
|
calculatePlace(resData, [this, useStdResultCtr](DT &res, int value) {res.dst->tCourseClassPlace.update(*this, value, useStdResultCtr); });
|
|
else if (totalResults)
|
|
calculatePlace(resData, [this, useStdResultCtr](DT &res, int value) {res.dst->tTotalPlace.update(*this, value, useStdResultCtr); });
|
|
else
|
|
calculatePlace(resData, [this, useStdResultCtr](DT &res, int value) {res.dst->tPlace.update(*this, value, useStdResultCtr); });
|
|
}
|
|
|
|
bool oEvent::calculateTeamResults(vector<const oTeam*> &teams, int leg, ResultType resType) {
|
|
oTeamList::iterator it;
|
|
|
|
bool hasRunner;
|
|
if (resType == ResultType::TotalResult)
|
|
hasRunner = sortTeams(ClassTotalResult, leg, true, teams);
|
|
else
|
|
hasRunner = sortTeams(ClassDefaultResult, leg, true, teams);
|
|
|
|
if (!hasRunner)
|
|
return false;
|
|
|
|
int cClassId = 0;
|
|
int cPlace = 0;
|
|
int vPlace = 0;
|
|
int cTime = 0;
|
|
bool invalidClass = false;
|
|
oTeam::ComputedLegResult res;
|
|
|
|
for (auto it : teams) {
|
|
if (it->isRemoved())
|
|
continue;
|
|
|
|
if (it->Class && it->Class->Id != cClassId) {
|
|
cClassId = it->Class->Id;
|
|
cPlace = 0;
|
|
vPlace = 0;
|
|
cTime = 0;
|
|
invalidClass = it->Class->getClassStatus() != oClass::ClassStatus::Normal;
|
|
}
|
|
|
|
int sleg;
|
|
if (leg == -1)
|
|
sleg = it->Runners.size() - 1;
|
|
else
|
|
sleg = leg;
|
|
|
|
if (size_t(leg) >= it->Runners.size())
|
|
continue;
|
|
|
|
int p;
|
|
if (invalidClass) {
|
|
p = 0;
|
|
}
|
|
else if (it->_cachedStatus == StatusOK) {
|
|
cPlace++;
|
|
|
|
if (it->_sortTime > cTime)
|
|
vPlace = cPlace;
|
|
|
|
cTime = it->_sortTime;
|
|
|
|
p = vPlace;
|
|
}
|
|
else {
|
|
p = 0;
|
|
}
|
|
|
|
bool tmpDefaultResult = resType == ResultType::ClassResultDefault || resType == ResultType::TotalResultDefault;
|
|
if (resType == ResultType::TotalResult || resType == ResultType::TotalResultDefault) {
|
|
it->getTeamPlace(sleg).totalP.update(*this, p, tmpDefaultResult);
|
|
}
|
|
else {
|
|
it->getTeamPlace(sleg).p.update(*this, p, tmpDefaultResult);
|
|
res.version = tmpDefaultResult ? -1 : dataRevision;
|
|
res.status = it->_cachedStatus;
|
|
res.time = it->_sortTime;
|
|
it->setComputedResult(sleg, res);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void oEvent::calculateTeamResults(const set<int> &classSelection, ResultType resType) {
|
|
set<int> classSelectionC;
|
|
set<int> classSelectionM;
|
|
bool allC = resType == ResultType::ClassResultDefault || resType == ResultType::TotalResult;
|
|
bool totalResult = resType == ResultType::TotalResult;
|
|
if (classSelection.empty()) {
|
|
for (auto &c : Classes) {
|
|
if (!c.isRemoved()) {
|
|
if (allC || c.getResultModuleTag().empty())
|
|
classSelectionC.insert(c.getId());
|
|
else
|
|
classSelectionM.insert(c.getId());
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int id : classSelection) {
|
|
pClass c = getClass(id);
|
|
if (c) {
|
|
if (c->getResultModuleTag().empty())
|
|
classSelectionC.insert(id);
|
|
else
|
|
classSelectionM.insert(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<const oTeam *> teams;
|
|
vector<oTeam *> teamsMod;
|
|
bool resultOK = true;
|
|
teams.reserve(Teams.size());
|
|
for (auto &t : Teams) {
|
|
if (t.isRemoved())
|
|
continue;
|
|
|
|
if (classSelectionC.count(t.getClassId(true))) {
|
|
if (resultOK && !t.isResultUpdated(totalResult))
|
|
resultOK = false;
|
|
teams.push_back(&t);
|
|
}
|
|
else if (classSelectionM.count(t.getClassId(true))) {
|
|
if (resultOK && !t.isResultUpdated(totalResult))
|
|
resultOK = false;
|
|
teamsMod.push_back(&t);
|
|
}
|
|
}
|
|
|
|
if (resultOK)
|
|
return;
|
|
|
|
for (int i = 0; i < maxRunnersTeam; i++) {
|
|
if (!calculateTeamResults(teams, i, resType))
|
|
break;
|
|
}
|
|
|
|
if (!teamsMod.empty())
|
|
calculateModuleTeamResults(classSelectionM, teamsMod);
|
|
}
|
|
|
|
void oEvent::calculateTeamResults(const vector<pTeam> &teams, ResultType resultType) {
|
|
bool allC = resultType == ResultType::ClassResultDefault || resultType == ResultType::TotalResultDefault;
|
|
bool totalResult = resultType == ResultType::TotalResult || resultType == ResultType::TotalResultDefault;
|
|
|
|
set<int> cls, clsMod;
|
|
for (pTeam t : teams)
|
|
cls.insert(t->getClassId(true));
|
|
|
|
if (!allC) {
|
|
for (int id : cls) {
|
|
pClass c = getClass(id);
|
|
if (c) {
|
|
if (!c->getResultModuleTag().empty())
|
|
clsMod.insert(id);
|
|
}
|
|
}
|
|
}
|
|
vector<const oTeam *> teamsStd;
|
|
vector<oTeam *> teamsMod;
|
|
bool resultOK = true;
|
|
teamsStd.reserve(teams.size());
|
|
if (!clsMod.empty())
|
|
teamsMod.reserve(teams.size());
|
|
for (auto &t : teams) {
|
|
if (resultOK && !t->isResultUpdated(totalResult))
|
|
resultOK = false;
|
|
|
|
if (clsMod.count(t->getClassId(true)))
|
|
teamsMod.push_back(t);
|
|
else
|
|
teamsStd.push_back(t);
|
|
}
|
|
|
|
if (resultOK)
|
|
return;
|
|
|
|
for (int i = 0; i < maxRunnersTeam; i++) {
|
|
if (!calculateTeamResults(teamsStd, i, resultType))
|
|
break;
|
|
}
|
|
|
|
if (!teamsMod.empty())
|
|
calculateModuleTeamResults(clsMod, teamsMod);
|
|
}
|
|
|
|
void oEvent::calculateModuleTeamResults(const set<int> &cls, vector<oTeam *> &teams) {
|
|
map<int, string> cls2Mod;
|
|
set<int> rgClasses;
|
|
for (int id : cls) {
|
|
pClass c = getClass(id);
|
|
if (c->isRogaining())
|
|
rgClasses.insert(id);
|
|
for (unsigned leg = 0; leg < c->getNumStages(); leg++) {
|
|
c->getLeaderInfo(oClass::AllowRecompute::No, leg).resetComputed(oClass::LeaderInfo::Type::Total);
|
|
c->getLeaderInfo(oClass::AllowRecompute::No, leg).resetComputed(oClass::LeaderInfo::Type::TotalInput);
|
|
}
|
|
|
|
cls2Mod[c->Id] = c->getResultModuleTag();
|
|
}
|
|
map<string, vector<oTeam*>> teamByResultModule;
|
|
for (auto t : teams) {
|
|
teamByResultModule[cls2Mod[t->getClassId(true)]].push_back(t);
|
|
}
|
|
typedef ResultCalcData<const oTeam> DT;
|
|
typedef ResultCalcData<const oRunner> DR;
|
|
|
|
vector<DR> legResultsData;
|
|
legResultsData.reserve(Runners.size());
|
|
|
|
for (auto &resCalc : teamByResultModule) {
|
|
wstring dmy;
|
|
|
|
auto &ge = oe->getGeneralResult(resCalc.first, dmy);
|
|
ge->calculateTeamResults(resCalc.second, true, oListInfo::ResultType::Classwise, false, 0);
|
|
vector<DT> resData;
|
|
resData.reserve(resCalc.second.size());
|
|
|
|
for (pTeam t : resCalc.second) {
|
|
pClass teamClass = t->getClassRef(true);
|
|
|
|
t->tComputedTime = t->getTempResult().getRunningTime();
|
|
t->tComputedPoints = t->getTempResult().getPoints();
|
|
t->tComputedStatus = t->getTempResult().getStatus();
|
|
bool ok = true;
|
|
int timeAcc = 0, timePar = 0;
|
|
|
|
int totScore = -1;
|
|
int clsId = t->getClassId(true);
|
|
if (t->tComputedStatus == StatusOK && t->inputStatus == StatusOK) {
|
|
if (rgClasses.count(clsId))
|
|
totScore = numeric_limits<int>::max() - (7 * 24 * 3600 * max(1, (1 + t->getRogainingPoints(true, true))) - (t->tComputedTime + t->inputTime));
|
|
else
|
|
totScore = t->tComputedTime + t->inputTime;
|
|
}
|
|
|
|
resData.emplace_back(clsId, totScore, t);
|
|
|
|
for (int i = 0; i < t->getNumRunners(); i++) {
|
|
t->getTeamPlace(i).p.update(*this, t->getTempResult().getPlace(), false);
|
|
t->getTeamPlace(i).totalP.update(*this, t->getTempResult().getPlace(), false);
|
|
oTeam::ComputedLegResult res;
|
|
res.version = dataRevision;
|
|
int legTime = 0;
|
|
bool lastLeg = i + 1 == t->getNumRunners();
|
|
|
|
if (t->Runners[i]) {
|
|
res.status = t->Runners[i]->getTempResult().getStatus();
|
|
res.time = t->Runners[i]->getTempResult().getRunningTime();
|
|
legTime = res.time;
|
|
|
|
auto lt = teamClass->getLegType(i);
|
|
if (res.status == StatusOK) {
|
|
if (lt == LTParallel || lt == LTParallelOptional)
|
|
timePar = max(timePar, res.time);
|
|
else if (lt != LTIgnore && lt != LTExtra)
|
|
timePar = res.time;
|
|
|
|
teamClass->getLeaderInfo(oClass::AllowRecompute::No, i).updateComputed(res.time, oClass::LeaderInfo::Type::Leg);
|
|
}
|
|
else {
|
|
ok = false;
|
|
}
|
|
|
|
if (ok || (lastLeg && t->tComputedStatus == StatusOK)) {
|
|
if (lastLeg)
|
|
legTime = t->tComputedTime;
|
|
else
|
|
legTime = timeAcc + timePar;
|
|
teamClass->getLeaderInfo(oClass::AllowRecompute::No, i).updateComputed(legTime, oClass::LeaderInfo::Type::Total);
|
|
teamClass->getLeaderInfo(oClass::AllowRecompute::No, i).updateComputed(t->getInputTime() + legTime, oClass::LeaderInfo::Type::TotalInput);
|
|
}
|
|
|
|
auto ltNext = teamClass->getLegType(i + 1);
|
|
if (ltNext == LTNormal || ltNext == LTSum)
|
|
timeAcc += timePar;
|
|
|
|
timePar = 0;
|
|
|
|
t->Runners[i]->tComputedTime = res.time;
|
|
t->Runners[i]->tComputedStatus = res.status;
|
|
t->Runners[i]->tComputedPoints = t->Runners[i]->getTempResult().getPoints();
|
|
|
|
int legScore = -1;
|
|
if (res.status == StatusOK) {
|
|
if (rgClasses.count(clsId))
|
|
legScore = numeric_limits<int>::max() - (7 * 24 * 3600 * max(1, (1 + t->Runners[i]->tComputedPoints)) - res.time);
|
|
else
|
|
legScore = res.time;
|
|
}
|
|
|
|
pClass rCls = t->Runners[i]->getClassRef(true);
|
|
int leg = rCls->mapLeg(i);
|
|
legResultsData.emplace_back(rCls->getId() * 256 + leg, legScore, t->Runners[i]);
|
|
}
|
|
else {
|
|
if (!teamClass->isOptional(i))
|
|
ok = false;
|
|
}
|
|
if (t->tComputedStatus == StatusOK ||
|
|
t->tComputedStatus == StatusOutOfCompetition ||
|
|
t->tComputedStatus == StatusNoTiming)
|
|
res.time = legTime;
|
|
|
|
if (lastLeg) {
|
|
res.time = t->tComputedTime;
|
|
res.status = t->tComputedStatus;
|
|
}
|
|
|
|
t->setComputedResult(i, res);
|
|
}
|
|
}
|
|
|
|
calculatePlace(legResultsData, [this](DR &res, int value) {
|
|
res.dst->tPlace.update(*this, value, false);
|
|
res.dst->tTotalPlace.update(*this, value, false); });
|
|
|
|
// Calculate and store total result
|
|
calculatePlace(resData, [this](DT &res, int value) {
|
|
for (int i = 0; i < res.dst->getNumRunners(); i++) {
|
|
res.dst->getTeamPlace(i).totalP.update(*this, value, false);
|
|
}});
|
|
}
|
|
}
|
|
|
|
const shared_ptr<GeneralResult> &oEvent::getGeneralResult(const string &tag, wstring &sourceFileOut) const {
|
|
for (int i = 0; i < 2; i++) {
|
|
if (i>0)
|
|
loadGeneralResults(false, true);
|
|
for (size_t k = 0; k < generalResults.size(); k++) {
|
|
if (tag == generalResults[k].tag) {
|
|
if (generalResults[k].ptr == 0)
|
|
throw meosException("Internal error");
|
|
sourceFileOut = generalResults[k].fileSource;
|
|
if (sourceFileOut == L"*")
|
|
sourceFileOut = L"";
|
|
|
|
return generalResults[k].ptr;
|
|
}
|
|
}
|
|
}
|
|
throw meosException("There is no result module with X as identifier.#" + tag);
|
|
}
|
|
|
|
void oEvent::loadGeneralResults(bool forceReload, bool loadFromDisc) const {
|
|
// OutputDebugString("Load General Results\n");
|
|
wchar_t bf[260];
|
|
getUserFile(bf, L"");
|
|
vector<wstring> res;
|
|
expandDirectory(bf, L"*.rules", res);
|
|
vector<wstring> res2;
|
|
expandDirectory(bf, L"*.brules", res2);
|
|
|
|
DynamicResult dr;
|
|
pair<wstring, wstring> err;
|
|
|
|
vector<GeneralResultCtr> newGeneralResults;
|
|
set<wstring> loaded;
|
|
map<string, int> tags;
|
|
set<long long> loadedRes;
|
|
if (forceReload) {
|
|
// Keep only built-in (non-dynamic) result modules
|
|
for (size_t k = 0; k < generalResults.size(); k++) {
|
|
if (!generalResults[k].isDynamic())
|
|
newGeneralResults.push_back(generalResults[k]);
|
|
}
|
|
generalResults.clear();
|
|
}
|
|
else {
|
|
// Mark all already loaded results as loaded
|
|
for (size_t k = 0; k < generalResults.size(); k++) {
|
|
if (generalResults[k].isDynamic()) {
|
|
loaded.insert(generalResults[k].fileSource);
|
|
tags.emplace(generalResults[k].tag, k);
|
|
loadedRes.insert(dynamic_cast<DynamicResult &>(*generalResults[k].ptr).getHashCode());
|
|
}
|
|
}
|
|
swap(generalResults, newGeneralResults);
|
|
}
|
|
|
|
vector<DynamicResultRef> rmAll;
|
|
getListContainer().getGeneralResults(rmAll);
|
|
|
|
// Get the open list from list editor
|
|
TabList &tl = dynamic_cast<TabList &>(*gdibase.getTabs().get(TListTab));
|
|
ListEditor *le = tl.getListEditorPtr();
|
|
if (le) {
|
|
MetaList *editorList = le->getCurrentList();
|
|
if (editorList) {
|
|
vector<DynamicResultRef> rm;
|
|
editorList->getDynamicResults(rm);
|
|
rmAll.insert(rmAll.end(), rm.begin(), rm.end());
|
|
}
|
|
}
|
|
|
|
for (size_t ii = 1; ii <= rmAll.size(); ii++) {
|
|
size_t i = rmAll.size() - ii;
|
|
if (!rmAll[i].res)
|
|
continue;
|
|
long long hash = rmAll[i].res->getHashCode();
|
|
string newTag = rmAll[i].res->getTag();
|
|
|
|
//string db = "Load result " + newTag + ", h=" + itos(hash) + "\n";
|
|
//OutputDebugStringA(db.c_str());
|
|
int setIx = -1;
|
|
if (tags.count(newTag)) {
|
|
int ix = tags[newTag];
|
|
|
|
if (loadedRes.count(hash) || newGeneralResults[ix].isImplicit())
|
|
setIx = ix; // Already loaded
|
|
|
|
if (setIx == -1) {
|
|
|
|
if (!rmAll[i].res->retaggable()) {
|
|
//assert(newTag == rmAll.back().res->getTag());
|
|
assert(newGeneralResults[ix].tag == newTag);
|
|
int n = 1;
|
|
string baseTag = newTag = DynamicResult::undecorateTag(newTag);
|
|
while (tags.count(newTag)) {
|
|
newTag = baseTag + "-v" + itos(++n);
|
|
}
|
|
if (newGeneralResults[ix].isDynamic()) {
|
|
tags[newTag] = ix;
|
|
newGeneralResults[ix].tag = newTag;
|
|
}
|
|
}
|
|
else {
|
|
int n = 1;
|
|
string baseTag = newTag = DynamicResult::undecorateTag(newTag);
|
|
while (tags.count(newTag)) {
|
|
newTag = baseTag + "-v" + itos(++n);
|
|
}
|
|
|
|
string db = "Retag " + newTag + "\n";
|
|
OutputDebugStringA(db.c_str());
|
|
|
|
if (rmAll[i].ctr)
|
|
rmAll[i].ctr->retagResultModule(newTag, true);
|
|
}
|
|
}
|
|
}
|
|
auto &drp = rmAll[i].res;
|
|
drp->setAnnotation(rmAll[i].getAnnotation());
|
|
|
|
if (setIx == -1) {
|
|
tags.emplace(drp->getTag(), newGeneralResults.size());
|
|
newGeneralResults.emplace_back(wstring(L"*"), drp);
|
|
}
|
|
else {
|
|
newGeneralResults[setIx] = GeneralResultCtr(wstring(L"*"), drp);
|
|
}
|
|
}
|
|
|
|
if (loadFromDisc) {
|
|
size_t builtIn = res2.size();
|
|
for (size_t k = 0; k < res.size(); k++)
|
|
res2.push_back(res[k]);
|
|
|
|
for (size_t k = 0; k < res2.size(); k++) {
|
|
try {
|
|
if (loaded.count(res2[k]))
|
|
continue;
|
|
|
|
dr.load(res2[k]);
|
|
string tag = DynamicResult::undecorateTag(dr.getTag());
|
|
int iter = 1;
|
|
while (tags.count(tag))
|
|
tag = dr.getTag() + + "_v" + itos(++iter);
|
|
if (iter > 1)
|
|
dr.setTag(tag);
|
|
|
|
auto drp = make_shared<DynamicResult>(dr);
|
|
if (loadedRes.count(drp->getHashCode()))
|
|
continue;
|
|
|
|
tags.emplace(dr.getTag(), newGeneralResults.size());
|
|
if (k < builtIn)
|
|
drp->setBuiltIn();
|
|
|
|
loadedRes.insert(drp->getHashCode());
|
|
newGeneralResults.push_back(GeneralResultCtr(res2[k], drp));
|
|
}
|
|
catch (meosException &ex) {
|
|
if (err.first.empty()) {
|
|
err.first = res2[k];
|
|
err.second = ex.wwhat();
|
|
}
|
|
}
|
|
catch (std::exception &ex) {
|
|
if (err.first.empty()) {
|
|
err.first = res2[k];
|
|
err.second = gdibase.widen(ex.what());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
swap(newGeneralResults, generalResults);
|
|
size_t ndIx;
|
|
for (ndIx = 0; ndIx < generalResults.size(); ndIx++) {
|
|
if (generalResults[ndIx].isDynamic())
|
|
break;
|
|
}
|
|
sort(generalResults.begin() + ndIx, generalResults.end());
|
|
if (!err.first.empty())
|
|
throw meosException(L"Error loading X (Y)#" + err.first + L"#" + err.second);
|
|
}
|
|
|
|
void oEvent::setGeneralResultContext(const oListParam *ctx) {
|
|
for (auto &gr : generalResults) {
|
|
if (ctx)
|
|
gr.ptr->setContext(ctx);
|
|
else
|
|
gr.ptr->clearContext();
|
|
}
|
|
}
|
|
|
|
|
|
void oEvent::getGeneralResults(bool onlyEditable, vector< pair<int, pair<string, wstring> > > &tagNameList, bool includeDate) const {
|
|
tagNameList.clear();
|
|
map<wstring, int> count;
|
|
map<pair<wstring, string>, int> countDate;
|
|
for (size_t k = 0; k < generalResults.size(); k++) {
|
|
string date = generalResults[k].ptr->getTimeStamp().substr(0,10);
|
|
++count[generalResults[k].name];
|
|
++countDate[make_pair(generalResults[k].name, date)];
|
|
}
|
|
|
|
for (size_t k = 0; k < generalResults.size(); k++) {
|
|
if (!onlyEditable || generalResults[k].isDynamic()) {
|
|
tagNameList.push_back(make_pair(100 + k, make_pair(generalResults[k].tag, lang.tl(generalResults[k].name))));
|
|
if (count[generalResults[k].name] > 1) {
|
|
size_t res = generalResults[k].tag.find_last_of('v');
|
|
if (res != string::npos) {
|
|
string version = generalResults[k].tag.substr(res);
|
|
tagNameList.back().second.second += L", " + gdioutput::widen(version);
|
|
}
|
|
if (includeDate) {
|
|
const string &datetime = generalResults[k].ptr->getTimeStamp();
|
|
if (!datetime.empty()) {
|
|
string date = datetime.substr(0, 10);
|
|
if (countDate[make_pair(generalResults[k].name, date)] > 1) {
|
|
tagNameList.back().second.second += L", " + gdioutput::widen(datetime);
|
|
}
|
|
else {
|
|
tagNameList.back().second.second += L", " + gdioutput::widen(date);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct TeamResultContainer {
|
|
pTeam team;
|
|
int runningTime;
|
|
RunnerStatus status;
|
|
|
|
bool operator<(const TeamResultContainer &o) const {
|
|
|
|
pClass cls = team->getClassRef(false);
|
|
pClass ocls = o.team->getClassRef(false);
|
|
|
|
if (cls != ocls) {
|
|
int so = cls ? cls->getSortIndex() : 0;
|
|
int oso = ocls ? ocls->getSortIndex() : 0;
|
|
if (so != oso)
|
|
return so < oso;
|
|
}
|
|
|
|
if (status != o.status)
|
|
return status < o.status;
|
|
|
|
if (runningTime != o.runningTime)
|
|
return runningTime < o.runningTime;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
void oEvent::calculateTeamResultAtControl(const set<int> &classId, int leg, int courseControlId, bool totalResults) {
|
|
vector<TeamResultContainer> objs;
|
|
objs.reserve(Teams.size());
|
|
oSpeakerObject temp;
|
|
for (auto &t : Teams) {
|
|
if (t.isRemoved())
|
|
continue;
|
|
|
|
if (!classId.empty() && !classId.count(t.getClassId(false)))
|
|
continue;
|
|
temp.reset();
|
|
t.fillSpeakerObject(leg, courseControlId, -1, totalResults, temp);
|
|
if (!temp.owner)
|
|
continue;
|
|
TeamResultContainer trc;
|
|
trc.runningTime = temp.runningTime.time;
|
|
trc.status = temp.status;
|
|
trc.team = &t;
|
|
objs.push_back(trc);
|
|
}
|
|
|
|
sort(objs.begin(), objs.end());
|
|
|
|
int cClass = -1;
|
|
int cPlace = -1;
|
|
int placeCounter = -1;
|
|
int cTime = 0;
|
|
for (size_t i = 0; i < objs.size(); i++) {
|
|
pTeam team = objs[i].team;
|
|
int c = team->getClassId(false);
|
|
if (c != cClass) {
|
|
cClass = c;
|
|
placeCounter = 1;
|
|
cTime = -1;
|
|
}
|
|
else {
|
|
placeCounter++;
|
|
}
|
|
|
|
if (cTime != objs[i].runningTime) {
|
|
cPlace = placeCounter;
|
|
}
|
|
|
|
team->tmpResult.startTime = team->getStartTime();
|
|
team->tmpResult.status = objs[i].status;
|
|
team->tmpResult.runningTime = objs[i].runningTime;
|
|
team->tmpResult.place = objs[i].status == StatusOK ? cPlace : 0;
|
|
team->tmpResult.points = 0; // Not supported
|
|
}
|
|
}
|
|
|
|
void oEvent::computePreliminarySplitResults(const set<int> &classes) const {
|
|
bool allClasses = classes.empty();
|
|
map<pair<int, int>, vector<const oRunner *>> runnerByClassLeg;
|
|
for (auto &r : Runners) {
|
|
r.tOnCourseResults.clear();
|
|
r.currentControlTime.first = 1;
|
|
r.currentControlTime.second = 100000;
|
|
|
|
if (r.isRemoved() || r.getClassId(false) == 0)
|
|
continue;
|
|
int cls = r.getClassId(true);
|
|
if (!allClasses && classes.count(cls) == 0)
|
|
continue;
|
|
int leg = r.getLegNumber();
|
|
if (r.getClassRef(false)->getQualificationFinal())
|
|
leg = 0;
|
|
|
|
r.setupRunnerStatistics();
|
|
runnerByClassLeg[make_pair(cls, leg)].push_back(&r);
|
|
}
|
|
|
|
map<pair<int, int>, int> courseCCid2CourseIx;
|
|
for (auto &c : Courses) {
|
|
if (c.isRemoved())
|
|
continue;
|
|
for (int ix = 0; ix < c.getNumControls(); ix++) {
|
|
int ccid = c.getCourseControlId(ix);
|
|
courseCCid2CourseIx[make_pair(c.getId(), ccid)] = ix;
|
|
}
|
|
courseCCid2CourseIx[make_pair(c.getId(), oPunch::PunchFinish)] = c.getNumControls();
|
|
}
|
|
|
|
map<pair<int, int>, set<int>> classLeg2ExistingCCId;
|
|
for (auto &p : punches) {
|
|
if (p.isRemoved() || p.isHiredCard())
|
|
continue;
|
|
pRunner r = p.getTiedRunner();
|
|
if (!r)
|
|
continue;
|
|
if (!p.isCheck() && r->getCourse(false) == nullptr)
|
|
r->tOnCourseResults.hasAnyRes = true; // Register all punches for runners without course
|
|
|
|
pClass cls = r->getClassRef(false);
|
|
if (r->getCourse(false) && cls) {
|
|
int ccId = p.getCourseControlId();
|
|
if (ccId <= 0)
|
|
continue;
|
|
int crs = r->getCourse(false)->getId();
|
|
int time = p.getTimeInt() - r->getStartTime(); //XXX Team time
|
|
r->tOnCourseResults.emplace_back(ccId, courseCCid2CourseIx[make_pair(crs, ccId)], time);
|
|
int clsId = r->getClassId(true);
|
|
int leg = r->getLegNumber();
|
|
if (cls->getQualificationFinal())
|
|
leg = 0;
|
|
|
|
classLeg2ExistingCCId[make_pair(clsId, leg)].insert(ccId);
|
|
}
|
|
}
|
|
// Add missing punches from card
|
|
for (auto &r : Runners) {
|
|
if (r.isRemoved() || !r.Card || r.getClassId(false) == 0)
|
|
continue;
|
|
int clsId = r.getClassId(true);
|
|
int leg = r.getLegNumber();
|
|
if (r.getClassRef(false)->getQualificationFinal())
|
|
leg = 0;
|
|
|
|
const set<int> &expectedCCid = classLeg2ExistingCCId[make_pair(clsId, leg)];
|
|
size_t nRT = 0;
|
|
for (auto &radioTimes : r.tOnCourseResults.res) {
|
|
if (expectedCCid.count(radioTimes.courseControlId))
|
|
nRT++;
|
|
}
|
|
|
|
if (nRT < expectedCCid.size()) {
|
|
pCourse crs = r.getCourse(true);
|
|
for (auto &p : r.Card->punches) {
|
|
if (p.tIndex >= 0 && p.tIndex < crs->getNumControls()) {
|
|
int ccId = crs->getCourseControlId(p.tIndex);
|
|
if (expectedCCid.count(ccId)) {
|
|
bool added = false;
|
|
for (auto &stored : r.tOnCourseResults.res) {
|
|
if (stored.courseControlId == ccId) {
|
|
added = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!added) {
|
|
int time = p.getTimeInt() - r.getStartTime(); //XXX Team time
|
|
r.tOnCourseResults.emplace_back(ccId, p.tIndex, time);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<tuple<int, int, int>> timeRunnerIx;
|
|
for (auto rList : runnerByClassLeg) {
|
|
auto &rr = rList.second;
|
|
pClass cls = getClass(rList.first.first);
|
|
assert(cls);
|
|
bool totRes = cls->getNumStages() > 1;
|
|
|
|
set<int> &legCCId = classLeg2ExistingCCId[rList.first];
|
|
legCCId.insert(oPunch::PunchFinish);
|
|
for (const int ccId : legCCId) {
|
|
// Leg with negative sign
|
|
int negLeg = 0;
|
|
timeRunnerIx.clear();
|
|
int nRun = rr.size();
|
|
if (ccId == oPunch::PunchFinish) {
|
|
negLeg = -1000; //Finish, smallest number
|
|
for (int j = 0; j < nRun; j++) {
|
|
auto r = rr[j];
|
|
if (r->prelStatusOK(true, false)) {
|
|
int time;
|
|
if (!r->tInTeam || !totRes)
|
|
time = r->getRunningTime(true);
|
|
else {
|
|
time = r->tInTeam->getLegRunningTime(r->tLeg, true, false);
|
|
}
|
|
int ix = -1;
|
|
int nr = r->tOnCourseResults.res.size();
|
|
for (int i = 0; i < nr; i++) {
|
|
if (r->tOnCourseResults.res[i].courseControlId == ccId) {
|
|
ix = i;
|
|
break;
|
|
}
|
|
}
|
|
if (ix == -1) {
|
|
ix = r->tOnCourseResults.res.size();
|
|
int nc = 0;
|
|
pCourse crs = r->getCourse(false);
|
|
if (crs)
|
|
nc = crs->getNumControls();
|
|
r->tOnCourseResults.emplace_back(ccId, nc, time);
|
|
}
|
|
timeRunnerIx.emplace_back(time, j, ix);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int j = 0; j < nRun; j++) {
|
|
auto r = rr[j];
|
|
int nr = r->tOnCourseResults.res.size();
|
|
for (int i = 0; i < nr; i++) {
|
|
if (r->tOnCourseResults.res[i].courseControlId == ccId) {
|
|
timeRunnerIx.emplace_back(r->tOnCourseResults.res[i].time, j, i);
|
|
negLeg = min(negLeg, -r->tOnCourseResults.res[i].controlIx);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sort(timeRunnerIx.begin(), timeRunnerIx.end());
|
|
|
|
int place = 0;
|
|
int time = 0;
|
|
int leadTime = 0;
|
|
int numPlace = timeRunnerIx.size();
|
|
for (int i = 0; i < numPlace; i++) {
|
|
int ct = get<0>(timeRunnerIx[i]);
|
|
if (time != ct) {
|
|
time = ct;
|
|
place = i + 1;
|
|
if (leadTime == 0)
|
|
leadTime = time;
|
|
}
|
|
auto r = rr[get<1>(timeRunnerIx[i])];
|
|
int locIx = get<2>(timeRunnerIx[i]);
|
|
r->tOnCourseResults.res[locIx].place = place;
|
|
r->tOnCourseResults.res[locIx].after = time - leadTime;
|
|
|
|
int &legWithTimeIndexNeg = r->currentControlTime.first;
|
|
if (negLeg < legWithTimeIndexNeg) {
|
|
legWithTimeIndexNeg = negLeg;
|
|
r->currentControlTime.second = ct;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|