##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Add comment
perrinel -
r442:dd79727b8dcb
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,242 +1,244
1 1 #include <Variable/Variable.h>
2 2 #include <Variable/VariableCacheController.h>
3 3 #include <Variable/VariableController.h>
4 4 #include <Variable/VariableModel.h>
5 5
6 6 #include <Data/DataProviderParameters.h>
7 7 #include <Data/IDataProvider.h>
8 8 #include <Data/IDataSeries.h>
9 9 #include <Time/TimeController.h>
10 10
11 11 #include <QDateTime>
12 12 #include <QMutex>
13 13 #include <QThread>
14 14 #include <QUuid>
15 15 #include <QtCore/QItemSelectionModel>
16 16
17 17 #include <unordered_map>
18 18
19 19 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
20 20
21 21 struct VariableController::VariableControllerPrivate {
22 22 explicit VariableControllerPrivate(VariableController *parent)
23 23 : m_WorkingMutex{},
24 24 m_VariableModel{new VariableModel{parent}},
25 25 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
26 26 m_VariableCacheController{std::make_unique<VariableCacheController>()}
27 27 {
28 28 }
29 29
30 30 QMutex m_WorkingMutex;
31 31 /// Variable model. The VariableController has the ownership
32 32 VariableModel *m_VariableModel;
33 33 QItemSelectionModel *m_VariableSelectionModel;
34 34
35 35
36 36 TimeController *m_TimeController{nullptr};
37 37 std::unique_ptr<VariableCacheController> m_VariableCacheController;
38 38
39 39 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
40 40 m_VariableToProviderMap;
41 41 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
42 42 };
43 43
44 44 VariableController::VariableController(QObject *parent)
45 45 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
46 46 {
47 47 qCDebug(LOG_VariableController()) << tr("VariableController construction")
48 48 << QThread::currentThread();
49 49
50 50 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
51 51 &VariableController::onAbortProgressRequested);
52 52 }
53 53
54 54 VariableController::~VariableController()
55 55 {
56 56 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
57 57 << QThread::currentThread();
58 58 this->waitForFinish();
59 59 }
60 60
61 61 VariableModel *VariableController::variableModel() noexcept
62 62 {
63 63 return impl->m_VariableModel;
64 64 }
65 65
66 66 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
67 67 {
68 68 return impl->m_VariableSelectionModel;
69 69 }
70 70
71 71 void VariableController::setTimeController(TimeController *timeController) noexcept
72 72 {
73 73 impl->m_TimeController = timeController;
74 74 }
75 75
76 76 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
77 77 {
78 78 if (!variable) {
79 79 qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
80 80 return;
81 81 }
82 82
83 83 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
84 84 // make some treatments before the deletion
85 85 emit variableAboutToBeDeleted(variable);
86 86
87 87 // Deletes identifier
88 88 impl->m_VariableToIdentifierMap.erase(variable);
89 89
90 90 // Deletes provider
91 91 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
92 92 qCDebug(LOG_VariableController())
93 93 << tr("Number of providers deleted for variable %1: %2")
94 94 .arg(variable->name(), QString::number(nbProvidersDeleted));
95 95
96 96 // Clears cache
97 97 impl->m_VariableCacheController->clear(variable);
98 98
99 99 // Deletes from model
100 100 impl->m_VariableModel->deleteVariable(variable);
101 101 }
102 102
103 103 void VariableController::deleteVariables(
104 104 const QVector<std::shared_ptr<Variable> > &variables) noexcept
105 105 {
106 106 for (auto variable : qAsConst(variables)) {
107 107 deleteVariable(variable);
108 108 }
109 109 }
110 110
111 111 void VariableController::abortProgress(std::shared_ptr<Variable> variable)
112 112 {
113 113 }
114 114
115 115 void VariableController::createVariable(const QString &name, const QVariantHash &metadata,
116 116 std::shared_ptr<IDataProvider> provider) noexcept
117 117 {
118 118
119 119 if (!impl->m_TimeController) {
120 120 qCCritical(LOG_VariableController())
121 121 << tr("Impossible to create variable: The time controller is null");
122 122 return;
123 123 }
124 124
125 125 auto dateTime = impl->m_TimeController->dateTime();
126 126
127 127 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime, metadata)) {
128 128 auto identifier = QUuid::createUuid();
129 129
130 130 // store the provider
131 131 impl->m_VariableToProviderMap[newVariable] = provider;
132 132 impl->m_VariableToIdentifierMap[newVariable] = identifier;
133 133
134 134 auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
135 135 QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
136 136 {
137 137 if (auto variable = varW.lock()) {
138 138 auto varIdentifier = impl->m_VariableToIdentifierMap.at(variable);
139 139 if (varIdentifier == identifier) {
140 140 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
141 141 variable->setDataSeries(dataSeriesAcquired);
142 142 emit variable->updated();
143 143 }
144 144 }
145 145 };
146 146
147 147 connect(provider.get(), &IDataProvider::dataProvided, addDateTimeAcquired);
148 148 connect(provider.get(), &IDataProvider::dataProvidedProgress, this,
149 149 &VariableController::onVariableRetrieveDataInProgress);
150 150 this->onRequestDataLoading(newVariable, dateTime);
151 151 }
152 152 }
153 153
154 154 void VariableController::onDateTimeOnSelection(const SqpDateTime &dateTime)
155 155 {
156 156 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
157 157 << QThread::currentThread()->objectName();
158 158 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
159 159
160 160 for (const auto &selectedRow : qAsConst(selectedRows)) {
161 161 if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
162 162 selectedVariable->setDateTime(dateTime);
163 163 this->onRequestDataLoading(selectedVariable, dateTime);
164
165 // notify that rescale operation has to be done
164 166 emit rangeChanged(selectedVariable, dateTime);
165 167 }
166 168 }
167 169 }
168 170
169 171 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
170 172 {
171 173 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
172 174
173 175 auto end = impl->m_VariableToIdentifierMap.cend();
174 176 auto it = std::find_if(impl->m_VariableToIdentifierMap.cbegin(), end, findReply);
175 177 if (it != end) {
176 178 impl->m_VariableModel->setDataProgress(it->first, progress);
177 179 }
178 180 }
179 181
180 182 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
181 183 {
182 184 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
183 185 << QThread::currentThread()->objectName();
184 186
185 187 auto it = impl->m_VariableToIdentifierMap.find(variable);
186 188 if (it != impl->m_VariableToIdentifierMap.cend()) {
187 189 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
188 190 }
189 191 else {
190 192 qCWarning(LOG_VariableController())
191 193 << tr("Aborting progression of inexistant variable detected !!!")
192 194 << QThread::currentThread()->objectName();
193 195 }
194 196 }
195 197
196 198
197 199 void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable,
198 200 const SqpDateTime &dateTime)
199 201 {
200 202 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
201 203 << QThread::currentThread()->objectName();
202 204 // we want to load data of the variable for the dateTime.
203 205 // First we check if the cache contains some of them.
204 206 // For the other, we ask the provider to give them.
205 207 if (variable) {
206 208
207 209 auto dateTimeListNotInCache
208 210 = impl->m_VariableCacheController->provideNotInCacheDateTimeList(variable, dateTime);
209 211
210 212 if (!dateTimeListNotInCache.empty()) {
211 213 // Ask the provider for each data on the dateTimeListNotInCache
212 214 auto identifier = impl->m_VariableToIdentifierMap.at(variable);
213 215 impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
214 216 identifier,
215 217 DataProviderParameters{std::move(dateTimeListNotInCache), variable->metadata()});
216 218 }
217 219 else {
218 220 emit variable->updated();
219 221 }
220 222 }
221 223 else {
222 224 qCCritical(LOG_VariableController()) << tr("Impossible to load data of a variable null");
223 225 }
224 226 }
225 227
226 228
227 229 void VariableController::initialize()
228 230 {
229 231 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
230 232 impl->m_WorkingMutex.lock();
231 233 qCDebug(LOG_VariableController()) << tr("VariableController init END");
232 234 }
233 235
234 236 void VariableController::finalize()
235 237 {
236 238 impl->m_WorkingMutex.unlock();
237 239 }
238 240
239 241 void VariableController::waitForFinish()
240 242 {
241 243 QMutexLocker locker{&impl->m_WorkingMutex};
242 244 }
General Comments 0
You need to be logged in to leave comments. Login now