swift
modelcaches.cpp
1 // SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
2 // SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
3 
4 #include "misc/simulation/data/modelcaches.h"
5 
6 #include <QtGlobal>
7 
8 #include "misc/cachesettingsutils.h"
9 #include "misc/logmessage.h"
10 #include "misc/verify.h"
11 
12 using namespace swift::misc;
13 
14 namespace swift::misc::simulation::data
15 {
16  void IMultiSimulatorModelCaches::setModelsForSimulator(const CAircraftModelList &models,
17  const CSimulatorInfo &simulator)
18  {
19  this->setCachedModels(models, simulator);
20  }
21 
22  int IMultiSimulatorModelCaches::updateModelsForSimulator(const CAircraftModelList &models,
23  const CSimulatorInfo &simulator)
24  {
25  if (models.isEmpty()) { return 0; }
26  CAircraftModelList allModels(this->getSynchronizedCachedModels(simulator));
27  const int c = allModels.replaceOrAddModelsWithString(models, Qt::CaseInsensitive);
28  if (c < 1) { return 0; }
29  this->setCachedModels(allModels, simulator);
30  return allModels.size();
31  }
32 
33  QString IMultiSimulatorModelCaches::getInfoString() const
34  {
35  static const QString is("FSX: %1 P3D: %2 FS9: %3 XP: %4 FG: %5");
36  return is.arg(this->getCachedModelsCount(CSimulatorInfo::FSX))
37  .arg(this->getCachedModelsCount(CSimulatorInfo::P3D))
38  .arg(this->getCachedModelsCount(CSimulatorInfo::FS9))
39  .arg(this->getCachedModelsCount(CSimulatorInfo::XPLANE))
40  .arg(this->getCachedModelsCount(CSimulatorInfo::FG));
41  }
42 
43  QString IMultiSimulatorModelCaches::getInfoStringFsFamily() const
44  {
45  static const QString is("FSX: %1, P3D: %2, FS9: %3, MSFS: %4, MSFS2024: %5");
46  return is.arg(this->getCachedModelsCount(CSimulatorInfo::FSX))
47  .arg(this->getCachedModelsCount(CSimulatorInfo::P3D))
48  .arg(this->getCachedModelsCount(CSimulatorInfo::FS9))
49  .arg(this->getCachedModelsCount(CSimulatorInfo::MSFS))
50  .arg(this->getCachedModelsCount(CSimulatorInfo::MSFS2024));
51  }
52 
53  QString IMultiSimulatorModelCaches::getCacheCountAndTimestamp(const CSimulatorInfo &simulator) const
54  {
55  static const QString s("%1 models, ts: %2");
56  return s.arg(this->getCachedModelsCount(simulator))
57  .arg(this->getCacheTimestamp(simulator).toString("yyyy-MM-dd HH:mm:ss"));
58  }
59 
60  void IMultiSimulatorModelCaches::gracefulShutdown()
61  {
62  // void
63  }
64 
65  void IMultiSimulatorModelCaches::markCacheAsAlreadySynchronized(const CSimulatorInfo &simulator, bool synchronized)
66  {
67  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
68  switch (simulator.getSimulator())
69  {
70  case CSimulatorInfo::FS9: m_syncFS9 = synchronized; break;
71  case CSimulatorInfo::FSX: m_syncFsx = synchronized; break;
72  case CSimulatorInfo::P3D: m_syncP3D = synchronized; break;
73  case CSimulatorInfo::XPLANE: m_syncXPlane = synchronized; break;
74  case CSimulatorInfo::FG: m_syncFG = synchronized; break;
75  case CSimulatorInfo::MSFS: m_syncMsfs = synchronized; break;
76  case CSimulatorInfo::MSFS2024: m_syncMsfs2024 = synchronized; break;
77  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
78  }
79  }
80 
81  void IMultiSimulatorModelCaches::emitCacheChanged(const CSimulatorInfo &simulator)
82  {
83  emit this->cacheChanged(simulator);
84  }
85 
86  int IMultiSimulatorModelCaches::getCachedModelsCount(const CSimulatorInfo &simulator) const
87  {
88  return this->getCachedModels(simulator).size();
89  }
90 
91  bool IMultiSimulatorModelCaches::hasOtherVersionFile(const CApplicationInfo &info,
92  const CSimulatorInfo &simulator) const
93  {
94  const QString fn = this->getFilename(simulator);
95  return CCacheSettingsUtils::hasOtherVersionCacheFile(info, fn);
96  }
97 
98  CSimulatorInfo IMultiSimulatorModelCaches::otherVersionSimulatorsWithFile(const CApplicationInfo &info) const
99  {
100  CSimulatorInfo sim(CSimulatorInfo::None);
101  if (this->hasOtherVersionFile(info, CSimulatorInfo::fsx())) { sim.addSimulator(CSimulatorInfo::fsx()); }
102  if (this->hasOtherVersionFile(info, CSimulatorInfo::p3d())) { sim.addSimulator(CSimulatorInfo::p3d()); }
103  if (this->hasOtherVersionFile(info, CSimulatorInfo::fs9())) { sim.addSimulator(CSimulatorInfo::fs9()); }
104  if (this->hasOtherVersionFile(info, CSimulatorInfo::fg())) { sim.addSimulator(CSimulatorInfo::fg()); }
105  if (this->hasOtherVersionFile(info, CSimulatorInfo::xplane())) { sim.addSimulator(CSimulatorInfo::xplane()); }
106  if (this->hasOtherVersionFile(info, CSimulatorInfo::msfs())) { sim.addSimulator(CSimulatorInfo::msfs()); }
107  if (this->hasOtherVersionFile(info, CSimulatorInfo::msfs2024()))
108  {
109  sim.addSimulator(CSimulatorInfo::msfs2024());
110  }
111  return sim;
112  }
113 
114  QStringList IMultiSimulatorModelCaches::getAllFilenames() const
115  {
116  return QStringList({
117  this->getFilename(CSimulatorInfo::FS9),
118  this->getFilename(CSimulatorInfo::FSX),
119  this->getFilename(CSimulatorInfo::P3D),
120  this->getFilename(CSimulatorInfo::XPLANE),
121  this->getFilename(CSimulatorInfo::FG),
122  this->getFilename(CSimulatorInfo::MSFS),
123  this->getFilename(CSimulatorInfo::MSFS2024),
124  });
125  }
126 
127  CSimulatorInfo IMultiSimulatorModelCaches::getSimulatorForFilename(const QString &filename) const
128  {
129  if (filename.isEmpty()) { return {}; }
130  CSimulatorInfo sims;
131  const QString compareFileName(QFileInfo(filename).fileName());
132  for (const CSimulatorInfo &singleSim : CSimulatorInfo::allSimulatorsSet())
133  {
134  const QString singleSimFile(getFilename(singleSim));
135  if (singleSimFile.isEmpty()) continue;
136  const QString singleSimFileName(QFileInfo(singleSimFile).fileName());
137  if (singleSimFileName == compareFileName)
138  {
139  sims.add(singleSim);
140  break;
141  }
142  }
143  return sims;
144  }
145 
146  CAircraftModelList IMultiSimulatorModelCaches::getSynchronizedCachedModels(const CSimulatorInfo &simulator)
147  {
148  SWIFT_VERIFY_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "need single simulator");
149  this->synchronizeCache(simulator);
150  return this->getCachedModels(simulator);
151  }
152 
153  QDateTime IMultiSimulatorModelCaches::getSynchronizedTimestamp(const CSimulatorInfo &simulator)
154  {
155  SWIFT_VERIFY_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "need single simulator");
156  this->synchronizeCache(simulator);
157  return this->getCacheTimestamp(simulator);
158  }
159 
160  CSimulatorInfo IMultiSimulatorModelCaches::simulatorsWithInitializedCache() const
161  {
162  static const QDateTime outdated = QDateTime::currentDateTimeUtc().addDays(-365 * 5);
163  CSimulatorInfo withInitializedCache;
164  for (const CSimulatorInfo &simInfo : CSimulatorInfo::allSimulators().asSingleSimulatorSet())
165  {
166  const QDateTime ts = this->getCacheTimestamp(simInfo);
167  if (ts.isValid() && ts > outdated) { withInitializedCache.add(simInfo); }
168  }
169  return withInitializedCache;
170  }
171 
172  CSimulatorInfo IMultiSimulatorModelCaches::simulatorsWithModels() const
173  {
174  CSimulatorInfo withModels;
175  for (const CSimulatorInfo &simInfo : CSimulatorInfo::allSimulators().asSingleSimulatorSet())
176  {
177  if (this->getCachedModelsCount(simInfo) > 0) { withModels.add(simInfo); }
178  }
179  return withModels;
180  }
181 
182  CModelCaches::CModelCaches(bool synchronizeCache, QObject *parent) : IMultiSimulatorModelCaches(parent)
183  {
184  const CSimulatorInfo sim = swift::misc::simulation::CSimulatorInfo::guessDefaultSimulator();
185  const QString simStr(sim.toQString(true));
186  if (synchronizeCache)
187  {
188  this->synchronizeCacheImpl(sim);
189  CLogMessage(this).info(u"Initialized model caches (%1) for %2") << this->getDescription() << simStr;
190  }
191  else
192  {
193  if (this->admitCacheImpl(sim))
194  {
195  CLogMessage(this).info(u"Admit model (%1) caches for %2") << this->getDescription() << simStr;
196  }
197  }
198  }
199 
200  const QStringList &CModelCaches::getLogCategories()
201  {
202  static const QStringList l({ CLogCategories::modelCache() });
203  return l;
204  }
205 
206  CAircraftModelList CModelCaches::getCachedModels(const CSimulatorInfo &simulator) const
207  {
208  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
209  switch (simulator.getSimulator())
210  {
211  case CSimulatorInfo::FS9: return m_modelCacheFs9.get();
212  case CSimulatorInfo::FSX: return m_modelCacheFsx.get();
213  case CSimulatorInfo::P3D: return m_modelCacheP3D.get();
214  case CSimulatorInfo::XPLANE: return m_modelCacheXP.get();
215  case CSimulatorInfo::FG: return m_modelCacheFG.get();
216  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.get();
217  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.get();
218  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); return CAircraftModelList();
219  }
220  }
221 
222  CStatusMessage CModelCaches::setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
223  {
224  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
225  CStatusMessage msg;
226  CAircraftModelList setModels(models);
227  setModels.setModelType(CAircraftModel::TypeOwnSimulatorModel); // unify type
228 
229  switch (simulator.getSimulator())
230  {
231  case CSimulatorInfo::FS9: msg = m_modelCacheFs9.set(setModels); break;
232  case CSimulatorInfo::FSX: msg = m_modelCacheFsx.set(setModels); break;
233  case CSimulatorInfo::P3D: msg = m_modelCacheP3D.set(setModels); break;
234  case CSimulatorInfo::XPLANE: msg = m_modelCacheXP.set(setModels); break;
235  case CSimulatorInfo::FG: msg = m_modelCacheFG.set(setModels); break;
236  case CSimulatorInfo::MSFS: msg = m_modelCacheMsfs.set(setModels); break;
237  case CSimulatorInfo::MSFS2024: msg = m_modelCacheMsfs2024.set(setModels); break;
238  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); return CStatusMessage();
239  }
240  this->emitCacheChanged(simulator); // set
241  return msg;
242  }
243 
244  CStatusMessage IMultiSimulatorModelCaches::clearCachedModels(const CSimulatorInfo &simulator)
245  {
246  static const CAircraftModelList models;
247  return this->setCachedModels(models, simulator);
248  }
249 
250  bool IMultiSimulatorModelCaches::isCacheAlreadySynchronized(const CSimulatorInfo &simulator) const
251  {
252  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
253  switch (simulator.getSimulator())
254  {
255  case CSimulatorInfo::FS9: return m_syncFS9;
256  case CSimulatorInfo::FSX: return m_syncFsx;
257  case CSimulatorInfo::P3D: return m_syncP3D;
258  case CSimulatorInfo::XPLANE: return m_syncXPlane;
259  case CSimulatorInfo::FG: return m_syncFG;
260  case CSimulatorInfo::MSFS: return m_syncMsfs;
261  case CSimulatorInfo::MSFS2024: return m_syncMsfs2024;
262  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
263  }
264  return false;
265  }
266 
267  void IMultiSimulatorModelCaches::synchronizeMultiCaches(const CSimulatorInfo &simulator)
268  {
269  for (const CSimulatorInfo &singleSimulator : simulator.asSingleSimulatorSet())
270  {
271  this->synchronizeCache(singleSimulator);
272  }
273  }
274 
275  void IMultiSimulatorModelCaches::admitMultiCaches(const CSimulatorInfo &simulator)
276  {
277  for (const CSimulatorInfo &singleSimulator : simulator.asSingleSimulatorSet())
278  {
279  this->admitMultiCaches(singleSimulator);
280  }
281  }
282 
283  QDateTime CModelCaches::getCacheTimestamp(const CSimulatorInfo &simulator) const
284  {
285  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
286  switch (simulator.getSimulator())
287  {
288  case CSimulatorInfo::FS9: return m_modelCacheFs9.getAvailableTimestamp();
289  case CSimulatorInfo::FSX: return m_modelCacheFsx.getAvailableTimestamp();
290  case CSimulatorInfo::P3D: return m_modelCacheP3D.getAvailableTimestamp();
291  case CSimulatorInfo::XPLANE: return m_modelCacheXP.getAvailableTimestamp();
292  case CSimulatorInfo::FG: return m_modelCacheFG.getAvailableTimestamp();
293  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.getAvailableTimestamp();
294  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.getAvailableTimestamp();
295  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); return QDateTime();
296  }
297  }
298 
299  CStatusMessage CModelCaches::setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
300  {
301  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
302  if (!ts.isValid())
303  {
304  return CStatusMessage(this).error(u"Invalid timestamp for '%1'") << simulator.toQString();
305  }
306  switch (simulator.getSimulator())
307  {
308  case CSimulatorInfo::FS9: return m_modelCacheFs9.set(m_modelCacheFs9.get(), ts.toMSecsSinceEpoch());
309  case CSimulatorInfo::FSX: return m_modelCacheFsx.set(m_modelCacheFsx.get(), ts.toMSecsSinceEpoch());
310  case CSimulatorInfo::P3D: return m_modelCacheP3D.set(m_modelCacheP3D.get(), ts.toMSecsSinceEpoch());
311  case CSimulatorInfo::XPLANE: return m_modelCacheXP.set(m_modelCacheXP.get(), ts.toMSecsSinceEpoch());
312  case CSimulatorInfo::FG: return m_modelCacheFG.set(m_modelCacheFG.get(), ts.toMSecsSinceEpoch());
313  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.set(m_modelCacheMsfs.get(), ts.toMSecsSinceEpoch());
314  case CSimulatorInfo::MSFS2024:
315  return m_modelCacheMsfs2024.set(m_modelCacheMsfs2024.get(), ts.toMSecsSinceEpoch());
316  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
317  }
318  return CStatusMessage();
319  }
320 
321  void CModelCaches::synchronizeCache(const CSimulatorInfo &simulator) { this->synchronizeCacheImpl(simulator); }
322 
323  void CModelCaches::admitCache(const CSimulatorInfo &simulator) { this->admitCacheImpl(simulator); }
324 
325  QString CModelCaches::getFilename(const CSimulatorInfo &simulator) const
326  {
327  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
328  switch (simulator.getSimulator())
329  {
330  case CSimulatorInfo::FS9: return m_modelCacheFs9.getFilename();
331  case CSimulatorInfo::FSX: return m_modelCacheFsx.getFilename();
332  case CSimulatorInfo::P3D: return m_modelCacheP3D.getFilename();
333  case CSimulatorInfo::XPLANE: return m_modelCacheXP.getFilename();
334  case CSimulatorInfo::FG: return m_modelCacheFG.getFilename();
335  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.getFilename();
336  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.getFilename();
337  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
338  }
339  return {};
340  }
341 
342  bool CModelCaches::isSaved(const CSimulatorInfo &simulator) const
343  {
344  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
345  switch (simulator.getSimulator())
346  {
347  case CSimulatorInfo::FS9: return m_modelCacheFs9.isSaved();
348  case CSimulatorInfo::FSX: return m_modelCacheFsx.isSaved();
349  case CSimulatorInfo::P3D: return m_modelCacheP3D.isSaved();
350  case CSimulatorInfo::XPLANE: return m_modelCacheXP.isSaved();
351  case CSimulatorInfo::FG: return m_modelCacheFG.isSaved();
352  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.isSaved();
353  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.isSaved();
354  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
355  }
356  return false;
357  }
358 
359  void CModelCaches::synchronizeCacheImpl(const CSimulatorInfo &simulator)
360  {
361  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
362 
363  if (this->isCacheAlreadySynchronized(simulator)) { return; }
364  switch (simulator.getSimulator())
365  {
366  case CSimulatorInfo::FS9: m_modelCacheFs9.synchronize(); break;
367  case CSimulatorInfo::FSX: m_modelCacheFsx.synchronize(); break;
368  case CSimulatorInfo::P3D: m_modelCacheP3D.synchronize(); break;
369  case CSimulatorInfo::XPLANE: m_modelCacheXP.synchronize(); break;
370  case CSimulatorInfo::FG: m_modelCacheFG.synchronize(); break;
371  case CSimulatorInfo::MSFS: m_modelCacheMsfs.synchronize(); break;
372  case CSimulatorInfo::MSFS2024: m_modelCacheMsfs2024.synchronize(); break;
373  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
374  }
375  this->markCacheAsAlreadySynchronized(simulator, true);
376  this->emitCacheChanged(simulator); // sync
377  }
378 
379  bool CModelCaches::admitCacheImpl(const CSimulatorInfo &simulator)
380  {
381  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
382 
383  if (this->isCacheAlreadySynchronized(simulator)) { return false; }
384  switch (simulator.getSimulator())
385  {
386  case CSimulatorInfo::FS9: m_modelCacheFs9.admit(); break;
387  case CSimulatorInfo::FSX: m_modelCacheFsx.admit(); break;
388  case CSimulatorInfo::P3D: m_modelCacheP3D.admit(); break;
389  case CSimulatorInfo::XPLANE: m_modelCacheXP.admit(); break;
390  case CSimulatorInfo::FG: m_modelCacheFG.admit(); break;
391  case CSimulatorInfo::MSFS: m_modelCacheMsfs.admit(); break;
392  case CSimulatorInfo::MSFS2024: m_modelCacheMsfs2024.admit(); break;
393  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); break;
394  }
395  return true;
396  }
397 
398  CModelSetCaches::CModelSetCaches(bool synchronizeCache, QObject *parent) : IMultiSimulatorModelCaches(parent)
399  {
400  CSimulatorInfo simulator = CSimulatorInfo::guessDefaultSimulator();
401  const QString simStr(simulator.toQString(true));
402 
403  if (synchronizeCache)
404  {
405  this->synchronizeCacheImpl(simulator);
406  CLogMessage(this).info(u"Initialized model caches (%1) for %2") << this->getDescription() << simStr;
407  }
408  else
409  {
410  if (this->admitCacheImpl(simulator))
411  {
412  CLogMessage(this).info(u"Admit model (%1) caches for %2") << this->getDescription() << simStr;
413  }
414  }
415  }
416 
417  const QStringList &CModelSetCaches::getLogCategories()
418  {
419  static const QStringList l({ CLogCategories::modelSetCache() });
420  return l;
421  }
422 
423  CAircraftModelList CModelSetCaches::getCachedModels(const CSimulatorInfo &simulator) const
424  {
425  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
426  switch (simulator.getSimulator())
427  {
428  case CSimulatorInfo::FS9: return m_modelCacheFs9.get();
429  case CSimulatorInfo::FSX: return m_modelCacheFsx.get();
430  case CSimulatorInfo::P3D: return m_modelCacheP3D.get();
431  case CSimulatorInfo::XPLANE: return m_modelCacheXP.get();
432  case CSimulatorInfo::FG: return m_modelCacheFG.get();
433  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.get();
434  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.get();
435  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); return CAircraftModelList();
436  }
437  }
438 
439  CStatusMessage CModelSetCaches::setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
440  {
441  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
442  CAircraftModelList orderedModels(models);
443  orderedModels.setModelType(CAircraftModel::TypeOwnSimulatorModel); // unify type
444 
445  if (simulator.isXPlane())
446  {
447  // see https://discordapp.com/channels/539048679160676382/539064750055751690/648974956306366499
448  // this solves the issue that ACF models are loaded in CSimulatorXPlane::loadCslPackages
449  const int removed = orderedModels.removeXPlaneFlyablePlanes();
450  if (removed > 0) { CLogMessage(this).info(u"Removed %1 flyable models from XPlane model set!"); }
451  }
452 
453  if (orderedModels.needsOrder()) { orderedModels.resetOrder(); }
454  else { orderedModels.sortAscendingByOrder(); }
455 
456  CStatusMessage msg;
457  switch (simulator.getSimulator())
458  {
459  case CSimulatorInfo::FS9: msg = m_modelCacheFs9.set(orderedModels); break;
460  case CSimulatorInfo::FSX: msg = m_modelCacheFsx.set(orderedModels); break;
461  case CSimulatorInfo::P3D: msg = m_modelCacheP3D.set(orderedModels); break;
462  case CSimulatorInfo::XPLANE: msg = m_modelCacheXP.set(orderedModels); break;
463  case CSimulatorInfo::FG: msg = m_modelCacheFG.set(orderedModels); break;
464  case CSimulatorInfo::MSFS: msg = m_modelCacheMsfs.set(orderedModels); break;
465  case CSimulatorInfo::MSFS2024: msg = m_modelCacheMsfs2024.set(orderedModels); break;
466  default: Q_ASSERT_X(false, Q_FUNC_INFO, "wrong simulator"); return CStatusMessage();
467  }
468  this->emitCacheChanged(simulator); // set
469  return msg;
470  }
471 
472  QDateTime CModelSetCaches::getCacheTimestamp(const CSimulatorInfo &simulator) const
473  {
474  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
475  switch (simulator.getSimulator())
476  {
477  case CSimulatorInfo::FS9: return m_modelCacheFs9.getAvailableTimestamp();
478  case CSimulatorInfo::FSX: return m_modelCacheFsx.getAvailableTimestamp();
479  case CSimulatorInfo::P3D: return m_modelCacheP3D.getAvailableTimestamp();
480  case CSimulatorInfo::XPLANE: return m_modelCacheXP.getAvailableTimestamp();
481  case CSimulatorInfo::FG: return m_modelCacheFG.getAvailableTimestamp();
482  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.getAvailableTimestamp();
483  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.getAvailableTimestamp();
484  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); return QDateTime();
485  }
486  }
487 
488  CStatusMessage CModelSetCaches::setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
489  {
490  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
491  if (!ts.isValid())
492  {
493  return CStatusMessage(this).error(u"Invalid timestamp for '%1'") << simulator.toQString();
494  }
495  switch (simulator.getSimulator())
496  {
497  case CSimulatorInfo::FS9: return m_modelCacheFs9.set(m_modelCacheFs9.get(), ts.toMSecsSinceEpoch());
498  case CSimulatorInfo::FSX: return m_modelCacheFsx.set(m_modelCacheFsx.get(), ts.toMSecsSinceEpoch());
499  case CSimulatorInfo::P3D: return m_modelCacheP3D.set(m_modelCacheP3D.get(), ts.toMSecsSinceEpoch());
500  case CSimulatorInfo::XPLANE: return m_modelCacheXP.set(m_modelCacheXP.get(), ts.toMSecsSinceEpoch());
501  case CSimulatorInfo::FG: return m_modelCacheFG.set(m_modelCacheFG.get(), ts.toMSecsSinceEpoch());
502  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.set(m_modelCacheMsfs.get(), ts.toMSecsSinceEpoch());
503  case CSimulatorInfo::MSFS2024:
504  return m_modelCacheMsfs2024.set(m_modelCacheMsfs2024.get(), ts.toMSecsSinceEpoch());
505  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
506  }
507  return CStatusMessage();
508  }
509 
510  void CModelSetCaches::synchronizeCache(const CSimulatorInfo &simulator) { this->synchronizeCacheImpl(simulator); }
511 
512  void CModelSetCaches::admitCache(const CSimulatorInfo &simulator) { this->admitCacheImpl(simulator); }
513 
514  QString CModelSetCaches::getFilename(const CSimulatorInfo &simulator) const
515  {
516  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
517  switch (simulator.getSimulator())
518  {
519  case CSimulatorInfo::FS9: return m_modelCacheFs9.getFilename();
520  case CSimulatorInfo::FSX: return m_modelCacheFsx.getFilename();
521  case CSimulatorInfo::P3D: return m_modelCacheP3D.getFilename();
522  case CSimulatorInfo::XPLANE: return m_modelCacheXP.getFilename();
523  case CSimulatorInfo::FG: return m_modelCacheFG.getFilename();
524  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.getFilename();
525  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.getFilename();
526  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
527  }
528  return {};
529  }
530 
531  bool CModelSetCaches::isSaved(const CSimulatorInfo &simulator) const
532  {
533  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
534  switch (simulator.getSimulator())
535  {
536  case CSimulatorInfo::FS9: return m_modelCacheFs9.isSaved();
537  case CSimulatorInfo::FSX: return m_modelCacheFsx.isSaved();
538  case CSimulatorInfo::P3D: return m_modelCacheP3D.isSaved();
539  case CSimulatorInfo::XPLANE: return m_modelCacheXP.isSaved();
540  case CSimulatorInfo::FG: return m_modelCacheFG.isSaved();
541  case CSimulatorInfo::MSFS: return m_modelCacheMsfs.isSaved();
542  case CSimulatorInfo::MSFS2024: return m_modelCacheMsfs2024.isSaved();
543  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
544  }
545  return false;
546  }
547 
548  void CModelSetCaches::synchronizeCacheImpl(const CSimulatorInfo &simulator)
549  {
550  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
551 
552  if (this->isCacheAlreadySynchronized(simulator)) { return; }
553  switch (simulator.getSimulator())
554  {
555  case CSimulatorInfo::FS9: m_modelCacheFs9.synchronize(); break;
556  case CSimulatorInfo::FSX: m_modelCacheFsx.synchronize(); break;
557  case CSimulatorInfo::P3D: m_modelCacheP3D.synchronize(); break;
558  case CSimulatorInfo::XPLANE: m_modelCacheXP.synchronize(); break;
559  case CSimulatorInfo::FG: m_modelCacheFG.synchronize(); break;
560  case CSimulatorInfo::MSFS: m_modelCacheMsfs.synchronize(); break;
561  case CSimulatorInfo::MSFS2024: m_modelCacheMsfs2024.synchronize(); break;
562  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
563  }
564  this->markCacheAsAlreadySynchronized(simulator, true);
565  this->emitCacheChanged(simulator); // sync
566  }
567 
568  bool CModelSetCaches::admitCacheImpl(const CSimulatorInfo &simulator)
569  {
570  Q_ASSERT_X(simulator.isSingleSimulator(), Q_FUNC_INFO, "No single simulator");
571 
572  if (this->isCacheAlreadySynchronized(simulator)) { return false; }
573  switch (simulator.getSimulator())
574  {
575  case CSimulatorInfo::FS9: m_modelCacheFs9.admit(); break;
576  case CSimulatorInfo::FSX: m_modelCacheFsx.admit(); break;
577  case CSimulatorInfo::P3D: m_modelCacheP3D.admit(); break;
578  case CSimulatorInfo::XPLANE: m_modelCacheXP.admit(); break;
579  case CSimulatorInfo::FG: m_modelCacheFG.admit(); break;
580  case CSimulatorInfo::MSFS: m_modelCacheMsfs.admit(); break;
581  case CSimulatorInfo::MSFS2024: m_modelCacheMsfs2024.admit(); break;
582  default: Q_ASSERT_X(false, Q_FUNC_INFO, "Wrong simulator"); break;
583  }
584  return true;
585  }
586 } // namespace swift::misc::simulation::data
swift::misc::CApplicationInfo
Description of a swift application.
Definition: applicationinfo.h:26
swift::misc::CCacheSettingsUtils::hasOtherVersionCacheFile
static bool hasOtherVersionCacheFile(const swift::misc::CApplicationInfo &info, const QString &myCacheFile)
Has the cache file for the given other version?
Definition: cachesettingsutils.cpp:71
swift::misc::CLogCategories::modelSetCache
static const QString & modelSetCache()
Model set cache.
Definition: logcategories.h:171
swift::misc::CLogCategories::modelCache
static const QString & modelCache()
Model cache.
Definition: logcategories.h:164
swift::misc::CLogMessage
Class for emitting a log message.
Definition: logmessage.h:27
swift::misc::CMessageBase::error
Derived & error(const char16_t(&format)[N])
Set the severity to error, providing a format string.
Definition: statusmessage.h:234
swift::misc::CMessageBase::info
Derived & info(const char16_t(&format)[N])
Set the severity to info, providing a format string.
Definition: statusmessage.h:214
swift::misc::CSequence::size
size_type size() const
Returns number of elements in the sequence.
Definition: sequence.h:273
swift::misc::CSequence::isEmpty
bool isEmpty() const
Synonym for empty.
Definition: sequence.h:285
swift::misc::CStatusMessage
Streamable status message, e.g.
Definition: statusmessage.h:394
swift::misc::IOrderableList::sortAscendingByOrder
void sortAscendingByOrder()
Sort ascending.
Definition: orderablelist.h:24
swift::misc::IOrderableList::resetOrder
void resetOrder(int offset=0)
Set order member to current order.
Definition: orderablelist.h:34
swift::misc::IOrderableList::needsOrder
bool needsOrder() const
All order values set or missing some?
Definition: orderablelist.h:41
swift::misc::mixin::String::toQString
QString toQString(bool i18n=false) const
Cast as QString.
Definition: mixinstring.h:76
swift::misc::simulation::CAircraftModel::TypeOwnSimulatorModel
@ TypeOwnSimulatorModel
represents own simulator model (AI model, model on disk)
Definition: aircraftmodel.h:84
swift::misc::simulation::CAircraftModelList
Value object encapsulating a list of aircraft models.
Definition: aircraftmodellist.h:60
swift::misc::simulation::CAircraftModelList::replaceOrAddModelsWithString
int replaceOrAddModelsWithString(const CAircraftModelList &addOrReplaceList, Qt::CaseSensitivity sensitivity)
Replace or add based on model string.
Definition: aircraftmodellist.cpp:857
swift::misc::simulation::CAircraftModelList::removeXPlaneFlyablePlanes
int removeXPlaneFlyablePlanes()
Remove the XPlane flyable planes.
Definition: aircraftmodellist.cpp:804
swift::misc::simulation::CAircraftModelList::setModelType
int setModelType(CAircraftModel::ModelType type)
Set type for all elements.
Definition: aircraftmodellist.cpp:702
swift::misc::simulation::CSimulatorInfo
Simple hardcoded info about the corresponding simulator.
Definition: simulatorinfo.h:41
swift::misc::simulation::CSimulatorInfo::allSimulatorsSet
static const QSet< CSimulatorInfo > & allSimulatorsSet()
All simulators as set.
Definition: simulatorinfo.cpp:237
swift::misc::simulation::CSimulatorInfo::addSimulator
void addSimulator(Simulator s)
Add simulator flags.
Definition: simulatorinfo.h:149
swift::misc::simulation::CSimulatorInfo::add
CSimulatorInfo add(const CSimulatorInfo &other)
Add simulator.
Definition: simulatorinfo.cpp:138
swift::misc::simulation::CSimulatorInfo::asSingleSimulatorSet
QSet< CSimulatorInfo > asSingleSimulatorSet() const
As a set of single simulator info objects.
Definition: simulatorinfo.cpp:149
swift::misc::simulation::CSimulatorInfo::allSimulators
static const CSimulatorInfo & allSimulators()
All simulators.
Definition: simulatorinfo.cpp:220
swift::misc::simulation::CSimulatorInfo::isSingleSimulator
bool isSingleSimulator() const
Single simulator selected.
Definition: simulatorinfo.cpp:71
swift::misc::simulation::CSimulatorInfo::guessDefaultSimulator
static const CSimulatorInfo & guessDefaultSimulator()
Guess a default simulator based on installation.
Definition: simulatorinfo.cpp:291
swift::misc::simulation::CSimulatorInfo::getSimulator
Simulator getSimulator() const
Simulator.
Definition: simulatorinfo.h:143
swift::misc::simulation::CSimulatorInfo::msfs
static const CSimulatorInfo & msfs()
Const simulator info objects.
Definition: simulatorinfo.h:232
swift::misc::simulation::CSimulatorInfo::fs9
static const CSimulatorInfo & fs9()
Const simulator info objects.
Definition: simulatorinfo.h:222
swift::misc::simulation::CSimulatorInfo::fsx
static const CSimulatorInfo & fsx()
Const simulator info objects.
Definition: simulatorinfo.h:212
swift::misc::simulation::CSimulatorInfo::p3d
static const CSimulatorInfo & p3d()
Const simulator info objects.
Definition: simulatorinfo.h:217
swift::misc::simulation::CSimulatorInfo::xplane
static const CSimulatorInfo & xplane()
Const simulator info objects.
Definition: simulatorinfo.h:227
swift::misc::simulation::CSimulatorInfo::msfs2024
static const CSimulatorInfo & msfs2024()
Const simulator info objects.
Definition: simulatorinfo.h:237
swift::misc::simulation::CSimulatorInfo::fg
static const CSimulatorInfo & fg()
Const simulator info objects.
Definition: simulatorinfo.h:207
swift::misc::simulation::data::CModelCaches::getCachedModels
CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const
Models for simulator.
Definition: modelcaches.cpp:206
swift::misc::simulation::data::CModelCaches::CModelCaches
CModelCaches(bool synchronizeCache, QObject *parent=nullptr)
Construtor.
Definition: modelcaches.cpp:182
swift::misc::simulation::data::CModelCaches::getDescription
QString getDescription() const
Descriptive text.
Definition: modelcaches.h:359
swift::misc::simulation::data::CModelCaches::setCachedModels
CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
Set cached models.
Definition: modelcaches.cpp:222
swift::misc::simulation::data::CModelCaches::isSaved
bool isSaved(const CSimulatorInfo &simulator) const
Cache saved?
Definition: modelcaches.cpp:342
swift::misc::simulation::data::CModelCaches::synchronizeCache
void synchronizeCache(const CSimulatorInfo &simulator)
Synchronize for given simulator.
Definition: modelcaches.cpp:321
swift::misc::simulation::data::CModelCaches::getCacheTimestamp
QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const
Cache timestamp.
Definition: modelcaches.cpp:283
swift::misc::simulation::data::CModelCaches::admitCache
void admitCache(const CSimulatorInfo &simulator)
Admit the cache for given simulator.
Definition: modelcaches.cpp:323
swift::misc::simulation::data::CModelCaches::setCacheTimestamp
CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
Set cache timestamp.
Definition: modelcaches.cpp:299
swift::misc::simulation::data::CModelCaches::getLogCategories
static const QStringList & getLogCategories()
Log categories.
Definition: modelcaches.cpp:200
swift::misc::simulation::data::CModelCaches::getFilename
QString getFilename(const CSimulatorInfo &simulator) const
Get filename for simulator cache file.
Definition: modelcaches.cpp:325
swift::misc::simulation::data::CModelSetCaches::admitCache
void admitCache(const CSimulatorInfo &simulator)
Admit the cache for given simulator.
Definition: modelcaches.cpp:512
swift::misc::simulation::data::CModelSetCaches::getDescription
QString getDescription() const
Descriptive text.
Definition: modelcaches.h:402
swift::misc::simulation::data::CModelSetCaches::getFilename
QString getFilename(const CSimulatorInfo &simulator) const
Get filename for simulator cache file.
Definition: modelcaches.cpp:514
swift::misc::simulation::data::CModelSetCaches::CModelSetCaches
CModelSetCaches(bool synchronizeCache, QObject *parent=nullptr)
Construtor.
Definition: modelcaches.cpp:398
swift::misc::simulation::data::CModelSetCaches::setCacheTimestamp
CStatusMessage setCacheTimestamp(const QDateTime &ts, const CSimulatorInfo &simulator)
Set cache timestamp.
Definition: modelcaches.cpp:488
swift::misc::simulation::data::CModelSetCaches::setCachedModels
CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)
Set cached models.
Definition: modelcaches.cpp:439
swift::misc::simulation::data::CModelSetCaches::isSaved
bool isSaved(const CSimulatorInfo &simulator) const
Cache saved?
Definition: modelcaches.cpp:531
swift::misc::simulation::data::CModelSetCaches::synchronizeCache
void synchronizeCache(const CSimulatorInfo &simulator)
Synchronize for given simulator.
Definition: modelcaches.cpp:510
swift::misc::simulation::data::CModelSetCaches::getLogCategories
static const QStringList & getLogCategories()
Log categories.
Definition: modelcaches.cpp:417
swift::misc::simulation::data::CModelSetCaches::getCacheTimestamp
QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const
Cache timestamp.
Definition: modelcaches.cpp:472
swift::misc::simulation::data::CModelSetCaches::getCachedModels
CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const
Models for simulator.
Definition: modelcaches.cpp:423
swift::misc::simulation::data::IMultiSimulatorModelCaches
Cache for multiple simulators specified by CSimulatorInfo.
Definition: modelcaches.h:189
swift::misc::simulation::data::IMultiSimulatorModelCaches::simulatorsWithInitializedCache
CSimulatorInfo simulatorsWithInitializedCache() const
Initialized caches for which simulator?
Definition: modelcaches.cpp:160
swift::misc::simulation::data::IMultiSimulatorModelCaches::otherVersionSimulatorsWithFile
CSimulatorInfo otherVersionSimulatorsWithFile(const swift::misc::CApplicationInfo &info) const
Simulators of given other versionwhich have a cache file.
Definition: modelcaches.cpp:98
swift::misc::simulation::data::IMultiSimulatorModelCaches::getSimulatorForFilename
CSimulatorInfo getSimulatorForFilename(const QString &filename) const
Simulator which uses cache with filename.
Definition: modelcaches.cpp:127
swift::misc::simulation::data::IMultiSimulatorModelCaches::isCacheAlreadySynchronized
bool isCacheAlreadySynchronized(const CSimulatorInfo &simulator) const
Is the cache already synchronized?
Definition: modelcaches.cpp:250
swift::misc::simulation::data::IMultiSimulatorModelCaches::getInfoString
QString getInfoString() const
Info string about models in cache.
Definition: modelcaches.cpp:33
swift::misc::simulation::data::IMultiSimulatorModelCaches::synchronizeCache
virtual void synchronizeCache(const CSimulatorInfo &simulator)=0
Synchronize for given simulator.
swift::misc::simulation::data::IMultiSimulatorModelCaches::getCachedModelsCount
int getCachedModelsCount(const CSimulatorInfo &simulator) const
Count of models for simulator.
Definition: modelcaches.cpp:86
swift::misc::simulation::data::IMultiSimulatorModelCaches::clearCachedModels
virtual CStatusMessage clearCachedModels(const CSimulatorInfo &simulator)
Clear cached models.
Definition: modelcaches.cpp:244
swift::misc::simulation::data::IMultiSimulatorModelCaches::hasOtherVersionFile
bool hasOtherVersionFile(const swift::misc::CApplicationInfo &info, const CSimulatorInfo &simulator) const
Has the other version the file?
Definition: modelcaches.cpp:91
swift::misc::simulation::data::IMultiSimulatorModelCaches::getCachedModels
virtual CAircraftModelList getCachedModels(const CSimulatorInfo &simulator) const =0
Models for simulator.
swift::misc::simulation::data::IMultiSimulatorModelCaches::getSynchronizedCachedModels
CAircraftModelList getSynchronizedCachedModels(const CSimulatorInfo &simulator)
Models.
Definition: modelcaches.cpp:146
swift::misc::simulation::data::IMultiSimulatorModelCaches::simulatorsWithModels
CSimulatorInfo simulatorsWithModels() const
Simulators which have models.
Definition: modelcaches.cpp:172
swift::misc::simulation::data::IMultiSimulatorModelCaches::setCachedModels
virtual CStatusMessage setCachedModels(const CAircraftModelList &models, const CSimulatorInfo &simulator)=0
Set cached models.
swift::misc::simulation::data::IMultiSimulatorModelCaches::getFilename
virtual QString getFilename(const CSimulatorInfo &simulator) const =0
Get filename for simulator cache file.
swift::misc::simulation::data::IMultiSimulatorModelCaches::synchronizeMultiCaches
virtual void synchronizeMultiCaches(const CSimulatorInfo &simulator)
Synchronize multiple simulators.
Definition: modelcaches.cpp:267
swift::misc::simulation::data::IMultiSimulatorModelCaches::emitCacheChanged
void emitCacheChanged(const CSimulatorInfo &simulator)
Emit cacheChanged() utility function (allows breakpoint)
Definition: modelcaches.cpp:81
swift::misc::simulation::data::IMultiSimulatorModelCaches::getCacheCountAndTimestamp
QString getCacheCountAndTimestamp(const CSimulatorInfo &simulator) const
Cache count and timestamp.
Definition: modelcaches.cpp:53
swift::misc::simulation::data::IMultiSimulatorModelCaches::getAllFilenames
virtual QStringList getAllFilenames() const
All file names.
Definition: modelcaches.cpp:114
swift::misc::simulation::data::IMultiSimulatorModelCaches::cacheChanged
void cacheChanged(const swift::misc::simulation::CSimulatorInfo &simulator)
Cache has been changed.
swift::misc::simulation::data::IMultiSimulatorModelCaches::setModelsForSimulator
void setModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator)
Set models.
Definition: modelcaches.cpp:16
swift::misc::simulation::data::IMultiSimulatorModelCaches::markCacheAsAlreadySynchronized
void markCacheAsAlreadySynchronized(const CSimulatorInfo &simulator, bool synchronized)
Is the cache already synchronized?
Definition: modelcaches.cpp:65
swift::misc::simulation::data::IMultiSimulatorModelCaches::getSynchronizedTimestamp
QDateTime getSynchronizedTimestamp(const CSimulatorInfo &simulator)
Timestamp.
Definition: modelcaches.cpp:153
swift::misc::simulation::data::IMultiSimulatorModelCaches::admitMultiCaches
virtual void admitMultiCaches(const CSimulatorInfo &simulator)
Synchronize multiple simulators.
Definition: modelcaches.cpp:275
swift::misc::simulation::data::IMultiSimulatorModelCaches::getInfoStringFsFamily
QString getInfoStringFsFamily() const
Info string without XPlane (FSX,P3D, FS9)
Definition: modelcaches.cpp:43
swift::misc::simulation::data::IMultiSimulatorModelCaches::getCacheTimestamp
virtual QDateTime getCacheTimestamp(const CSimulatorInfo &simulator) const =0
Cache timestamp.
swift::misc::simulation::data::IMultiSimulatorModelCaches::updateModelsForSimulator
int updateModelsForSimulator(const CAircraftModelList &models, const CSimulatorInfo &simulator)
Set models.
Definition: modelcaches.cpp:22
swift::misc
Free functions in swift::misc.
Definition: aircraftmatcher.h:22
SWIFT_VERIFY_X
#define SWIFT_VERIFY_X(COND, WHERE, WHAT)
A weaker kind of assert.
Definition: verify.h:26
Generated on Mon Mar 24 2025 16:42:22 for swift by doxygen 1.9.1