GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1327:d0b687dbfe3e

1

#include <Variable/Variable.h>

1

#include <Variable/Variable.h>

2

#include <Variable/VariableAcquisitionWorker.h>

2

#include <Variable/VariableAcquisitionWorker.h>

3

#include <Variable/VariableCacheStrategy.h>

3

#include <Variable/VariableCacheStrategy.h>

4

#include <Variable/VariableCacheStrategyFactory.h>

4

#include <Variable/VariableCacheStrategyFactory.h>

5

#include <Variable/VariableController.h>

5

#include <Variable/VariableController.h>

6

#include <Variable/VariableModel.h>

6

#include <Variable/VariableModel.h>

7

#include <Variable/VariableSynchronizationGroup.h>

7

#include <Variable/VariableSynchronizationGroup.h>

8

9

#include <Data/DataProviderParameters.h>

9

#include <Data/DataProviderParameters.h>

10

#include <Data/IDataProvider.h>

10

#include <Data/IDataProvider.h>

11

#include <Data/IDataSeries.h>

11

#include <Data/IDataSeries.h>

12

#include <Data/VariableRequest.h>

12

#include <Data/VariableRequest.h>

13

#include <Time/TimeController.h>

13

#include <Time/TimeController.h>

14

15

#include <QDataStream>

15

#include <QDataStream>

16

#include <QMutex>

16

#include <QMutex>

17

#include <QThread>

17

#include <QThread>

18

#include <QUuid>

18

#include <QUuid>

19

#include <QtCore/QItemSelectionModel>

19

#include <QtCore/QItemSelectionModel>

20

21

#include <deque>

21

#include <deque>

22

#include <set>

22

#include <set>

23

#include <unordered_map>

23

#include <unordered_map>

24

25

Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")

25

Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")

26

27

namespace {

27

namespace {

28

29

SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,

29

SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,

30

const SqpRange &oldGraphRange)

30

const SqpRange &oldGraphRange)

31

{

31

{

32

auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);

32

auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);

33

34

auto varRangeRequested = varRange;

34

auto varRangeRequested = varRange;

35

switch (zoomType) {

35

switch (zoomType) {

36

case AcquisitionZoomType::ZoomIn: {

36

case AcquisitionZoomType::ZoomIn: {

37

auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;

37

auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;

38

auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;

38

auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;

39

varRangeRequested.m_TStart += deltaLeft;

39

varRangeRequested.m_TStart += deltaLeft;

40

varRangeRequested.m_TEnd -= deltaRight;

40

varRangeRequested.m_TEnd -= deltaRight;

41

break;

41

break;

42

}

42

}

43

44

case AcquisitionZoomType::ZoomOut: {

44

case AcquisitionZoomType::ZoomOut: {

45

auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;

45

auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;

46

auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;

46

auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;

47

varRangeRequested.m_TStart -= deltaLeft;

47

varRangeRequested.m_TStart -= deltaLeft;

48

varRangeRequested.m_TEnd += deltaRight;

48

varRangeRequested.m_TEnd += deltaRight;

49

break;

49

break;

50

}

50

}

51

case AcquisitionZoomType::PanRight: {

51

case AcquisitionZoomType::PanRight: {

52

auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;

52

auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;

53

auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;

53

auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;

54

varRangeRequested.m_TStart += deltaLeft;

54

varRangeRequested.m_TStart += deltaLeft;

55

varRangeRequested.m_TEnd += deltaRight;

55

varRangeRequested.m_TEnd += deltaRight;

56

break;

56

break;

57

}

57

}

58

case AcquisitionZoomType::PanLeft: {

58

case AcquisitionZoomType::PanLeft: {

59

auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;

59

auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;

60

auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;

60

auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;

61

varRangeRequested.m_TStart -= deltaLeft;

61

varRangeRequested.m_TStart -= deltaLeft;

62

varRangeRequested.m_TEnd -= deltaRight;

62

varRangeRequested.m_TEnd -= deltaRight;

63

break;

63

break;

64

}

64

}

65

case AcquisitionZoomType::Unknown: {

65

case AcquisitionZoomType::Unknown: {

66

qCCritical(LOG_VariableController())

66

qCCritical(LOG_VariableController())

67

<< VariableController::tr("Impossible to synchronize: zoom type unknown");

67

<< VariableController::tr("Impossible to synchronize: zoom type unknown");

68

break;

68

break;

69

}

69

}

70

default:

70

default:

71

qCCritical(LOG_VariableController()) << VariableController::tr(

71

qCCritical(LOG_VariableController()) << VariableController::tr(

72

"Impossible to synchronize: zoom type not take into account");

72

"Impossible to synchronize: zoom type not take into account");

73

// No action

73

// No action

74

break;

74

break;

75

}

75

}

76

77

return varRangeRequested;

77

return varRangeRequested;

78

}

78

}

79

}

79

}

80

81

enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };

81

enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };

82

83

struct VariableRequestHandler {

83

struct VariableRequestHandler {

84

85

VariableRequestHandler()

85

VariableRequestHandler()

86

{

86

{

87

m_CanUpdate = false;

87

m_CanUpdate = false;

88

m_State = VariableRequestHandlerState::OFF;

88

m_State = VariableRequestHandlerState::OFF;

89

}

89

}

90

91

QUuid m_VarId;

91

QUuid m_VarId;

92

VariableRequest m_RunningVarRequest;

92

VariableRequest m_RunningVarRequest;

93

VariableRequest m_PendingVarRequest;

93

VariableRequest m_PendingVarRequest;

94

VariableRequestHandlerState m_State;

94

VariableRequestHandlerState m_State;

95

bool m_CanUpdate;

95

bool m_CanUpdate;

96

};

96

};

97

98

struct VariableController::VariableControllerPrivate {

98

struct VariableController::VariableControllerPrivate {

99

explicit VariableControllerPrivate(VariableController *parent)

99

explicit VariableControllerPrivate(VariableController *parent)

100

: m_WorkingMutex{},

100

: m_WorkingMutex{},

101

m_VariableModel{new VariableModel{parent}},

101

m_VariableModel{new VariableModel{parent}},

102

m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},

102

m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},

103

// m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},

103

// m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},

104

m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(

104

m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(

105

CacheStrategy::SingleThreshold)},

105

CacheStrategy::SingleThreshold)},

106

m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},

106

m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},

107

q{parent}

107

q{parent}

108

{

108

{

109

110

m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);

110

m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);

111

m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");

111

m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");

112

}

112

}

113

114

115

virtual ~VariableControllerPrivate()

115

virtual ~VariableControllerPrivate()

116

{

116

{

117

qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");

117

qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");

118

m_VariableAcquisitionWorkerThread.quit();

118

m_VariableAcquisitionWorkerThread.quit();

119

m_VariableAcquisitionWorkerThread.wait();

119

m_VariableAcquisitionWorkerThread.wait();

120

}

120

}

121

122

123

void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,

123

void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,

124

QUuid varRequestId);

124

QUuid varRequestId);

125

126

std::shared_ptr<Variable> findVariable(QUuid vIdentifier);

126

std::shared_ptr<Variable> findVariable(QUuid vIdentifier);

127

std::shared_ptr<IDataSeries>

127

std::shared_ptr<IDataSeries>

128

retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);

128

retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);

129

130

void registerProvider(std::shared_ptr<IDataProvider> provider);

130

void registerProvider(std::shared_ptr<IDataProvider> provider);

131

132

void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);

132

void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);

133

QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);

133

QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);

134

void updateVariables(QUuid varRequestId);

134

void updateVariables(QUuid varRequestId);

135

void updateVariableRequest(QUuid varRequestId);

135

void updateVariableRequest(QUuid varRequestId);

136

void cancelVariableRequest(QUuid varRequestId);

136

void cancelVariableRequest(QUuid varRequestId);

137

void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);

137

void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);

138

139

template <typename VariableIterator>

140

void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);

141

139

QMutex m_WorkingMutex;

142

QMutex m_WorkingMutex;

140

/// Variable model. The VariableController has the ownership

143

/// Variable model. The VariableController has the ownership

141

VariableModel *m_VariableModel;

144

VariableModel *m_VariableModel;

142

QItemSelectionModel *m_VariableSelectionModel;

145

QItemSelectionModel *m_VariableSelectionModel;

143

146

144

147

145

TimeController *m_TimeController{nullptr};

148

TimeController *m_TimeController{nullptr};

146

std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;

149

std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;

147

std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;

150

std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;

148

QThread m_VariableAcquisitionWorkerThread;

151

QThread m_VariableAcquisitionWorkerThread;

149

152

150

std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >

153

std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >

151

m_VariableToProviderMap;

154

m_VariableToProviderMap;

152

std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;

155

std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;

153

std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >

156

std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >

154

m_GroupIdToVariableSynchronizationGroupMap;

157

m_GroupIdToVariableSynchronizationGroupMap;

155

std::map<QUuid, QUuid> m_VariableIdGroupIdMap;

158

std::map<QUuid, QUuid> m_VariableIdGroupIdMap;

156

std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;

159

std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;

157

160

158

std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;

161

std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;

159

std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;

162

std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;

160

163

161

VariableController *q;

164

VariableController *q;

162

};

165

};

163

166

164

167

165

VariableController::VariableController(QObject *parent)

168

VariableController::VariableController(QObject *parent)

166

: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}

169

: QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}

167

{

170

{

168

qCDebug(LOG_VariableController()) << tr("VariableController construction")

171

qCDebug(LOG_VariableController()) << tr("VariableController construction")

169

<< QThread::currentThread();

172

<< QThread::currentThread();

170

173

171

connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,

174

connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,

172

&VariableController::onAbortProgressRequested);

175

&VariableController::onAbortProgressRequested);

173

176

174

connect(impl->m_VariableAcquisitionWorker.get(),

177

connect(impl->m_VariableAcquisitionWorker.get(),

175

&VariableAcquisitionWorker::variableCanceledRequested, this,

178

&VariableAcquisitionWorker::variableCanceledRequested, this,

176

&VariableController::onAbortAcquisitionRequested);

179

&VariableController::onAbortAcquisitionRequested);

177

180

178

connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,

181

connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,

179

&VariableController::onDataProvided);

182

&VariableController::onDataProvided);

180

connect(impl->m_VariableAcquisitionWorker.get(),

183

connect(impl->m_VariableAcquisitionWorker.get(),

181

&VariableAcquisitionWorker::variableRequestInProgress, this,

184

&VariableAcquisitionWorker::variableRequestInProgress, this,

182

&VariableController::onVariableRetrieveDataInProgress);

185

&VariableController::onVariableRetrieveDataInProgress);

183

186

184

187

185

connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,

188

connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,

186

impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);

189

impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);

187

connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,

190

connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,

188

impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);

191

impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);

189

192

190

connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,

193

connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,

191

&VariableController::onUpdateDateTime);

194

&VariableController::onUpdateDateTime);

192

195

193

impl->m_VariableAcquisitionWorkerThread.start();

196

impl->m_VariableAcquisitionWorkerThread.start();

194

}

197

}

195

198

196

VariableController::~VariableController()

199

VariableController::~VariableController()

197

{

200

{

198

qCDebug(LOG_VariableController()) << tr("VariableController destruction")

201

qCDebug(LOG_VariableController()) << tr("VariableController destruction")

199

<< QThread::currentThread();

202

<< QThread::currentThread();

200

this->waitForFinish();

203

this->waitForFinish();

201

}

204

}

202

205

203

VariableModel *VariableController::variableModel() noexcept

206

VariableModel *VariableController::variableModel() noexcept

204

{

207

{

205

return impl->m_VariableModel;

208

return impl->m_VariableModel;

206

}

209

}

207

210

208

QItemSelectionModel *VariableController::variableSelectionModel() noexcept

211

QItemSelectionModel *VariableController::variableSelectionModel() noexcept

209

{

212

{

210

return impl->m_VariableSelectionModel;

213

return impl->m_VariableSelectionModel;

211

}

214

}

212

215

213

void VariableController::setTimeController(TimeController *timeController) noexcept

216

void VariableController::setTimeController(TimeController *timeController) noexcept

214

{

217

{

215

impl->m_TimeController = timeController;

218

impl->m_TimeController = timeController;

216

}

219

}

217

220

218

std::shared_ptr<Variable>

221

std::shared_ptr<Variable>

219

VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept

222

VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept

220

{

223

{

221

if (impl->m_VariableModel->containsVariable(variable)) {

224

if (impl->m_VariableModel->containsVariable(variable)) {

222

// Clones variable

225

// Clones variable

223

auto duplicate = variable->clone();

226

auto duplicate = variable->clone();

224

227

225

// Adds clone to model

228

// Adds clone to model

226

impl->m_VariableModel->addVariable(duplicate);

229

impl->m_VariableModel->addVariable(duplicate);

227

230

228

// Generates clone identifier

231

// Generates clone identifier

229

impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();

232

impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();

230

233

231

// Registers provider

234

// Registers provider

232

auto variableProvider = impl->m_VariableToProviderMap.at(variable);

235

auto variableProvider = impl->m_VariableToProviderMap.at(variable);

233

auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;

236

auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;

234

237

235

impl->m_VariableToProviderMap[duplicate] = duplicateProvider;

238

impl->m_VariableToProviderMap[duplicate] = duplicateProvider;

236

if (duplicateProvider) {

239

if (duplicateProvider) {

237

impl->registerProvider(duplicateProvider);

240

impl->registerProvider(duplicateProvider);

238

}

241

}

239

242

240

return duplicate;

243

return duplicate;

241

}

244

}

242

else {

245

else {

243

qCCritical(LOG_VariableController())

246

qCCritical(LOG_VariableController())

244

<< tr("Can't create duplicate of variable %1: variable not registered in the model")

247

<< tr("Can't create duplicate of variable %1: variable not registered in the model")

245

.arg(variable->name());

248

.arg(variable->name());

246

return nullptr;

249

return nullptr;

247

}

250

}

248

}

251

}

249

252

250

void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept

253

void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept

251

{

254

{

252

if (!variable) {

255

if (!variable) {

253

qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";

256

qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";

254

return;

257

return;

255

}

258

}

256

259

257

// Spreads in SciQlop that the variable will be deleted, so that potential receivers can

260

// Spreads in SciQlop that the variable will be deleted, so that potential receivers can

258

// make some treatments before the deletion

261

// make some treatments before the deletion

259

emit variableAboutToBeDeleted(variable);

262

emit variableAboutToBeDeleted(variable);

260

263

264

auto variableIt = impl->m_VariableToIdentifierMap.find(variable);

265

Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());

266

267

auto variableId = variableIt->second;

268

269

// Removes variable's handler

270

impl->m_VarIdToVarRequestHandler.erase(variableId);

271

272

// Desynchronizes variable (if the variable is in a sync group)

273

auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);

274

if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {

275

impl->desynchronize(variableIt, syncGroupIt->second);

276

}

277

261

// Deletes identifier

278

// Deletes identifier

262

impl->m_VariableToIdentifierMap.erase(variable);

279

impl->m_VariableToIdentifierMap.erase(variableIt);

263

280

264

// Deletes provider

281

// Deletes provider

265

auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);

282

auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);

266

qCDebug(LOG_VariableController())

283

qCDebug(LOG_VariableController())

267

<< tr("Number of providers deleted for variable %1: %2")

284

<< tr("Number of providers deleted for variable %1: %2")

268

.arg(variable->name(), QString::number(nbProvidersDeleted));

285

.arg(variable->name(), QString::number(nbProvidersDeleted));

269

286

270

287

271

// Deletes from model

288

// Deletes from model

272

impl->m_VariableModel->deleteVariable(variable);

289

impl->m_VariableModel->deleteVariable(variable);

273

}

290

}

274

291

275

void VariableController::deleteVariables(

292

void VariableController::deleteVariables(

276

const QVector<std::shared_ptr<Variable> > &variables) noexcept

293

const QVector<std::shared_ptr<Variable> > &variables) noexcept

277

{

294

{

278

for (auto variable : qAsConst(variables)) {

295

for (auto variable : qAsConst(variables)) {

279

deleteVariable(variable);

296

deleteVariable(variable);

280

}

297

}

281

}

298

}

282

299

283

QByteArray

300

QByteArray

284

VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const

301

VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const

285

{

302

{

286

auto encodedData = QByteArray{};

303

auto encodedData = QByteArray{};

287

304

288

QVariantList ids;

305

QVariantList ids;

289

for (auto &var : variables) {

306

for (auto &var : variables) {

290

auto itVar = impl->m_VariableToIdentifierMap.find(var);

307

auto itVar = impl->m_VariableToIdentifierMap.find(var);

291

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

308

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

292

qCCritical(LOG_VariableController())

309

qCCritical(LOG_VariableController())

293

<< tr("Impossible to find the data for an unknown variable.");

310

<< tr("Impossible to find the data for an unknown variable.");

294

}

311

}

295

312

296

ids << itVar->second.toByteArray();

313

ids << itVar->second.toByteArray();

297

}

314

}

298

315

299

QDataStream stream{&encodedData, QIODevice::WriteOnly};

316

QDataStream stream{&encodedData, QIODevice::WriteOnly};

300

stream << ids;

317

stream << ids;

301

318

302

return encodedData;

319

return encodedData;

303

}

320

}

304

321

305

QList<std::shared_ptr<Variable> >

322

QList<std::shared_ptr<Variable> >

306

VariableController::variablesForMimeData(const QByteArray &mimeData) const

323

VariableController::variablesForMimeData(const QByteArray &mimeData) const

307

{

324

{

308

auto variables = QList<std::shared_ptr<Variable> >{};

325

auto variables = QList<std::shared_ptr<Variable> >{};

309

QDataStream stream{mimeData};

326

QDataStream stream{mimeData};

310

327

311

QVariantList ids;

328

QVariantList ids;

312

stream >> ids;

329

stream >> ids;

313

330

314

for (auto id : ids) {

331

for (auto id : ids) {

315

auto uuid = QUuid{id.toByteArray()};

332

auto uuid = QUuid{id.toByteArray()};

316

auto var = impl->findVariable(uuid);

333

auto var = impl->findVariable(uuid);

317

variables << var;

334

variables << var;

318

}

335

}

319

336

320

return variables;

337

return variables;

321

}

338

}

322

339

323

std::shared_ptr<Variable>

340

std::shared_ptr<Variable>

324

VariableController::createVariable(const QString &name, const QVariantHash &metadata,

341

VariableController::createVariable(const QString &name, const QVariantHash &metadata,

325

std::shared_ptr<IDataProvider> provider) noexcept

342

std::shared_ptr<IDataProvider> provider) noexcept

326

{

343

{

327

if (!impl->m_TimeController) {

344

if (!impl->m_TimeController) {

328

qCCritical(LOG_VariableController())

345

qCCritical(LOG_VariableController())

329

<< tr("Impossible to create variable: The time controller is null");

346

<< tr("Impossible to create variable: The time controller is null");

330

return nullptr;

347

return nullptr;

331

}

348

}

332

349

333

auto range = impl->m_TimeController->dateTime();

350

auto range = impl->m_TimeController->dateTime();

334

351

335

if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {

352

if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {

336

auto varId = QUuid::createUuid();

353

auto varId = QUuid::createUuid();

337

354

338

// Create the handler

355

// Create the handler

339

auto varRequestHandler = std::make_unique<VariableRequestHandler>();

356

auto varRequestHandler = std::make_unique<VariableRequestHandler>();

340

varRequestHandler->m_VarId = varId;

357

varRequestHandler->m_VarId = varId;

341

358

342

impl->m_VarIdToVarRequestHandler.insert(

359

impl->m_VarIdToVarRequestHandler.insert(

343

std::make_pair(varId, std::move(varRequestHandler)));

360

std::make_pair(varId, std::move(varRequestHandler)));

344

361

345

// store the provider

362

// store the provider

346

impl->registerProvider(provider);

363

impl->registerProvider(provider);

347

364

348

// Associate the provider

365

// Associate the provider

349

impl->m_VariableToProviderMap[newVariable] = provider;

366

impl->m_VariableToProviderMap[newVariable] = provider;

350

impl->m_VariableToIdentifierMap[newVariable] = varId;

367

impl->m_VariableToIdentifierMap[newVariable] = varId;

351

368

352

this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);

369

this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);

353

370

354

// auto varRequestId = QUuid::createUuid();

371

// auto varRequestId = QUuid::createUuid();

355

// qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;

372

// qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;

356

// impl->processRequest(newVariable, range, varRequestId);

373

// impl->processRequest(newVariable, range, varRequestId);

357

// impl->updateVariableRequest(varRequestId);

374

// impl->updateVariableRequest(varRequestId);

358

375

359

return newVariable;

376

return newVariable;

360

}

377

}

361

378

362

qCCritical(LOG_VariableController()) << tr("Impossible to create variable");

379

qCCritical(LOG_VariableController()) << tr("Impossible to create variable");

363

return nullptr;

380

return nullptr;

364

}

381

}

365

382

366

void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)

383

void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)

367

{

384

{

368

// NOTE: Even if acquisition request is aborting, the graphe range will be changed

385

// NOTE: Even if acquisition request is aborting, the graphe range will be changed

369

qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"

386

qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"

370

<< QThread::currentThread()->objectName();

387

<< QThread::currentThread()->objectName();

371

auto selectedRows = impl->m_VariableSelectionModel->selectedRows();

388

auto selectedRows = impl->m_VariableSelectionModel->selectedRows();

372

389

373

// NOTE we only permit the time modification for one variable

390

// NOTE we only permit the time modification for one variable

374

// DEPRECATED

391

// DEPRECATED

375

// auto variables = QVector<std::shared_ptr<Variable> >{};

392

// auto variables = QVector<std::shared_ptr<Variable> >{};

376

// for (const auto &selectedRow : qAsConst(selectedRows)) {

393

// for (const auto &selectedRow : qAsConst(selectedRows)) {

377

// if (auto selectedVariable =

394

// if (auto selectedVariable =

378

// impl->m_VariableModel->variable(selectedRow.row())) {

395

// impl->m_VariableModel->variable(selectedRow.row())) {

379

// variables << selectedVariable;

396

// variables << selectedVariable;

380

397

381

// // notify that rescale operation has to be done

398

// // notify that rescale operation has to be done

382

// emit rangeChanged(selectedVariable, dateTime);

399

// emit rangeChanged(selectedVariable, dateTime);

383

// }

400

// }

384

// }

401

// }

385

// if (!variables.isEmpty()) {

402

// if (!variables.isEmpty()) {

386

// this->onRequestDataLoading(variables, dateTime, synchro);

403

// this->onRequestDataLoading(variables, dateTime, synchro);

387

// }

404

// }

388

if (selectedRows.size() == 1) {

405

if (selectedRows.size() == 1) {

389

406

390

if (auto selectedVariable

407

if (auto selectedVariable

391

= impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {

408

= impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {

392

409

393

onUpdateDateTime(selectedVariable, dateTime);

410

onUpdateDateTime(selectedVariable, dateTime);

394

}

411

}

395

}

412

}

396

else if (selectedRows.size() > 1) {

413

else if (selectedRows.size() > 1) {

397

qCCritical(LOG_VariableController())

414

qCCritical(LOG_VariableController())

398

<< tr("Impossible to set time for more than 1 variable in the same time");

415

<< tr("Impossible to set time for more than 1 variable in the same time");

399

}

416

}

400

else {

417

else {

401

qCWarning(LOG_VariableController())

418

qCWarning(LOG_VariableController())

402

<< tr("There is no variable selected to set the time one");

419

<< tr("There is no variable selected to set the time one");

403

}

420

}

404

}

421

}

405

422

406

void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,

423

void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,

407

const SqpRange &dateTime)

424

const SqpRange &dateTime)

408

{

425

{

409

auto itVar = impl->m_VariableToIdentifierMap.find(variable);

426

auto itVar = impl->m_VariableToIdentifierMap.find(variable);

410

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

427

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

411

qCCritical(LOG_VariableController())

428

qCCritical(LOG_VariableController())

412

<< tr("Impossible to onDateTimeOnSelection request for unknown variable");

429

<< tr("Impossible to onDateTimeOnSelection request for unknown variable");

413

return;

430

return;

414

}

431

}

415

432

416

// notify that rescale operation has to be done

433

// notify that rescale operation has to be done

417

emit rangeChanged(variable, dateTime);

434

emit rangeChanged(variable, dateTime);

418

435

419

auto synchro

436

auto synchro

420

= impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();

437

= impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();

421

438

422

this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);

439

this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);

423

}

440

}

424

441

425

void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,

442

void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,

426

const SqpRange &cacheRangeRequested,

443

const SqpRange &cacheRangeRequested,

427

QVector<AcquisitionDataPacket> dataAcquired)

444

QVector<AcquisitionDataPacket> dataAcquired)

428

{

445

{

429

qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();

446

qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();

430

auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);

447

auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);

431

auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);

448

auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);

432

if (!varRequestId.isNull()) {

449

if (!varRequestId.isNull()) {

433

impl->updateVariables(varRequestId);

450

impl->updateVariables(varRequestId);

434

}

451

}

435

}

452

}

436

453

437

void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)

454

void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)

438

{

455

{

439

qCDebug(LOG_VariableController())

456

qCDebug(LOG_VariableController())

440

<< "TORM: variableController::onVariableRetrieveDataInProgress"

457

<< "TORM: variableController::onVariableRetrieveDataInProgress"

441

<< QThread::currentThread()->objectName() << progress;

458

<< QThread::currentThread()->objectName() << progress;

442

if (auto var = impl->findVariable(identifier)) {

459

if (auto var = impl->findVariable(identifier)) {

443

impl->m_VariableModel->setDataProgress(var, progress);

460

impl->m_VariableModel->setDataProgress(var, progress);

444

}

461

}

445

else {

462

else {

446

qCCritical(LOG_VariableController())

463

qCCritical(LOG_VariableController())

447

<< tr("Impossible to notify progression of a null variable");

464

<< tr("Impossible to notify progression of a null variable");

448

}

465

}

449

}

466

}

450

467

451

void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)

468

void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)

452

{

469

{

453

qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"

470

qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"

454

<< QThread::currentThread()->objectName() << variable->name();

471

<< QThread::currentThread()->objectName() << variable->name();

455

472

456

auto itVar = impl->m_VariableToIdentifierMap.find(variable);

473

auto itVar = impl->m_VariableToIdentifierMap.find(variable);

457

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

474

if (itVar == impl->m_VariableToIdentifierMap.cend()) {

458

qCCritical(LOG_VariableController())

475

qCCritical(LOG_VariableController())

459

<< tr("Impossible to onAbortProgressRequested request for unknown variable");

476

<< tr("Impossible to onAbortProgressRequested request for unknown variable");

460

return;

477

return;

461

}

478

}

462

479

463

auto varId = itVar->second;

480

auto varId = itVar->second;

464

481

465

auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);

482

auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);

466

if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {

483

if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {

467

qCCritical(LOG_VariableController())

484

qCCritical(LOG_VariableController())

468

<< tr("Impossible to onAbortProgressRequested for variable with unknown handler");

485

<< tr("Impossible to onAbortProgressRequested for variable with unknown handler");

469

return;

486

return;

470

}

487

}

471

488

472

auto varHandler = itVarHandler->second.get();

489

auto varHandler = itVarHandler->second.get();

473

490

474

// case where a variable has a running request

491

// case where a variable has a running request

475

if (varHandler->m_State != VariableRequestHandlerState::OFF) {

492

if (varHandler->m_State != VariableRequestHandlerState::OFF) {

476

impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);

493

impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);

477

}

494

}

478

}

495

}

479

496

480

void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)

497

void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)

481

{

498

{

482

qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"

499

qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"

483

<< QThread::currentThread()->objectName() << vIdentifier;

500

<< QThread::currentThread()->objectName() << vIdentifier;

484

501

485

if (auto var = impl->findVariable(vIdentifier)) {

502

if (auto var = impl->findVariable(vIdentifier)) {

486

this->onAbortProgressRequested(var);

503

this->onAbortProgressRequested(var);

487

}

504

}

488

else {

505

else {

489

qCCritical(LOG_VariableController())

506

qCCritical(LOG_VariableController())

490

<< tr("Impossible to abort Acquisition Requestof a null variable");

507

<< tr("Impossible to abort Acquisition Requestof a null variable");

491

}

508

}

492

}

509

}

493

510

494

void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)

511

void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)

495

{

512

{

496

qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"

513

qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"

497

<< QThread::currentThread()->objectName()

514

<< QThread::currentThread()->objectName()

498

<< synchronizationGroupId;

515

<< synchronizationGroupId;

499

auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();

516

auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();

500

impl->m_GroupIdToVariableSynchronizationGroupMap.insert(

517

impl->m_GroupIdToVariableSynchronizationGroupMap.insert(

501

std::make_pair(synchronizationGroupId, vSynchroGroup));

518

std::make_pair(synchronizationGroupId, vSynchroGroup));

502

}

519

}

503

520

504

void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)

521

void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)

505

{

522

{

506

impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);

523

impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);

507

}

524

}

508

525

509

void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,

526

void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,

510

QUuid synchronizationGroupId)

527

QUuid synchronizationGroupId)

511

528

512

{

529

{

513

qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"

530

qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"

514

<< synchronizationGroupId;

531

<< synchronizationGroupId;

515

auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);

532

auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);

516

if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {

533

if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {

517

auto groupIdToVSGIt

534

auto groupIdToVSGIt

518

= impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);

535

= impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);

519

if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {

536

if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {

520

impl->m_VariableIdGroupIdMap.insert(

537

impl->m_VariableIdGroupIdMap.insert(

521

std::make_pair(varToVarIdIt->second, synchronizationGroupId));

538

std::make_pair(varToVarIdIt->second, synchronizationGroupId));

522

groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);

539

groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);

523

}

540

}

524

else {

541

else {

525

qCCritical(LOG_VariableController())

542

qCCritical(LOG_VariableController())

526

<< tr("Impossible to synchronize a variable with an unknown sycnhronization group")

543

<< tr("Impossible to synchronize a variable with an unknown sycnhronization group")

527

<< variable->name();

544

<< variable->name();

528

}

545

}

529

}

546

}

530

else {

547

else {

531

qCCritical(LOG_VariableController())

548

qCCritical(LOG_VariableController())

532

<< tr("Impossible to synchronize a variable with no identifier") << variable->name();

549

<< tr("Impossible to synchronize a variable with no identifier") << variable->name();

533

}

550

}

534

}

551

}

535

552

536

void VariableController::desynchronize(std::shared_ptr<Variable> variable,

553

void VariableController::desynchronize(std::shared_ptr<Variable> variable,

537

QUuid synchronizationGroupId)

554

QUuid synchronizationGroupId)

538

{

555

{

539

// Gets variable id

556

// Gets variable id

540

auto variableIt = impl->m_VariableToIdentifierMap.find(variable);

557

auto variableIt = impl->m_VariableToIdentifierMap.find(variable);

541

if (variableIt == impl->m_VariableToIdentifierMap.cend()) {

558

if (variableIt == impl->m_VariableToIdentifierMap.cend()) {

542

qCCritical(LOG_VariableController())

559

qCCritical(LOG_VariableController())

543

<< tr("Can't desynchronize variable %1: variable identifier not found")

560

<< tr("Can't desynchronize variable %1: variable identifier not found")

544

.arg(variable->name());

561

.arg(variable->name());

545

return;

562

return;

546

}

563

}

547

564

548

// Gets synchronization group

565

impl->desynchronize(variableIt, synchronizationGroupId);

549

auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);

550

if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {

551

qCCritical(LOG_VariableController())

552

<< tr("Can't desynchronize variable %1: unknown synchronization group")

553

.arg(variable->name());

554

return;

555

}

556

557

auto variableId = variableIt->second;

558

559

// Removes variable from synchronization group

560

auto synchronizationGroup = groupIt->second;

561

synchronizationGroup->removeVariableId(variableId);

562

563

// Removes link between variable and synchronization group

564

impl->m_VariableIdGroupIdMap.erase(variableId);

565

}

566

}

566

567

void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,

568

void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,

568

const SqpRange &range, bool synchronise)

569

const SqpRange &range, bool synchronise)

569

{

570

{

570

// variables is assumed synchronized

571

// variables is assumed synchronized

571

// TODO: Asser variables synchronization

572

// TODO: Asser variables synchronization

572

// we want to load data of the variable for the dateTime.

573

// we want to load data of the variable for the dateTime.

573

if (variables.isEmpty()) {

574

if (variables.isEmpty()) {

574

return;

575

return;

575

}

576

}

576

577

auto varRequestId = QUuid::createUuid();

578

auto varRequestId = QUuid::createUuid();

578

qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"

579

qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"

579

<< QThread::currentThread()->objectName() << varRequestId

580

<< QThread::currentThread()->objectName() << varRequestId

580

<< range << synchronise;

581

<< range << synchronise;

581

582

if (!synchronise) {

583

if (!synchronise) {

583

auto varIds = std::list<QUuid>{};

584

auto varIds = std::list<QUuid>{};

584

for (const auto &var : variables) {

585

for (const auto &var : variables) {

585

auto vId = impl->m_VariableToIdentifierMap.at(var);

586

auto vId = impl->m_VariableToIdentifierMap.at(var);

586

varIds.push_back(vId);

587

varIds.push_back(vId);

587

}

588

}

588

impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));

589

impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));

589

for (const auto &var : variables) {

590

for (const auto &var : variables) {

590

qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId

591

qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId

591

<< varIds.size();

592

<< varIds.size();

592

impl->processRequest(var, range, varRequestId);

593

impl->processRequest(var, range, varRequestId);

593

}

594

}

594

}

595

}

595

else {

596

else {

596

auto vId = impl->m_VariableToIdentifierMap.at(variables.first());

597

auto vId = impl->m_VariableToIdentifierMap.at(variables.first());

597

auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);

598

auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);

598

if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {

599

if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {

599

auto groupId = varIdToGroupIdIt->second;

600

auto groupId = varIdToGroupIdIt->second;

600

601

auto vSynchronizationGroup

602

auto vSynchronizationGroup

602

= impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);

603

= impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);

603

auto vSyncIds = vSynchronizationGroup->getIds();

604

auto vSyncIds = vSynchronizationGroup->getIds();

604

605

auto varIds = std::list<QUuid>{};

606

auto varIds = std::list<QUuid>{};

606

for (auto vId : vSyncIds) {

607

for (auto vId : vSyncIds) {

607

varIds.push_back(vId);

608

varIds.push_back(vId);

608

}

609

}

609

impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));

610

impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));

610

611

for (auto vId : vSyncIds) {

612

for (auto vId : vSyncIds) {

612

auto var = impl->findVariable(vId);

613

auto var = impl->findVariable(vId);

613

614

// Don't process already processed var

615

// Don't process already processed var

615

if (var != nullptr) {

616

if (var != nullptr) {

616

qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()

617

qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()

617

<< varRequestId;

618

<< varRequestId;

618

auto vSyncRangeRequested

619

auto vSyncRangeRequested

619

= variables.contains(var)

620

= variables.contains(var)

620

? range

621

? range

621

: computeSynchroRangeRequested(var->range(), range,

622

: computeSynchroRangeRequested(var->range(), range,

622

variables.first()->range());

623

variables.first()->range());

623

qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;

624

qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;

624

impl->processRequest(var, vSyncRangeRequested, varRequestId);

625

impl->processRequest(var, vSyncRangeRequested, varRequestId);

625

}

626

}

626

else {

627

else {

627

qCCritical(LOG_VariableController())

628

qCCritical(LOG_VariableController())

628

629

<< tr("Impossible to synchronize a null variable");

630

<< tr("Impossible to synchronize a null variable");

630

}

631

}

631

}

632

}

632

}

633

}

633

}

634

}

634

635

impl->updateVariables(varRequestId);

636

impl->updateVariables(varRequestId);

636

}

637

}

637

638

639

void VariableController::initialize()

640

void VariableController::initialize()

640

{

641

{

641

qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();

642

qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();

642

impl->m_WorkingMutex.lock();

643

impl->m_WorkingMutex.lock();

643

qCDebug(LOG_VariableController()) << tr("VariableController init END");

644

qCDebug(LOG_VariableController()) << tr("VariableController init END");

644

}

645

}

645

646

void VariableController::finalize()

647

void VariableController::finalize()

647

{

648

{

648

impl->m_WorkingMutex.unlock();

649

impl->m_WorkingMutex.unlock();

649

}

650

}

650

651

void VariableController::waitForFinish()

652

void VariableController::waitForFinish()

652

{

653

{

653

QMutexLocker locker{&impl->m_WorkingMutex};

654

QMutexLocker locker{&impl->m_WorkingMutex};

654

}

655

}

655

656

AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)

657

AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)

657

{

658

{

658

// t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd

659

// t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd

659

auto zoomType = AcquisitionZoomType::Unknown;

660

auto zoomType = AcquisitionZoomType::Unknown;

660

if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {

661

if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {

661

qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";

662

qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";

662

zoomType = AcquisitionZoomType::ZoomOut;

663

zoomType = AcquisitionZoomType::ZoomOut;

663

}

664

}

664

else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {

665

else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {

665

qCDebug(LOG_VariableController()) << "zoomtype: PanRight";

666

qCDebug(LOG_VariableController()) << "zoomtype: PanRight";

666

zoomType = AcquisitionZoomType::PanRight;

667

zoomType = AcquisitionZoomType::PanRight;

667

}

668

}

668

else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {

669

else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {

669

qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";

670

qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";

670

zoomType = AcquisitionZoomType::PanLeft;

671

zoomType = AcquisitionZoomType::PanLeft;

671

}

672

}

672

else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {

673

else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {

673

qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";

674

qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";

674

zoomType = AcquisitionZoomType::ZoomIn;

675

zoomType = AcquisitionZoomType::ZoomIn;

675

}

676

}

676

else {

677

else {

677

qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";

678

qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";

678

}

679

}

679

return zoomType;

680

return zoomType;

680

}

681

}

681

682

void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,

683

void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,

683

const SqpRange &rangeRequested,

684

const SqpRange &rangeRequested,

684

QUuid varRequestId)

685

QUuid varRequestId)

685

{

686

{

686

auto itVar = m_VariableToIdentifierMap.find(var);

687

auto itVar = m_VariableToIdentifierMap.find(var);

687

if (itVar == m_VariableToIdentifierMap.cend()) {

688

if (itVar == m_VariableToIdentifierMap.cend()) {

688

qCCritical(LOG_VariableController())

689

qCCritical(LOG_VariableController())

689

<< tr("Impossible to process request for unknown variable");

690

<< tr("Impossible to process request for unknown variable");

690

return;

691

return;

691

}

692

}

692

693

auto varId = itVar->second;

694

auto varId = itVar->second;

694

695

auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);

696

auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);

696

if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {

697

if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {

697

qCCritical(LOG_VariableController())

698

qCCritical(LOG_VariableController())

698

<< tr("Impossible to process request for variable with unknown handler");

699

<< tr("Impossible to process request for variable with unknown handler");

699

return;

700

return;

700

}

701

}

701

702

auto oldRange = var->range();

703

auto oldRange = var->range();

703

704

auto varHandler = itVarHandler->second.get();

705

auto varHandler = itVarHandler->second.get();

705

706

if (varHandler->m_State != VariableRequestHandlerState::OFF) {

707

if (varHandler->m_State != VariableRequestHandlerState::OFF) {

707

oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;

708

oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;

708

}

709

}

709

710

auto varRequest = VariableRequest{};

711

auto varRequest = VariableRequest{};

711

varRequest.m_VariableGroupId = varRequestId;

712

varRequest.m_VariableGroupId = varRequestId;

712

auto varStrategyRangesRequested

713

auto varStrategyRangesRequested

713

= m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);

714

= m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);

714

varRequest.m_RangeRequested = varStrategyRangesRequested.first;

715

varRequest.m_RangeRequested = varStrategyRangesRequested.first;

715

varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;

716

varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;

716

717

switch (varHandler->m_State) {

718

switch (varHandler->m_State) {

718

case VariableRequestHandlerState::OFF: {

719

case VariableRequestHandlerState::OFF: {

719

qCDebug(LOG_VariableController()) << tr("Process Request OFF")

720

qCDebug(LOG_VariableController()) << tr("Process Request OFF")

720

<< varRequest.m_RangeRequested

721

<< varRequest.m_RangeRequested

721

<< varRequest.m_CacheRangeRequested;

722

<< varRequest.m_CacheRangeRequested;

722

varHandler->m_RunningVarRequest = varRequest;

723

varHandler->m_RunningVarRequest = varRequest;

723

varHandler->m_State = VariableRequestHandlerState::RUNNING;

724

varHandler->m_State = VariableRequestHandlerState::RUNNING;

724

executeVarRequest(var, varRequest);

725

executeVarRequest(var, varRequest);

725

break;

726

break;

726

}

727

}

727

case VariableRequestHandlerState::RUNNING: {

728

case VariableRequestHandlerState::RUNNING: {

728

qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")

729

qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")

729

<< varRequest.m_RangeRequested

730

<< varRequest.m_RangeRequested

730

<< varRequest.m_CacheRangeRequested;

731

<< varRequest.m_CacheRangeRequested;

731

varHandler->m_State = VariableRequestHandlerState::PENDING;

732

varHandler->m_State = VariableRequestHandlerState::PENDING;

732

varHandler->m_PendingVarRequest = varRequest;

733

varHandler->m_PendingVarRequest = varRequest;

733

break;

734

break;

734

}

735

}

735

case VariableRequestHandlerState::PENDING: {

736

case VariableRequestHandlerState::PENDING: {

736

qCDebug(LOG_VariableController()) << tr("Process Request PENDING")

737

qCDebug(LOG_VariableController()) << tr("Process Request PENDING")

737

<< varRequest.m_RangeRequested

738

<< varRequest.m_RangeRequested

738

<< varRequest.m_CacheRangeRequested;

739

<< varRequest.m_CacheRangeRequested;

739

auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;

740

auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;

740

cancelVariableRequest(variableGroupIdToCancel);

741

cancelVariableRequest(variableGroupIdToCancel);

741

// Cancel variable can make state downgrade

742

// Cancel variable can make state downgrade

742

varHandler->m_State = VariableRequestHandlerState::PENDING;

743

varHandler->m_State = VariableRequestHandlerState::PENDING;

743

varHandler->m_PendingVarRequest = varRequest;

744

varHandler->m_PendingVarRequest = varRequest;

744

745

break;

746

break;

746

}

747

}

747

default:

748

default:

748

qCCritical(LOG_VariableController())

749

qCCritical(LOG_VariableController())

749

<< QObject::tr("Unknown VariableRequestHandlerState");

750

<< QObject::tr("Unknown VariableRequestHandlerState");

750

}

751

}

751

}

752

}

752

753

std::shared_ptr<Variable>

754

std::shared_ptr<Variable>

754

VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)

755

VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)

755

{

756

{

756

std::shared_ptr<Variable> var;

757

std::shared_ptr<Variable> var;

757

auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };

758

auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };

758

759

auto end = m_VariableToIdentifierMap.cend();

760

auto end = m_VariableToIdentifierMap.cend();

760

auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);

761

auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);

761

if (it != end) {

762

if (it != end) {

762

var = it->first;

763

var = it->first;

763

}

764

}

764

else {

765

else {

765

qCCritical(LOG_VariableController())

766

qCCritical(LOG_VariableController())

766

<< tr("Impossible to find the variable with the identifier: ") << vIdentifier;

767

<< tr("Impossible to find the variable with the identifier: ") << vIdentifier;

767

}

768

}

768

769

return var;

770

return var;

770

}

771

}

771

772

std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(

773

std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(

773

const QVector<AcquisitionDataPacket> acqDataPacketVector)

774

const QVector<AcquisitionDataPacket> acqDataPacketVector)

774

{

775

{

775

qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")

776

qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")

776

<< acqDataPacketVector.size();

777

<< acqDataPacketVector.size();

777

std::shared_ptr<IDataSeries> dataSeries;

778

std::shared_ptr<IDataSeries> dataSeries;

778

if (!acqDataPacketVector.isEmpty()) {

779

if (!acqDataPacketVector.isEmpty()) {

779

dataSeries = acqDataPacketVector[0].m_DateSeries;

780

dataSeries = acqDataPacketVector[0].m_DateSeries;

780

for (int i = 1; i < acqDataPacketVector.size(); ++i) {

781

for (int i = 1; i < acqDataPacketVector.size(); ++i) {

781

dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());

782

dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());

782

}

783

}

783

}

784

}

784

qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")

785

qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")

785

<< acqDataPacketVector.size();

786

<< acqDataPacketVector.size();

786

return dataSeries;

787

return dataSeries;

787

}

788

}

788

789

void VariableController::VariableControllerPrivate::registerProvider(

790

void VariableController::VariableControllerPrivate::registerProvider(

790

std::shared_ptr<IDataProvider> provider)

791

std::shared_ptr<IDataProvider> provider)

791

{

792

{

792

if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {

793

if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {

793

qCDebug(LOG_VariableController()) << tr("Registering of a new provider")

794

qCDebug(LOG_VariableController()) << tr("Registering of a new provider")

794

<< provider->objectName();

795

<< provider->objectName();

795

m_ProviderSet.insert(provider);

796

m_ProviderSet.insert(provider);

796

connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),

797

connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),

797

&VariableAcquisitionWorker::onVariableDataAcquired);

798

&VariableAcquisitionWorker::onVariableDataAcquired);

798

connect(provider.get(), &IDataProvider::dataProvidedProgress,

799

connect(provider.get(), &IDataProvider::dataProvidedProgress,

799

m_VariableAcquisitionWorker.get(),

800

m_VariableAcquisitionWorker.get(),

800

&VariableAcquisitionWorker::onVariableRetrieveDataInProgress);

801

&VariableAcquisitionWorker::onVariableRetrieveDataInProgress);

801

connect(provider.get(), &IDataProvider::dataProvidedFailed,

802

connect(provider.get(), &IDataProvider::dataProvidedFailed,

802

m_VariableAcquisitionWorker.get(),

803

m_VariableAcquisitionWorker.get(),

803

&VariableAcquisitionWorker::onVariableAcquisitionFailed);

804

&VariableAcquisitionWorker::onVariableAcquisitionFailed);

804

}

805

}

805

else {

806

else {

806

qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");

807

qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");

807

}

808

}

808

}

809

}

809

810

QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(

811

QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(

811

QUuid varId, std::shared_ptr<IDataSeries> dataSeries)

812

QUuid varId, std::shared_ptr<IDataSeries> dataSeries)

812

{

813

{

813

auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);

814

auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);

814

if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {

815

if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {

815

return QUuid();

816

return QUuid();

816

}

817

}

817

818

auto varHandler = itVarHandler->second.get();

819

auto varHandler = itVarHandler->second.get();

819

if (varHandler->m_State == VariableRequestHandlerState::OFF) {

820

if (varHandler->m_State == VariableRequestHandlerState::OFF) {

820

qCCritical(LOG_VariableController())

821

qCCritical(LOG_VariableController())

821

<< tr("acceptVariableRequest impossible on a variable with OFF state");

822

<< tr("acceptVariableRequest impossible on a variable with OFF state");

822

}

823

}

823

824

varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;

825

varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;

825

varHandler->m_CanUpdate = true;

826

varHandler->m_CanUpdate = true;

826

827

// Element traité, on a déjà toutes les données necessaires

828

// Element traité, on a déjà toutes les données necessaires

828

auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;

829

auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;

829

qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId

830

qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId

830

<< m_VarGroupIdToVarIds.size();

831

<< m_VarGroupIdToVarIds.size();

831

832

return varHandler->m_RunningVarRequest.m_VariableGroupId;

833

return varHandler->m_RunningVarRequest.m_VariableGroupId;

833

}

834

}

834

835

void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)

836

void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)

836

{

837

{

837

qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"

838

qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"

838

<< QThread::currentThread()->objectName() << varRequestId;

839

<< QThread::currentThread()->objectName() << varRequestId;

839

840

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

841

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

841

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

842

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

842

qCWarning(LOG_VariableController())

843

qCWarning(LOG_VariableController())

843

<< tr("Impossible to updateVariables of unknown variables") << varRequestId;

844

<< tr("Impossible to updateVariables of unknown variables") << varRequestId;

844

return;

845

return;

845

}

846

}

846

847

auto &varIds = varGroupIdToVarIdsIt->second;

848

auto &varIds = varGroupIdToVarIdsIt->second;

848

auto varIdsEnd = varIds.end();

849

auto varIdsEnd = varIds.end();

849

bool processVariableUpdate = true;

850

bool processVariableUpdate = true;

850

qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"

851

qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"

851

<< varRequestId << varIds.size();

852

<< varRequestId << varIds.size();

852

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;

853

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;

853

++varIdsIt) {

854

++varIdsIt) {

854

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

855

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

855

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

856

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

856

processVariableUpdate &= itVarHandler->second->m_CanUpdate;

857

processVariableUpdate &= itVarHandler->second->m_CanUpdate;

857

}

858

}

858

}

859

}

859

860

if (processVariableUpdate) {

861

if (processVariableUpdate) {

861

qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();

862

qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();

862

for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {

863

for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {

863

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

864

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

864

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

865

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

865

if (auto var = findVariable(*varIdsIt)) {

866

if (auto var = findVariable(*varIdsIt)) {

866

auto &varRequest = itVarHandler->second->m_RunningVarRequest;

867

auto &varRequest = itVarHandler->second->m_RunningVarRequest;

867

var->setRange(varRequest.m_RangeRequested);

868

var->setRange(varRequest.m_RangeRequested);

868

var->setCacheRange(varRequest.m_CacheRangeRequested);

869

var->setCacheRange(varRequest.m_CacheRangeRequested);

869

qCDebug(LOG_VariableController()) << tr("1: onDataProvided")

870

qCDebug(LOG_VariableController()) << tr("1: onDataProvided")

870

<< varRequest.m_RangeRequested

871

<< varRequest.m_RangeRequested

871

<< varRequest.m_CacheRangeRequested;

872

<< varRequest.m_CacheRangeRequested;

872

qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")

873

qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")

873

<< var->nbPoints()

874

<< var->nbPoints()

874

<< varRequest.m_DataSeries->nbPoints();

875

<< varRequest.m_DataSeries->nbPoints();

875

var->mergeDataSeries(varRequest.m_DataSeries);

876

var->mergeDataSeries(varRequest.m_DataSeries);

876

qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")

877

qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")

877

<< var->nbPoints();

878

<< var->nbPoints();

878

879

emit var->updated();

880

emit var->updated();

880

qCDebug(LOG_VariableController()) << tr("Update OK");

881

qCDebug(LOG_VariableController()) << tr("Update OK");

881

}

882

}

882

else {

883

else {

883

qCCritical(LOG_VariableController())

884

qCCritical(LOG_VariableController())

884

<< tr("Impossible to update data to a null variable");

885

<< tr("Impossible to update data to a null variable");

885

}

886

}

886

}

887

}

887

}

888

}

888

updateVariableRequest(varRequestId);

889

updateVariableRequest(varRequestId);

889

890

// cleaning varRequestId

891

// cleaning varRequestId

891

qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;

892

qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;

892

m_VarGroupIdToVarIds.erase(varRequestId);

893

m_VarGroupIdToVarIds.erase(varRequestId);

893

if (m_VarGroupIdToVarIds.empty()) {

894

if (m_VarGroupIdToVarIds.empty()) {

894

emit q->acquisitionFinished();

895

emit q->acquisitionFinished();

895

}

896

}

896

}

897

}

897

}

898

}

898

899

900

void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)

901

void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)

901

{

902

{

902

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

903

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

903

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

904

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

904

qCCritical(LOG_VariableController()) << QObject::tr(

905

qCCritical(LOG_VariableController()) << QObject::tr(

905

"Impossible to updateVariableRequest since varGroupdId isn't here anymore");

906

"Impossible to updateVariableRequest since varGroupdId isn't here anymore");

906

907

return;

908

return;

908

}

909

}

909

910

auto &varIds = varGroupIdToVarIdsIt->second;

911

auto &varIds = varGroupIdToVarIdsIt->second;

911

auto varIdsEnd = varIds.end();

912

auto varIdsEnd = varIds.end();

912

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {

913

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {

913

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

914

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

914

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

915

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

915

916

auto varHandler = itVarHandler->second.get();

917

auto varHandler = itVarHandler->second.get();

917

varHandler->m_CanUpdate = false;

918

varHandler->m_CanUpdate = false;

918

919

920

switch (varHandler->m_State) {

921

switch (varHandler->m_State) {

921

case VariableRequestHandlerState::OFF: {

922

case VariableRequestHandlerState::OFF: {

922

qCCritical(LOG_VariableController())

923

qCCritical(LOG_VariableController())

923

<< QObject::tr("Impossible to update a variable with handler in OFF state");

924

<< QObject::tr("Impossible to update a variable with handler in OFF state");

924

} break;

925

} break;

925

case VariableRequestHandlerState::RUNNING: {

926

case VariableRequestHandlerState::RUNNING: {

926

varHandler->m_State = VariableRequestHandlerState::OFF;

927

varHandler->m_State = VariableRequestHandlerState::OFF;

927

varHandler->m_RunningVarRequest = VariableRequest{};

928

varHandler->m_RunningVarRequest = VariableRequest{};

928

break;

929

break;

929

}

930

}

930

case VariableRequestHandlerState::PENDING: {

931

case VariableRequestHandlerState::PENDING: {

931

varHandler->m_State = VariableRequestHandlerState::RUNNING;

932

varHandler->m_State = VariableRequestHandlerState::RUNNING;

932

varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;

933

varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;

933

varHandler->m_PendingVarRequest = VariableRequest{};

934

varHandler->m_PendingVarRequest = VariableRequest{};

934

auto var = findVariable(itVarHandler->first);

935

auto var = findVariable(itVarHandler->first);

935

executeVarRequest(var, varHandler->m_RunningVarRequest);

936

executeVarRequest(var, varHandler->m_RunningVarRequest);

936

updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);

937

updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);

937

break;

938

break;

938

}

939

}

939

default:

940

default:

940

qCCritical(LOG_VariableController())

941

qCCritical(LOG_VariableController())

941

<< QObject::tr("Unknown VariableRequestHandlerState");

942

<< QObject::tr("Unknown VariableRequestHandlerState");

942

}

943

}

943

}

944

}

944

}

945

}

945

}

946

}

946

947

948

void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)

949

void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)

949

{

950

{

950

qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;

951

qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;

951

952

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

953

auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);

953

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

954

if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {

954

qCCritical(LOG_VariableController())

955

qCCritical(LOG_VariableController())

955

<< tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;

956

<< tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;

956

return;

957

return;

957

}

958

}

958

959

auto &varIds = varGroupIdToVarIdsIt->second;

960

auto &varIds = varGroupIdToVarIdsIt->second;

960

auto varIdsEnd = varIds.end();

961

auto varIdsEnd = varIds.end();

961

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {

962

for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {

962

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

963

auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);

963

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

964

if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {

964

965

auto varHandler = itVarHandler->second.get();

966

auto varHandler = itVarHandler->second.get();

966

varHandler->m_VarId = QUuid{};

967

varHandler->m_VarId = QUuid{};

967

switch (varHandler->m_State) {

968

switch (varHandler->m_State) {

968

case VariableRequestHandlerState::OFF: {

969

case VariableRequestHandlerState::OFF: {

969

qCWarning(LOG_VariableController())

970

qCWarning(LOG_VariableController())

970

<< QObject::tr("Impossible to cancel a variable with no running request");

971

<< QObject::tr("Impossible to cancel a variable with no running request");

971

break;

972

break;

972

}

973

}

973

case VariableRequestHandlerState::RUNNING: {

974

case VariableRequestHandlerState::RUNNING: {

974

975

if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {

976

if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {

976

auto var = findVariable(itVarHandler->first);

977

auto var = findVariable(itVarHandler->first);

977

auto varProvider = m_VariableToProviderMap.at(var);

978

auto varProvider = m_VariableToProviderMap.at(var);

978

if (varProvider != nullptr) {

979

if (varProvider != nullptr) {

979

m_VariableAcquisitionWorker->abortProgressRequested(

980

m_VariableAcquisitionWorker->abortProgressRequested(

980

itVarHandler->first);

981

itVarHandler->first);

981

}

982

}

982

m_VariableModel->setDataProgress(var, 0.0);

983

m_VariableModel->setDataProgress(var, 0.0);

983

varHandler->m_CanUpdate = false;

984

varHandler->m_CanUpdate = false;

984

varHandler->m_State = VariableRequestHandlerState::OFF;

985

varHandler->m_State = VariableRequestHandlerState::OFF;

985

varHandler->m_RunningVarRequest = VariableRequest{};

986

varHandler->m_RunningVarRequest = VariableRequest{};

986

}

987

}

987

else {

988

else {

988

// TODO: log Impossible to cancel the running variable request beacause its

989

// TODO: log Impossible to cancel the running variable request beacause its

989

// varRequestId isn't not the canceled one

990

// varRequestId isn't not the canceled one

990

}

991

}

991

break;

992

break;

992

}

993

}

993

case VariableRequestHandlerState::PENDING: {

994

case VariableRequestHandlerState::PENDING: {

994

if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {

995

if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {

995

auto var = findVariable(itVarHandler->first);

996

auto var = findVariable(itVarHandler->first);

996

auto varProvider = m_VariableToProviderMap.at(var);

997

auto varProvider = m_VariableToProviderMap.at(var);

997

if (varProvider != nullptr) {

998

if (varProvider != nullptr) {

998

m_VariableAcquisitionWorker->abortProgressRequested(

999

m_VariableAcquisitionWorker->abortProgressRequested(

999

itVarHandler->first);

1000

itVarHandler->first);

1000

}

1001

}

1001

m_VariableModel->setDataProgress(var, 0.0);

1002

m_VariableModel->setDataProgress(var, 0.0);

1002

varHandler->m_CanUpdate = false;

1003

varHandler->m_CanUpdate = false;

1003

varHandler->m_State = VariableRequestHandlerState::RUNNING;

1004

varHandler->m_State = VariableRequestHandlerState::RUNNING;

1004

varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;

1005

varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;

1005

varHandler->m_PendingVarRequest = VariableRequest{};

1006

varHandler->m_PendingVarRequest = VariableRequest{};

1006

executeVarRequest(var, varHandler->m_RunningVarRequest);

1007

executeVarRequest(var, varHandler->m_RunningVarRequest);

1007

}

1008

}

1008

else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {

1009

else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {

1009

varHandler->m_State = VariableRequestHandlerState::RUNNING;

1010

varHandler->m_State = VariableRequestHandlerState::RUNNING;

1010

varHandler->m_PendingVarRequest = VariableRequest{};

1011

varHandler->m_PendingVarRequest = VariableRequest{};

1011

}

1012

}

1012

else {

1013

else {

1013

// TODO: log Impossible to cancel the variable request beacause its

1014

// TODO: log Impossible to cancel the variable request beacause its

1014

// varRequestId isn't not the canceled one

1015

// varRequestId isn't not the canceled one

1015

}

1016

}

1016

break;

1017

break;

1017

}

1018

}

1018

default:

1019

default:

1019

qCCritical(LOG_VariableController())

1020

qCCritical(LOG_VariableController())

1020

<< QObject::tr("Unknown VariableRequestHandlerState");

1021

<< QObject::tr("Unknown VariableRequestHandlerState");

1021

}

1022

}

1022

}

1023

}

1023

}

1024

}

1024

qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;

1025

qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;

1025

m_VarGroupIdToVarIds.erase(varRequestId);

1026

m_VarGroupIdToVarIds.erase(varRequestId);

1026

if (m_VarGroupIdToVarIds.empty()) {

1027

if (m_VarGroupIdToVarIds.empty()) {

1027

emit q->acquisitionFinished();

1028

emit q->acquisitionFinished();

1028

}

1029

}

1029

}

1030

}

1030

1031

void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,

1032

void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,

1032

VariableRequest &varRequest)

1033

VariableRequest &varRequest)

1033

{

1034

{

1034

qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");

1035

qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");

1035

1036

auto varId = m_VariableToIdentifierMap.at(var);

1037

auto varIdIt = m_VariableToIdentifierMap.find(var);

1038

if (varIdIt == m_VariableToIdentifierMap.cend()) {

1039

qCWarning(LOG_VariableController()) << tr(

1040

"Can't execute request of a variable that is not registered (may has been deleted)");

1041

return;

1042

}

1043

1044

auto varId = varIdIt->second;

1037

1045

1038

auto varCacheRange = var->cacheRange();

1046

auto varCacheRange = var->cacheRange();

1039

auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;

1047

auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;

1040

auto notInCacheRangeList

1048

auto notInCacheRangeList

1041

= Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);

1049

= Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);

1042

auto inCacheRangeList

1050

auto inCacheRangeList

1043

= Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);

1051

= Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);

1044

1052

1045

if (!notInCacheRangeList.empty()) {

1053

if (!notInCacheRangeList.empty()) {

1046

1054

1047

auto varProvider = m_VariableToProviderMap.at(var);

1055

auto varProvider = m_VariableToProviderMap.at(var);

1048

if (varProvider != nullptr) {

1056

if (varProvider != nullptr) {

1049

qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested

1057

qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested

1050

<< varRequest.m_CacheRangeRequested;

1058

<< varRequest.m_CacheRangeRequested;

1051

m_VariableAcquisitionWorker->pushVariableRequest(

1059

m_VariableAcquisitionWorker->pushVariableRequest(

1052

varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,

1060

varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,

1053

varRequest.m_CacheRangeRequested,

1061

varRequest.m_CacheRangeRequested,

1054

DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},

1062

DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},

1055

varProvider);

1063

varProvider);

1056

}

1064

}

1057

else {

1065

else {

1058

qCCritical(LOG_VariableController())

1066

qCCritical(LOG_VariableController())

1059

<< "Impossible to provide data with a null provider";

1067

<< "Impossible to provide data with a null provider";

1060

}

1068

}

1061

1069

1062

if (!inCacheRangeList.empty()) {

1070

if (!inCacheRangeList.empty()) {

1063

emit q->updateVarDisplaying(var, inCacheRangeList.first());

1071

emit q->updateVarDisplaying(var, inCacheRangeList.first());

1064

}

1072

}

1065

}

1073

}

1066

else {

1074

else {

1067

acceptVariableRequest(varId,

1075

acceptVariableRequest(varId,

1068

var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));

1076

var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));

1069

}

1077

}

1070

}

1078

}

1079

1080

template <typename VariableIterator>

1081

void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,

1082

const QUuid &syncGroupId)

1083

{

1084

const auto &variable = variableIt->first;

1085

const auto &variableId = variableIt->second;

1086

1087

// Gets synchronization group

1088

auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);

1089

if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {

1090

qCCritical(LOG_VariableController())

1091

<< tr("Can't desynchronize variable %1: unknown synchronization group")

1092

.arg(variable->name());

1093

return;

1094

}

1095

1096

// Removes variable from synchronization group

1097

auto synchronizationGroup = groupIt->second;

1098

synchronizationGroup->removeVariableId(variableId);

1099

1100

// Removes link between variable and synchronization group

1101

m_VariableIdGroupIdMap.erase(variableId);

1102

}

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableCacheStrategyFactory.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizationGroup.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QDataStream>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <deque>
             #include <set>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
                 auto varRangeRequested = varRange;
                 switch (zoomType) {
                     case AcquisitionZoomType::ZoomIn: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::ZoomOut: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
                         auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaLeft;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         varRangeRequested.m_TStart -= deltaLeft;
                         varRangeRequested.m_TEnd -= deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
                         qCCritical(LOG_VariableController())
                             << VariableController::tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController()) << VariableController::tr(
                             "Impossible to synchronize: zoom type not take into account");
                         // No action
                         break;
                 }
                 return varRangeRequested;
             }
             }
             enum class VariableRequestHandlerState { OFF, RUNNING, PENDING };
             struct VariableRequestHandler {
                 VariableRequestHandler()
                 {
                     m_CanUpdate = false;
                     m_State = VariableRequestHandlerState::OFF;
                 }
                 QUuid m_VarId;
                 VariableRequest m_RunningVarRequest;
                 VariableRequest m_PendingVarRequest;
                 VariableRequestHandlerState m_State;
                 bool m_CanUpdate;
             };
             struct VariableController::VariableControllerPrivate {
                 explicit VariableControllerPrivate(VariableController *parent)
                         : m_WorkingMutex{},
                           m_VariableModel{new VariableModel{parent}},
                           m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
                           // m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
                           m_VariableCacheStrategy{VariableCacheStrategyFactory::createCacheStrategy(
                               CacheStrategy::SingleThreshold)},
                           m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           q{parent}
                 {
                     m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
                     m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
                 }
                 virtual ~VariableControllerPrivate()
                 {
                     qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
                     m_VariableAcquisitionWorkerThread.quit();
                     m_VariableAcquisitionWorkerThread.wait();
                 }
                 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
                                     QUuid varRequestId);
                 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
                 std::shared_ptr<IDataSeries>
                 retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
                 void registerProvider(std::shared_ptr<IDataProvider> provider);
                 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
                 QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
                 void updateVariables(QUuid varRequestId);
                 void updateVariableRequest(QUuid varRequestId);
                 void cancelVariableRequest(QUuid varRequestId);
                 void executeVarRequest(std::shared_ptr<Variable> var, VariableRequest &varRequest);
+                template <typename VariableIterator>
+                void desynchronize(VariableIterator variableIt, const QUuid &syncGroupId);
                 QMutex m_WorkingMutex;
                 /// Variable model. The VariableController has the ownership
                 VariableModel *m_VariableModel;
                 QItemSelectionModel *m_VariableSelectionModel;
                 TimeController *m_TimeController{nullptr};
                 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
                 std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
                 QThread m_VariableAcquisitionWorkerThread;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
                 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
                 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
                     m_GroupIdToVariableSynchronizationGroupMap;
                 std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
                 std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
                 std::map<QUuid, std::list<QUuid> > m_VarGroupIdToVarIds;
                 std::map<QUuid, std::unique_ptr<VariableRequestHandler> > m_VarIdToVarRequestHandler;
                 VariableController *q;
             };
             VariableController::VariableController(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController construction")
                                                   << QThread::currentThread();
                 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                         &VariableController::onAbortProgressRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableCanceledRequested, this,
                         &VariableController::onAbortAcquisitionRequested);
                 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                         &VariableController::onDataProvided);
                 connect(impl->m_VariableAcquisitionWorker.get(),
                         &VariableAcquisitionWorker::variableRequestInProgress, this,
                         &VariableController::onVariableRetrieveDataInProgress);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                         impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::finalize);
                 connect(impl->m_VariableModel, &VariableModel::requestVariableRangeUpdate, this,
                         &VariableController::onUpdateDateTime);
                 impl->m_VariableAcquisitionWorkerThread.start();
             }
             VariableController::~VariableController()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
                                                   << QThread::currentThread();
                 this->waitForFinish();
             }
             VariableModel *VariableController::variableModel() noexcept
             {
                 return impl->m_VariableModel;
             }
             QItemSelectionModel *VariableController::variableSelectionModel() noexcept
             {
                 return impl->m_VariableSelectionModel;
             }
             void VariableController::setTimeController(TimeController *timeController) noexcept
             {
                 impl->m_TimeController = timeController;
             }
             std::shared_ptr<Variable>
             VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (impl->m_VariableModel->containsVariable(variable)) {
                     // Clones variable
                     auto duplicate = variable->clone();
                     // Adds clone to model
                     impl->m_VariableModel->addVariable(duplicate);
                     // Generates clone identifier
                     impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
                     // Registers provider
                     auto variableProvider = impl->m_VariableToProviderMap.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_VariableToProviderMap[duplicate] = duplicateProvider;
                     if (duplicateProvider) {
                         impl->registerProvider(duplicateProvider);
                     }
                     return duplicate;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Can't create duplicate of variable %1: variable not registered in the model")
                                .arg(variable->name());
                     return nullptr;
                 }
             }
             void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 if (!variable) {
                     qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
                     return;
                 }
                 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
                 // make some treatments before the deletion
                 emit variableAboutToBeDeleted(variable);
+                auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
+                Q_ASSERT(variableIt != impl->m_VariableToIdentifierMap.cend());
+                auto variableId = variableIt->second;
+                // Removes variable's handler
+                impl->m_VarIdToVarRequestHandler.erase(variableId);
+                // Desynchronizes variable (if the variable is in a sync group)
+                auto syncGroupIt = impl->m_VariableIdGroupIdMap.find(variableId);
+                if (syncGroupIt != impl->m_VariableIdGroupIdMap.cend()) {
+                    impl->desynchronize(variableIt, syncGroupIt->second);
+                }
                 // Deletes identifier
-                impl->m_VariableToIdentifierMap.erase(variable);
+                impl->m_VariableToIdentifierMap.erase(variableIt);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_VariableToProviderMap.erase(variable);
                 qCDebug(LOG_VariableController())
                     << tr("Number of providers deleted for variable %1: %2")
                            .arg(variable->name(), QString::number(nbProvidersDeleted));
                 // Deletes from model
                 impl->m_VariableModel->deleteVariable(variable);
             }
             void VariableController::deleteVariables(
                 const QVector<std::shared_ptr<Variable> > &variables) noexcept
             {
                 for (auto variable : qAsConst(variables)) {
                     deleteVariable(variable);
                 }
             }
             QByteArray
             VariableController::mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const
             {
                 auto encodedData = QByteArray{};
                 QVariantList ids;
                 for (auto &var : variables) {
                     auto itVar = impl->m_VariableToIdentifierMap.find(var);
                     if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to find the data for an unknown variable.");
                     }
                     ids << itVar->second.toByteArray();
                 }
                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
                 stream << ids;
                 return encodedData;
             }
             QList<std::shared_ptr<Variable> >
             VariableController::variablesForMimeData(const QByteArray &mimeData) const
             {
                 auto variables = QList<std::shared_ptr<Variable> >{};
                 QDataStream stream{mimeData};
                 QVariantList ids;
                 stream >> ids;
                 for (auto id : ids) {
                     auto uuid = QUuid{id.toByteArray()};
                     auto var = impl->findVariable(uuid);
                     variables << var;
                 }
                 return variables;
             }
             std::shared_ptr<Variable>
             VariableController::createVariable(const QString &name, const QVariantHash &metadata,
                                                std::shared_ptr<IDataProvider> provider) noexcept
             {
                 if (!impl->m_TimeController) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to create variable: The time controller is null");
                     return nullptr;
                 }
                 auto range = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
                     auto varId = QUuid::createUuid();
                     // Create the handler
                     auto varRequestHandler = std::make_unique<VariableRequestHandler>();
                     varRequestHandler->m_VarId = varId;
                     impl->m_VarIdToVarRequestHandler.insert(
                         std::make_pair(varId, std::move(varRequestHandler)));
                     // store the provider
                     impl->registerProvider(provider);
                     // Associate the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
                     impl->m_VariableToIdentifierMap[newVariable] = varId;
                     this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{newVariable}, range, false);
                     //        auto varRequestId = QUuid::createUuid();
                     //        qCInfo(LOG_VariableController()) << "createVariable: " << varId << varRequestId;
                     //        impl->processRequest(newVariable, range, varRequestId);
                     //        impl->updateVariableRequest(varRequestId);
                     return newVariable;
                 }
                 qCCritical(LOG_VariableController()) << tr("Impossible to create variable");
                 return nullptr;
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // NOTE: Even if acquisition request is aborting, the graphe range will be changed
                 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                                   << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 // NOTE we only permit the time modification for one variable
                 // DEPRECATED
                 // auto variables = QVector<std::shared_ptr<Variable> >{};
                 //        for (const auto &selectedRow : qAsConst(selectedRows)) {
                 //            if (auto selectedVariable =
                 //            impl->m_VariableModel->variable(selectedRow.row())) {
                 //                variables << selectedVariable;
                 //                // notify that rescale operation has to be done
                 //                emit rangeChanged(selectedVariable, dateTime);
                 //            }
                 //        }
                 //        if (!variables.isEmpty()) {
                 //            this->onRequestDataLoading(variables, dateTime, synchro);
                 //        }
                 if (selectedRows.size() == 1) {
                     if (auto selectedVariable
                         = impl->m_VariableModel->variable(qAsConst(selectedRows).first().row())) {
                         onUpdateDateTime(selectedVariable, dateTime);
                     }
                 }
                 else if (selectedRows.size() > 1) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to set time for more than 1 variable in the same time");
                 }
                 else {
                     qCWarning(LOG_VariableController())
                         << tr("There is no variable selected to set the time one");
                 }
             }
             void VariableController::onUpdateDateTime(std::shared_ptr<Variable> variable,
                                                       const SqpRange &dateTime)
             {
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onDateTimeOnSelection request for unknown variable");
                     return;
                 }
                 // notify that rescale operation has to be done
                 emit rangeChanged(variable, dateTime);
                 auto synchro
                     = impl->m_VariableIdGroupIdMap.find(itVar->second) != impl->m_VariableIdGroupIdMap.cend();
                 this->onRequestDataLoading(QVector<std::shared_ptr<Variable> >{variable}, dateTime, synchro);
             }
             void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                                     const SqpRange &cacheRangeRequested,
                                                     QVector<AcquisitionDataPacket> dataAcquired)
             {
                 qCDebug(LOG_VariableController()) << tr("onDataProvided") << QThread::currentThread();
                 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
                 auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
                 if (!varRequestId.isNull()) {
                     impl->updateVariables(varRequestId);
                 }
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 qCDebug(LOG_VariableController())
                     << "TORM: variableController::onVariableRetrieveDataInProgress"
                     << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to notify progression of a null variable");
                 }
             }
             void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortProgressRequested"
                                                   << QThread::currentThread()->objectName() << variable->name();
                 auto itVar = impl->m_VariableToIdentifierMap.find(variable);
                 if (itVar == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = impl->m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == impl->m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to onAbortProgressRequested for variable with unknown handler");
                     return;
                 }
                 auto varHandler = itVarHandler->second.get();
                 // case where a variable has a running request
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     impl->cancelVariableRequest(varHandler->m_RunningVarRequest.m_VariableGroupId);
                 }
             }
             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
             {
                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
                                                   << QThread::currentThread()->objectName() << vIdentifier;
                 if (auto var = impl->findVariable(vIdentifier)) {
                     this->onAbortProgressRequested(var);
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to abort Acquisition Requestof a null variable");
                 }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                                                   << QThread::currentThread()->objectName()
                                                   << synchronizationGroupId;
                 auto vSynchroGroup = std::make_shared<VariableSynchronizationGroup>();
                 impl->m_GroupIdToVariableSynchronizationGroupMap.insert(
                     std::make_pair(synchronizationGroupId, vSynchroGroup));
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_GroupIdToVariableSynchronizationGroupMap.erase(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
                                                   << synchronizationGroupId;
                 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
                     auto groupIdToVSGIt
                         = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
                     if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
                         impl->m_VariableIdGroupIdMap.insert(
                             std::make_pair(varToVarIdIt->second, synchronizationGroupId));
                         groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << tr("Impossible to synchronize a variable with an unknown sycnhronization group")
                             << variable->name();
                     }
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to synchronize a variable with no identifier") << variable->name();
                 }
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
                 // Gets variable id
                 auto variableIt = impl->m_VariableToIdentifierMap.find(variable);
                 if (variableIt == impl->m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Can't desynchronize variable %1: variable identifier not found")
                                .arg(variable->name());
                     return;
                 }
-                // Gets synchronization group
+                impl->desynchronize(variableIt, synchronizationGroupId);
-                auto groupIt = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
-                if (groupIt == impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
-                    qCCritical(LOG_VariableController())
-                        << tr("Can't desynchronize variable %1: unknown synchronization group")
-                               .arg(variable->name());
-                    return;
-                auto variableId = variableIt->second;
-                // Removes variable from synchronization group
-                auto synchronizationGroup = groupIt->second;
-                synchronizationGroup->removeVariableId(variableId);
-                // Removes link between variable and synchronization group
-                impl->m_VariableIdGroupIdMap.erase(variableId);
             }
             void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
                                                           const SqpRange &range, bool synchronise)
             {
                 // variables is assumed synchronized
                 // TODO: Asser variables synchronization
                 // we want to load data of the variable for the dateTime.
                 if (variables.isEmpty()) {
                     return;
                 }
                 auto varRequestId = QUuid::createUuid();
                 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
                                                   << QThread::currentThread()->objectName() << varRequestId
                                                   << range << synchronise;
                 if (!synchronise) {
                     auto varIds = std::list<QUuid>{};
                     for (const auto &var : variables) {
                         auto vId = impl->m_VariableToIdentifierMap.at(var);
                         varIds.push_back(vId);
                     }
                     impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                     for (const auto &var : variables) {
                         qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId
                                                           << varIds.size();
                         impl->processRequest(var, range, varRequestId);
                     }
                 }
                 else {
                     auto vId = impl->m_VariableToIdentifierMap.at(variables.first());
                     auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                     if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                         auto groupId = varIdToGroupIdIt->second;
                         auto vSynchronizationGroup
                             = impl->m_GroupIdToVariableSynchronizationGroupMap.at(groupId);
                         auto vSyncIds = vSynchronizationGroup->getIds();
                         auto varIds = std::list<QUuid>{};
                         for (auto vId : vSyncIds) {
                             varIds.push_back(vId);
                         }
                         impl->m_VarGroupIdToVarIds.insert(std::make_pair(varRequestId, varIds));
                         for (auto vId : vSyncIds) {
                             auto var = impl->findVariable(vId);
                             // Don't process already processed var
                             if (var != nullptr) {
                                 qCDebug(LOG_VariableController()) << "processRequest synchro for" << var->name()
                                                                   << varRequestId;
                                 auto vSyncRangeRequested
                                     = variables.contains(var)
                                           ? range
                                           : computeSynchroRangeRequested(var->range(), range,
                                                                          variables.first()->range());
                                 qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
                                 impl->processRequest(var, vSyncRangeRequested, varRequestId);
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to synchronize a null variable");
                             }
                         }
                     }
                 }
                 impl->updateVariables(varRequestId);
             }
             void VariableController::initialize()
             {
                 qCDebug(LOG_VariableController()) << tr("VariableController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableController()) << tr("VariableController init END");
             }
             void VariableController::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const SqpRange &oldRange)
             {
                 // t1.m_TStart <= t2.m_TStart && t2.m_TEnd <= t1.m_TEnd
                 auto zoomType = AcquisitionZoomType::Unknown;
                 if (range.m_TStart <= oldRange.m_TStart && oldRange.m_TEnd <= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomOut";
                     zoomType = AcquisitionZoomType::ZoomOut;
                 }
                 else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanRight";
                     zoomType = AcquisitionZoomType::PanRight;
                 }
                 else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: PanLeft";
                     zoomType = AcquisitionZoomType::PanLeft;
                 }
                 else if (range.m_TStart >= oldRange.m_TStart && oldRange.m_TEnd >= range.m_TEnd) {
                     qCDebug(LOG_VariableController()) << "zoomtype: ZoomIn";
                     zoomType = AcquisitionZoomType::ZoomIn;
                 }
                 else {
                     qCDebug(LOG_VariableController()) << "getZoomType: Unknown type detected";
                 }
                 return zoomType;
             }
             void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
                                                                                const SqpRange &rangeRequested,
                                                                                QUuid varRequestId)
             {
                 auto itVar = m_VariableToIdentifierMap.find(var);
                 if (itVar == m_VariableToIdentifierMap.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for unknown variable");
                     return;
                 }
                 auto varId = itVar->second;
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to process request for variable with unknown handler");
                     return;
                 }
                 auto oldRange = var->range();
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State != VariableRequestHandlerState::OFF) {
                     oldRange = varHandler->m_RunningVarRequest.m_RangeRequested;
                 }
                 auto varRequest = VariableRequest{};
                 varRequest.m_VariableGroupId = varRequestId;
                 auto varStrategyRangesRequested
                     = m_VariableCacheStrategy->computeRange(oldRange, rangeRequested);
                 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
                 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
                 switch (varHandler->m_State) {
                     case VariableRequestHandlerState::OFF: {
                         qCDebug(LOG_VariableController()) << tr("Process Request OFF")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_RunningVarRequest = varRequest;
                         varHandler->m_State = VariableRequestHandlerState::RUNNING;
                         executeVarRequest(var, varRequest);
                         break;
                     }
                     case VariableRequestHandlerState::RUNNING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request RUNNING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     case VariableRequestHandlerState::PENDING: {
                         qCDebug(LOG_VariableController()) << tr("Process Request PENDING")
                                                           << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         auto variableGroupIdToCancel = varHandler->m_PendingVarRequest.m_VariableGroupId;
                         cancelVariableRequest(variableGroupIdToCancel);
                         // Cancel variable can make state downgrade
                         varHandler->m_State = VariableRequestHandlerState::PENDING;
                         varHandler->m_PendingVarRequest = varRequest;
                         break;
                     }
                     default:
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Unknown VariableRequestHandlerState");
                 }
             }
             std::shared_ptr<Variable>
             VariableController::VariableControllerPrivate::findVariable(QUuid vIdentifier)
             {
                 std::shared_ptr<Variable> var;
                 auto findReply = [vIdentifier](const auto &entry) { return vIdentifier == entry.second; };
                 auto end = m_VariableToIdentifierMap.cend();
                 auto it = std::find_if(m_VariableToIdentifierMap.cbegin(), end, findReply);
                 if (it != end) {
                     var = it->first;
                 }
                 else {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to find the variable with the identifier: ") << vIdentifier;
                 }
                 return var;
             }
             std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
                 const QVector<AcquisitionDataPacket> acqDataPacketVector)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
                                                   << acqDataPacketVector.size();
                 std::shared_ptr<IDataSeries> dataSeries;
                 if (!acqDataPacketVector.isEmpty()) {
                     dataSeries = acqDataPacketVector[0].m_DateSeries;
                     for (int i = 1; i < acqDataPacketVector.size(); ++i) {
                         dataSeries->merge(acqDataPacketVector[i].m_DateSeries.get());
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
                                                   << acqDataPacketVector.size();
                 return dataSeries;
             }
             void VariableController::VariableControllerPrivate::registerProvider(
                 std::shared_ptr<IDataProvider> provider)
             {
                 if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
                     qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
                                                       << provider->objectName();
                     m_ProviderSet.insert(provider);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                 }
                 else {
                     qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                 }
             }
             QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
                 QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
             {
                 auto itVarHandler = m_VarIdToVarRequestHandler.find(varId);
                 if (itVarHandler == m_VarIdToVarRequestHandler.cend()) {
                     return QUuid();
                 }
                 auto varHandler = itVarHandler->second.get();
                 if (varHandler->m_State == VariableRequestHandlerState::OFF) {
                     qCCritical(LOG_VariableController())
                         << tr("acceptVariableRequest impossible on a variable with OFF state");
                 }
                 varHandler->m_RunningVarRequest.m_DataSeries = dataSeries;
                 varHandler->m_CanUpdate = true;
                 // Element traité, on a déjà toutes les données necessaires
                 auto varGroupId = varHandler->m_RunningVarRequest.m_VariableGroupId;
                 qCDebug(LOG_VariableController()) << "Variable::acceptVariableRequest" << varGroupId
                                                   << m_VarGroupIdToVarIds.size();
                 return varHandler->m_RunningVarRequest.m_VariableGroupId;
             }
             void VariableController::VariableControllerPrivate::updateVariables(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << QThread::currentThread()->objectName() << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCWarning(LOG_VariableController())
                         << tr("Impossible to updateVariables of unknown variables") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 bool processVariableUpdate = true;
                 qCDebug(LOG_VariableController()) << "VariableControllerPrivate::updateVariables"
                                                   << varRequestId << varIds.size();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd) && processVariableUpdate;
                      ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         processVariableUpdate &= itVarHandler->second->m_CanUpdate;
                     }
                 }
                 if (processVariableUpdate) {
                     qCDebug(LOG_VariableController()) << "Final update OK for the var request" << varIds.size();
                     for (auto varIdsIt = varIds.begin(); varIdsIt != varIdsEnd; ++varIdsIt) {
                         auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                         if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                             if (auto var = findVariable(*varIdsIt)) {
                                 auto &varRequest = itVarHandler->second->m_RunningVarRequest;
                                 var->setRange(varRequest.m_RangeRequested);
                                 var->setCacheRange(varRequest.m_CacheRangeRequested);
                                 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
                                                                   << varRequest.m_RangeRequested
                                                                   << varRequest.m_CacheRangeRequested;
                                 qCDebug(LOG_VariableController()) << tr("2: onDataProvided var points before")
                                                                   << var->nbPoints()
                                                                   << varRequest.m_DataSeries->nbPoints();
                                 var->mergeDataSeries(varRequest.m_DataSeries);
                                 qCDebug(LOG_VariableController()) << tr("3: onDataProvided var points after")
                                                                   << var->nbPoints();
                                 emit var->updated();
                                 qCDebug(LOG_VariableController()) << tr("Update OK");
                             }
                             else {
                                 qCCritical(LOG_VariableController())
                                     << tr("Impossible to update data to a null variable");
                             }
                         }
                     }
                     updateVariableRequest(varRequestId);
                     // cleaning varRequestId
                     qCDebug(LOG_VariableController()) << tr("m_VarGroupIdToVarIds erase") << varRequestId;
                     m_VarGroupIdToVarIds.erase(varRequestId);
                     if (m_VarGroupIdToVarIds.empty()) {
                         emit q->acquisitionFinished();
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
             {
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController()) << QObject::tr(
                         "Impossible to updateVariableRequest since varGroupdId isn't here anymore");
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_CanUpdate = false;
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Impossible to update a variable with handler in OFF state");
                             } break;
                             case VariableRequestHandlerState::RUNNING: {
                                 varHandler->m_State = VariableRequestHandlerState::OFF;
                                 varHandler->m_RunningVarRequest = VariableRequest{};
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                 varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                 varHandler->m_PendingVarRequest = VariableRequest{};
                                 auto var = findVariable(itVarHandler->first);
                                 executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 updateVariables(varHandler->m_RunningVarRequest.m_VariableGroupId);
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
             }
             void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
             {
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest") << varRequestId;
                 auto varGroupIdToVarIdsIt = m_VarGroupIdToVarIds.find(varRequestId);
                 if (varGroupIdToVarIdsIt == m_VarGroupIdToVarIds.end()) {
                     qCCritical(LOG_VariableController())
                         << tr("Impossible to cancelVariableRequest for unknown varGroupdId") << varRequestId;
                     return;
                 }
                 auto &varIds = varGroupIdToVarIdsIt->second;
                 auto varIdsEnd = varIds.end();
                 for (auto varIdsIt = varIds.begin(); (varIdsIt != varIdsEnd); ++varIdsIt) {
                     auto itVarHandler = m_VarIdToVarRequestHandler.find(*varIdsIt);
                     if (itVarHandler != m_VarIdToVarRequestHandler.cend()) {
                         auto varHandler = itVarHandler->second.get();
                         varHandler->m_VarId = QUuid{};
                         switch (varHandler->m_State) {
                             case VariableRequestHandlerState::OFF: {
                                 qCWarning(LOG_VariableController())
                                     << QObject::tr("Impossible to cancel a variable with no running request");
                                 break;
                             }
                             case VariableRequestHandlerState::RUNNING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::OFF;
                                     varHandler->m_RunningVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the running variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             case VariableRequestHandlerState::PENDING: {
                                 if (varHandler->m_RunningVarRequest.m_VariableGroupId == varRequestId) {
                                     auto var = findVariable(itVarHandler->first);
                                     auto varProvider = m_VariableToProviderMap.at(var);
                                     if (varProvider != nullptr) {
                                         m_VariableAcquisitionWorker->abortProgressRequested(
                                             itVarHandler->first);
                                     }
                                     m_VariableModel->setDataProgress(var, 0.0);
                                     varHandler->m_CanUpdate = false;
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_RunningVarRequest = varHandler->m_PendingVarRequest;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                     executeVarRequest(var, varHandler->m_RunningVarRequest);
                                 }
                                 else if (varHandler->m_PendingVarRequest.m_VariableGroupId == varRequestId) {
                                     varHandler->m_State = VariableRequestHandlerState::RUNNING;
                                     varHandler->m_PendingVarRequest = VariableRequest{};
                                 }
                                 else {
                                     // TODO: log Impossible to cancel the variable request beacause its
                                     // varRequestId isn't not the canceled one
                                 }
                                 break;
                             }
                             default:
                                 qCCritical(LOG_VariableController())
                                     << QObject::tr("Unknown VariableRequestHandlerState");
                         }
                     }
                 }
                 qCDebug(LOG_VariableController()) << tr("cancelVariableRequest: erase") << varRequestId;
                 m_VarGroupIdToVarIds.erase(varRequestId);
                 if (m_VarGroupIdToVarIds.empty()) {
                     emit q->acquisitionFinished();
                 }
             }
             void VariableController::VariableControllerPrivate::executeVarRequest(std::shared_ptr<Variable> var,
                                                                                   VariableRequest &varRequest)
             {
                 qCDebug(LOG_VariableController()) << tr("TORM: executeVarRequest");
-                auto varId = m_VariableToIdentifierMap.at(var);
+                auto varIdIt = m_VariableToIdentifierMap.find(var);
+                if (varIdIt == m_VariableToIdentifierMap.cend()) {
+                    qCWarning(LOG_VariableController()) << tr(
+                        "Can't execute request of a variable that is not registered (may has been deleted)");
+                    return;
+                }
+                auto varId = varIdIt->second;
                 auto varCacheRange = var->cacheRange();
                 auto varCacheRangeRequested = varRequest.m_CacheRangeRequested;
                 auto notInCacheRangeList
                     = Variable::provideNotInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 auto inCacheRangeList
                     = Variable::provideInCacheRangeList(varCacheRange, varCacheRangeRequested);
                 if (!notInCacheRangeList.empty()) {
                     auto varProvider = m_VariableToProviderMap.at(var);
                     if (varProvider != nullptr) {
                         qCDebug(LOG_VariableController()) << "executeVarRequest " << varRequest.m_RangeRequested
                                                           << varRequest.m_CacheRangeRequested;
                         m_VariableAcquisitionWorker->pushVariableRequest(
                             varRequest.m_VariableGroupId, varId, varRequest.m_RangeRequested,
                             varRequest.m_CacheRangeRequested,
                             DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                             varProvider);
                     }
                     else {
                         qCCritical(LOG_VariableController())
                             << "Impossible to provide data with a null provider";
                     }
                     if (!inCacheRangeList.empty()) {
                         emit q->updateVarDisplaying(var, inCacheRangeList.first());
                     }
                 }
                 else {
                     acceptVariableRequest(varId,
                                           var->dataSeries()->subDataSeries(varRequest.m_CacheRangeRequested));
                 }
             }
+            template <typename VariableIterator>
+            void VariableController::VariableControllerPrivate::desynchronize(VariableIterator variableIt,
+                                                                              const QUuid &syncGroupId)
+            {
+                const auto &variable = variableIt->first;
+                const auto &variableId = variableIt->second;
+                // Gets synchronization group
+                auto groupIt = m_GroupIdToVariableSynchronizationGroupMap.find(syncGroupId);
+                if (groupIt == m_GroupIdToVariableSynchronizationGroupMap.cend()) {
+                    qCCritical(LOG_VariableController())
+                        << tr("Can't desynchronize variable %1: unknown synchronization group")
+                               .arg(variable->name());
+                    return;
+                }
+                // Removes variable from synchronization group
+                auto synchronizationGroup = groupIt->second;
+                synchronizationGroup->removeVariableId(variableId);
+                // Removes link between variable and synchronization group
+                m_VariableIdGroupIdMap.erase(variableId);
+            }