##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SCIQLOP-Initialisation
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Implements unit test (3)...
Implements unit test (3) Implements validation method and generates last value for CosinusProvider
Alexandre Leroux - - Load All Authors

File last commit:

r676:e5aabf0f62fb
r689:e4699d579435
Show More
VariableController.cpp
805 lines | 33.1 KiB | text/x-c | CppLexer
/ core / src / Variable / VariableController.cpp
History | Source | Raw |Copy content |Copy permalink
perrinel
The mock plugin can now create data with view operation
 r219 #include <Variable/Variable.h>
perrinel
Implementation of V5 acquisition
 r510 #include <Variable/VariableAcquisitionWorker.h>
#include <Variable/VariableCacheStrategy.h>
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 #include <Variable/VariableController.h>
Alexandre Leroux
Adds Variable model in the Variable controller
 r108 #include <Variable/VariableModel.h>
perrinel
Implementation of V5 acquisition
 r510 #include <Variable/VariableSynchronizationGroup.h>
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106
Alexandre Leroux
Updates VariableController::createVariable() method...
 r154 #include <Data/DataProviderParameters.h>
#include <Data/IDataProvider.h>
#include <Data/IDataSeries.h>
perrinel
Add implementation of the Var Acquisition waiting
 r585 #include <Data/VariableRequest.h>
perrinel
Time widget is now used with the variable createion request
 r179 #include <Time/TimeController.h>
Alexandre Leroux
Updates VariableController::createVariable() method...
 r154
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 #include <QMutex>
#include <QThread>
Alexandre Leroux
Transits tokens in provider requests
 r347 #include <QUuid>
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 #include <QtCore/QItemSelectionModel>
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106
perrinel
Add implementation of the Var Acquisition waiting
 r585 #include <deque>
perrinel
Implementation of V5 acquisition
 r510 #include <set>
perrinel
Create a variable notify the variable cache parameter
 r209 #include <unordered_map>
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
perrinel
Implementation of V5 acquisition
 r510 namespace {
perrinel
change grapheRange to graphRange
 r516 SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
perrinel
Implementation of V5 acquisition
 r510 const SqpRange &oldGraphRange)
{
perrinel
change grapheRange to graphRange
 r516 auto zoomType = VariableController::getZoomType(graphRange, oldGraphRange);
perrinel
Implementation of V5 acquisition
 r510
auto varRangeRequested = varRange;
switch (zoomType) {
case AcquisitionZoomType::ZoomIn: {
perrinel
change grapheRange to graphRange
 r516 auto deltaLeft = graphRange.m_TStart - oldGraphRange.m_TStart;
auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
perrinel
Implementation of V5 acquisition
 r510 varRangeRequested.m_TStart += deltaLeft;
varRangeRequested.m_TEnd -= deltaRight;
break;
}
case AcquisitionZoomType::ZoomOut: {
perrinel
change grapheRange to graphRange
 r516 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
perrinel
Implementation of V5 acquisition
 r510 varRangeRequested.m_TStart -= deltaLeft;
varRangeRequested.m_TEnd += deltaRight;
break;
}
case AcquisitionZoomType::PanRight: {
perrinel
change grapheRange to graphRange
 r516 auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
perrinel
Implementation of V5 acquisition
 r510 varRangeRequested.m_TStart += deltaRight;
varRangeRequested.m_TEnd += deltaRight;
break;
}
case AcquisitionZoomType::PanLeft: {
perrinel
change grapheRange to graphRange
 r516 auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
perrinel
Implementation of V5 acquisition
 r510 varRangeRequested.m_TStart -= deltaLeft;
varRangeRequested.m_TEnd -= deltaLeft;
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;
}
}
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 struct VariableController::VariableControllerPrivate {
Alexandre Leroux
Use raw pointer for VariableModel (QObject class)
 r148 explicit VariableControllerPrivate(VariableController *parent)
perrinel
Create a variable notify the variable cache parameter
 r209 : m_WorkingMutex{},
m_VariableModel{new VariableModel{parent}},
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
perrinel
Implementation of V5 acquisition
 r510 m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
perrinel
add Skeleton for displaying data which are already in cache
 r538 m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
q{parent}
perrinel
Implementation of V5 acquisition
 r510 {
m_VariableAcquisitionWorker->moveToThread(&m_VariableAcquisitionWorkerThread);
m_VariableAcquisitionWorkerThread.setObjectName("VariableAcquisitionWorkerThread");
}
virtual ~VariableControllerPrivate()
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 {
perrinel
Implementation of V5 acquisition
 r510 qCDebug(LOG_VariableController()) << tr("VariableControllerPrivate destruction");
m_VariableAcquisitionWorkerThread.quit();
m_VariableAcquisitionWorkerThread.wait();
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 }
perrinel
Implementation of V5 acquisition
 r510
perrinel
Add implementation of the Var Acquisition waiting
 r585 void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
QUuid varRequestId);
perrinel
Implementation of V5 acquisition
 r510
perrinel
Update worker for SqpRange compatibility
 r501 QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
const SqpRange &dateTime);
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500
perrinel
Implementation of V5 acquisition
 r510 std::shared_ptr<Variable> findVariable(QUuid vIdentifier);
std::shared_ptr<IDataSeries>
retrieveDataSeries(const QVector<AcquisitionDataPacket> acqDataPacketVector);
void registerProvider(std::shared_ptr<IDataProvider> provider);
perrinel
Add implementation of the Var Acquisition waiting
 r585 void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
void updateVariableRequest(QUuid varRequestId);
void cancelVariableRequest(QUuid varRequestId);
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 QMutex m_WorkingMutex;
Alexandre Leroux
Use raw pointer for VariableModel (QObject class)
 r148 /// Variable model. The VariableController has the ownership
VariableModel *m_VariableModel;
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 QItemSelectionModel *m_VariableSelectionModel;
perrinel
Time widget is now used with the variable createion request
 r179
perrinel
Create a variable notify the variable cache parameter
 r209
perrinel
Correction MR
 r181 TimeController *m_TimeController{nullptr};
perrinel
Implementation of V5 acquisition
 r510 std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
QThread m_VariableAcquisitionWorkerThread;
perrinel
The mock plugin can now create data with view operation
 r219
std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
m_VariableToProviderMap;
Alexandre Leroux
Corrects regression on variable destruction
 r386 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifierMap;
perrinel
Implementation of V5 acquisition
 r510 std::map<QUuid, std::shared_ptr<VariableSynchronizationGroup> >
m_GroupIdToVariableSynchronizationGroupMap;
std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
perrinel
add Skeleton for displaying data which are already in cache
 r538
perrinel
Add implementation of the Var Acquisition waiting
 r585 std::map<QUuid, std::map<QUuid, VariableRequest> > m_VarRequestIdToVarIdVarRequestMap;
std::map<QUuid, std::deque<QUuid> > m_VarIdToVarRequestIdQueueMap;
perrinel
add Skeleton for displaying data which are already in cache
 r538
VariableController *q;
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 };
perrinel
Implementation of V5 acquisition
 r510
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 VariableController::VariableController(QObject *parent)
Alexandre Leroux
Use raw pointer for VariableModel (QObject class)
 r148 : QObject{parent}, impl{spimpl::make_unique_impl<VariableControllerPrivate>(this)}
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 {
perrinel
Correction clang format
 r337 qCDebug(LOG_VariableController()) << tr("VariableController construction")
<< QThread::currentThread();
perrinel
Implement of the abort download process
 r388
connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
&VariableController::onAbortProgressRequested);
perrinel
Implementation of V5 acquisition
 r510
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);
impl->m_VariableAcquisitionWorkerThread.start();
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 }
VariableController::~VariableController()
{
perrinel
Correction clang format
 r337 qCDebug(LOG_VariableController()) << tr("VariableController destruction")
<< QThread::currentThread();
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 this->waitForFinish();
}
Alexandre Leroux
Updates VariableController::createVariable() method...
 r154 VariableModel *VariableController::variableModel() noexcept
Alexandre Leroux
Adds Variable model in the Variable controller
 r108 {
Alexandre Leroux
Updates VariableController::createVariable() method...
 r154 return impl->m_VariableModel;
Alexandre Leroux
Adds Variable model in the Variable controller
 r108 }
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 QItemSelectionModel *VariableController::variableSelectionModel() noexcept
{
return impl->m_VariableSelectionModel;
}
perrinel
Time widget is now used with the variable createion request
 r179 void VariableController::setTimeController(TimeController *timeController) noexcept
{
impl->m_TimeController = timeController;
}
Alexandre Leroux
Adds 'Duplicate' action on variable menu
 r650 std::shared_ptr<Variable>
VariableController::cloneVariable(std::shared_ptr<Variable> variable) noexcept
{
Alexandre Leroux
Creates duplicate only if the variable is in the model
 r654 if (impl->m_VariableModel->containsVariable(variable)) {
// Clones variable
auto duplicate = variable->clone();
Alexandre Leroux
Clones variable
 r651
Alexandre Leroux
Creates duplicate only if the variable is in the model
 r654 // Adds clone to model
impl->m_VariableModel->addVariable(duplicate);
Alexandre Leroux
Adds variable to model
 r652
Alexandre Leroux
Generates clone identifier in controller
 r655 // Generates clone identifier
impl->m_VariableToIdentifierMap[duplicate] = QUuid::createUuid();
Alexandre Leroux
Generates and registers clone provider
 r656 // 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);
}
Alexandre Leroux
Creates duplicate only if the variable is in the model
 r654 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;
}
Alexandre Leroux
Adds 'Duplicate' action on variable menu
 r650 }
Alexandre Leroux
Variable deletion (1)...
 r303 void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noexcept
{
if (!variable) {
qCCritical(LOG_VariableController()) << "Can't delete variable: variable is null";
return;
}
Alexandre Leroux
Variable deletion (6)...
 r309 // Spreads in SciQlop that the variable will be deleted, so that potential receivers can
// make some treatments before the deletion
emit variableAboutToBeDeleted(variable);
Alexandre Leroux
Variable deletion (2)...
 r304
Alexandre Leroux
Corrects regression on variable destruction
 r386 // Deletes identifier
impl->m_VariableToIdentifierMap.erase(variable);
Alexandre Leroux
Variable deletion (2)...
 r304 // 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));
Alexandre Leroux
Variable deletion (1)...
 r303
Alexandre Leroux
Variable deletion (2)...
 r305
Alexandre Leroux
Variable deletion (3)...
 r306 // Deletes from model
impl->m_VariableModel->deleteVariable(variable);
}
Alexandre Leroux
Variable deletion (1)...
 r303
void VariableController::deleteVariables(
const QVector<std::shared_ptr<Variable> > &variables) noexcept
{
for (auto variable : qAsConst(variables)) {
deleteVariable(variable);
}
}
perrinel
Implement of the abort download process
 r388 void VariableController::abortProgress(std::shared_ptr<Variable> variable)
{
}
perrinel
Add test acquisition.
r553 std::shared_ptr<Variable>
VariableController::createVariable(const QString &name, const QVariantHash &metadata,
std::shared_ptr<IDataProvider> provider) noexcept
Alexandre Leroux
Affects model to the Variable Widget
 r143 {
perrinel
Time widget is now used with the variable createion request
 r179 if (!impl->m_TimeController) {
qCCritical(LOG_VariableController())
<< tr("Impossible to create variable: The time controller is null");
perrinel
Add test acquisition.
r553 return nullptr;
perrinel
Time widget is now used with the variable createion request
 r179 }
perrinel
Implementation of V5 acquisition
 r510 auto range = impl->m_TimeController->dateTime();
Alexandre Leroux
Updates variable creation to pass metadata...
 r377
perrinel
Implementation of V5 acquisition
 r510 if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
perrinel
Implement the network controller to permit the execution of a request...
 r359 auto identifier = QUuid::createUuid();
perrinel
Create a variable notify the variable cache parameter
 r209
perrinel
The mock plugin can now create data with view operation
 r219 // store the provider
perrinel
Implementation of V5 acquisition
 r510 impl->registerProvider(provider);
// Associate the provider
perrinel
The mock plugin can now create data with view operation
 r219 impl->m_VariableToProviderMap[newVariable] = provider;
Alexandre Leroux
Corrects regression on variable destruction
 r386 impl->m_VariableToIdentifierMap[newVariable] = identifier;
perrinel
The cache is now updated only if date requested has been successfully...
 r293
perrinel
Add implementation of the Var Acquisition waiting
 r585 auto varRequestId = QUuid::createUuid();
qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
impl->processRequest(newVariable, range, varRequestId);
impl->updateVariableRequest(varRequestId);
perrinel
Add test acquisition.
r553
return newVariable;
Alexandre Leroux
Updates VariableController::createVariable() method...
 r154 }
Alexandre Leroux
Affects model to the Variable Widget
 r143 }
perrinel
Change SqpRange for SqpDateTime
 r471 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 {
perrinel
Add implementation of the Var Acquisition waiting
 r585 // TODO check synchronisation and Rescale
perrinel
Correction clang format
 r337 qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
<< QThread::currentThread()->objectName();
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
perrinel
Add implementation of the Var Acquisition waiting
 r585 auto varRequestId = QUuid::createUuid();
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281
for (const auto &selectedRow : qAsConst(selectedRows)) {
if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
perrinel
Implementation of V5 acquisition
 r510 selectedVariable->setRange(dateTime);
perrinel
Add implementation of the Var Acquisition waiting
 r585 impl->processRequest(selectedVariable, dateTime, varRequestId);
perrinel
Add comment
 r408
// notify that rescale operation has to be done
perrinel
Add connection logical for the rescale operation
 r403 emit rangeChanged(selectedVariable, dateTime);
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 }
}
perrinel
Add implementation of the Var Acquisition waiting
 r585 impl->updateVariableRequest(varRequestId);
perrinel
Temporal parameters of the selected variables can be updated using the...
 r281 }
perrinel
Implementation of V5 acquisition
 r510 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
const SqpRange &cacheRangeRequested,
QVector<AcquisitionDataPacket> dataAcquired)
perrinel
Add implementation of progress bar on variable inspector connected to...
 r369 {
perrinel
Add implementation of the Var Acquisition waiting
 r585 auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
if (!varRequestId.isNull()) {
impl->updateVariableRequest(varRequestId);
perrinel
Implementation of V5 acquisition
 r510 }
}
perrinel
Add implementation of progress bar on variable inspector connected to...
 r369
perrinel
Implementation of V5 acquisition
 r510 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
{
perrinel
Correction for MR
 r517 if (auto var = impl->findVariable(identifier)) {
perrinel
Implementation of V5 acquisition
 r510 impl->m_VariableModel->setDataProgress(var, progress);
}
else {
qCCritical(LOG_VariableController())
<< tr("Impossible to notify progression of a null variable");
perrinel
Add implementation of progress bar on variable inspector connected to...
 r369 }
}
perrinel
Implement of the abort download process
 r388 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
{
qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
<< QThread::currentThread()->objectName();
perrinel
Add thread protection on AbortDownload process
 r389 auto it = impl->m_VariableToIdentifierMap.find(variable);
if (it != impl->m_VariableToIdentifierMap.cend()) {
perrinel
Implement of the abort download process
 r388 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
}
else {
qCWarning(LOG_VariableController())
<< tr("Aborting progression of inexistant variable detected !!!")
<< QThread::currentThread()->objectName();
}
}
perrinel
Implementation of V5 acquisition
 r510 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
{
perrinel
Add synchronization part of v5 acquisition
 r511 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
<< QThread::currentThread()->objectName()
<< synchronizationGroupId;
perrinel
Implementation of V5 acquisition
 r510 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);
}
perrinel
Add synchronization part of v5 acquisition
 r511 void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
QUuid synchronizationGroupId)
{
qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronized"
<< synchronizationGroupId;
perrinel
Correction for MR
 r517 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(variable);
if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
auto groupIdToVSGIt
perrinel
Add synchronization part of v5 acquisition
 r511 = impl->m_GroupIdToVariableSynchronizationGroupMap.find(synchronizationGroupId);
perrinel
Correction for MR
 r517 if (groupIdToVSGIt != impl->m_GroupIdToVariableSynchronizationGroupMap.cend()) {
perrinel
Add synchronization part of v5 acquisition
 r511 impl->m_VariableIdGroupIdMap.insert(
perrinel
Correction for MR
 r517 std::make_pair(varToVarIdIt->second, synchronizationGroupId));
groupIdToVSGIt->second->addVariableId(varToVarIdIt->second);
perrinel
Add synchronization part of v5 acquisition
 r511 }
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();
}
}
Alexandre Leroux
Handles desynchronisation when removing variable from a graph (1)...
 r676 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
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);
}
perrinel
The mock plugin can now create data with view operation
 r219
perrinel
Implementation of V5 acquisition
 r510 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> > variables,
const SqpRange &range, const SqpRange &oldRange,
bool synchronise)
perrinel
The mock plugin can now create data with view operation
 r219 {
perrinel
Implementation of V5 acquisition
 r510 // NOTE: oldRange isn't really necessary since oldRange == variable->range().
perrinel
The mock plugin can now create data with view operation
 r219 // we want to load data of the variable for the dateTime.
// First we check if the cache contains some of them.
// For the other, we ask the provider to give them.
perrinel
Add implementation of the Var Acquisition waiting
 r585 auto varRequestId = QUuid::createUuid();
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
<< QThread::currentThread()->objectName() << varRequestId;
perrinel
Add implementation of the Var Acquisition waiting
 r585
perrinel
Correction for MR
 r517 for (const auto &var : variables) {
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
perrinel
Add implementation of the Var Acquisition waiting
 r585 impl->processRequest(var, range, varRequestId);
perrinel
Implementation of V5 acquisition
 r510 }
perrinel
The mock plugin can now create data with view operation
 r219
perrinel
Implementation of V5 acquisition
 r510 if (synchronise) {
// Get the group ids
perrinel
Add synchronization part of v5 acquisition
 r511 qCDebug(LOG_VariableController())
perrinel
Correction for MR
 r517 << "TORM VariableController::onRequestDataLoading for synchro var ENABLE";
perrinel
Next range of a variable synchronized is now computed using:...
 r586 auto groupIds = std::set<QUuid>{};
auto groupIdToOldRangeMap = std::map<QUuid, SqpRange>{};
perrinel
Correction for MR
 r517 for (const auto &var : variables) {
perrinel
Add synchronization part of v5 acquisition
 r511 auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
auto vId = varToVarIdIt->second;
auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
auto gId = varIdToGroupIdIt->second;
perrinel
Next range of a variable synchronized is now computed using:...
 r586 groupIdToOldRangeMap.insert(std::make_pair(gId, var->range()));
perrinel
Implementation of V5 acquisition
 r510 if (groupIds.find(gId) == groupIds.cend()) {
perrinel
Add synchronization part of v5 acquisition
 r511 qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
perrinel
Implementation of V5 acquisition
 r510 groupIds.insert(gId);
}
}
}
perrinel
Fix the cosinus bug....
 r276 }
perrinel
Implementation of V5 acquisition
 r510
// We assume here all group ids exist
perrinel
Correction for MR
 r517 for (const auto &gId : groupIds) {
perrinel
Implementation of V5 acquisition
 r510 auto vSynchronizationGroup = impl->m_GroupIdToVariableSynchronizationGroupMap.at(gId);
auto vSyncIds = vSynchronizationGroup->getIds();
perrinel
Add synchronization part of v5 acquisition
 r511 qCDebug(LOG_VariableController()) << "Var in synchro group ";
perrinel
Implementation of V5 acquisition
 r510 for (auto vId : vSyncIds) {
auto var = impl->findVariable(vId);
perrinel
Add synchronization part of v5 acquisition
 r511
// Don't process already processed var
if (!variables.contains(var)) {
if (var != nullptr) {
qCDebug(LOG_VariableController()) << "processRequest synchro for"
<< var->name();
perrinel
Next range of a variable synchronized is now computed using:...
 r586 auto vSyncRangeRequested = computeSynchroRangeRequested(
var->range(), range, groupIdToOldRangeMap.at(gId));
qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
perrinel
Add implementation of the Var Acquisition waiting
 r585 impl->processRequest(var, vSyncRangeRequested, varRequestId);
perrinel
Add synchronization part of v5 acquisition
 r511 }
else {
qCCritical(LOG_VariableController())
<< tr("Impossible to synchronize a null variable");
}
perrinel
Implementation of V5 acquisition
 r510 }
}
perrinel
Fix the cosinus bug....
 r276 }
perrinel
The mock plugin can now create data with view operation
 r219 }
perrinel
Add implementation of the Var Acquisition waiting
 r585
impl->updateVariableRequest(varRequestId);
perrinel
The mock plugin can now create data with view operation
 r219 }
Alexandre Leroux
Inits variable controller and adds it to the SciQlop app
 r106 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};
}
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500
perrinel
Implementation of V5 acquisition
 r510 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) {
zoomType = AcquisitionZoomType::ZoomOut;
}
else if (range.m_TStart > oldRange.m_TStart && range.m_TEnd > oldRange.m_TEnd) {
zoomType = AcquisitionZoomType::PanRight;
}
else if (range.m_TStart < oldRange.m_TStart && range.m_TEnd < oldRange.m_TEnd) {
zoomType = AcquisitionZoomType::PanLeft;
}
else if (range.m_TStart > oldRange.m_TStart && oldRange.m_TEnd > range.m_TEnd) {
zoomType = AcquisitionZoomType::ZoomIn;
}
else {
qCCritical(LOG_VariableController()) << "getZoomType: Unknown type detected";
}
return zoomType;
}
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500
perrinel
Implementation of V5 acquisition
 r510 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
perrinel
Add implementation of the Var Acquisition waiting
 r585 const SqpRange &rangeRequested,
QUuid varRequestId)
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500 {
perrinel
Add implementation of the Var Acquisition waiting
 r585 // TODO: protect at
auto varRequest = VariableRequest{};
auto varId = m_VariableToIdentifierMap.at(var);
auto varStrategyRangesRequested
= m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
auto notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
auto inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
perrinel
Implementation of V5 acquisition
 r510
if (!notInCacheRangeList.empty()) {
perrinel
Add implementation of the Var Acquisition waiting
 r585 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest RR ") << rangeRequested;
qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest R ")
<< varStrategyRangesRequested.first;
qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest CR ")
<< varStrategyRangesRequested.second;
perrinel
Add implementation of the Var Acquisition waiting
 r585 // store VarRequest
storeVariableRequest(varId, varRequestId, varRequest);
perrinel
Implementation of V5 acquisition
 r510 auto varProvider = m_VariableToProviderMap.at(var);
if (varProvider != nullptr) {
perrinel
Add implementation of the Var Acquisition waiting
 r585 auto varRequestIdCanceled = m_VariableAcquisitionWorker->pushVariableRequest(
varRequestId, varId, varStrategyRangesRequested.first,
varStrategyRangesRequested.second,
perrinel
Implementation of V5 acquisition
 r510 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
varProvider);
perrinel
Add implementation of the Var Acquisition waiting
 r585
if (!varRequestIdCanceled.isNull()) {
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
<< varRequestIdCanceled;
perrinel
Add implementation of the Var Acquisition waiting
 r585 cancelVariableRequest(varRequestIdCanceled);
}
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500 }
else {
perrinel
Implementation of V5 acquisition
 r510 qCCritical(LOG_VariableController())
<< "Impossible to provide data with a null provider";
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500 }
perrinel
add Skeleton for displaying data which are already in cache
 r538
if (!inCacheRangeList.empty()) {
emit q->updateVarDisplaying(var, inCacheRangeList.first());
}
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500 }
perrinel
Implementation of V5 acquisition
 r510 else {
perrinel
Add implementation of the Var Acquisition waiting
 r585
varRequest.m_RangeRequested = varStrategyRangesRequested.first;
varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
// store VarRequest
storeVariableRequest(varId, varRequestId, varRequest);
acceptVariableRequest(varId,
var->dataSeries()->subDataSeries(varStrategyRangesRequested.second));
perrinel
Implementation of V5 acquisition
 r510 }
}
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;
}
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500
perrinel
Implementation of V5 acquisition
 r510 return var;
}
std::shared_ptr<IDataSeries> VariableController::VariableControllerPrivate::retrieveDataSeries(
const QVector<AcquisitionDataPacket> acqDataPacketVector)
{
perrinel
The dataSeries of a variable is now shared istead of uniq to avoid...
 r513 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size")
<< acqDataPacketVector.size();
perrinel
Implementation of V5 acquisition
 r510 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());
}
}
perrinel
The dataSeries of a variable is now shared istead of uniq to avoid...
 r513 qCDebug(LOG_VariableController()) << tr("TORM: retrieveDataSeries acqDataPacketVector size END")
<< acqDataPacketVector.size();
perrinel
Implementation of V5 acquisition
 r510 return dataSeries;
}
void VariableController::VariableControllerPrivate::registerProvider(
std::shared_ptr<IDataProvider> provider)
{
if (m_ProviderSet.find(provider) == m_ProviderSet.end()) {
perrinel
The dataSeries of a variable is now shared istead of uniq to avoid...
 r513 qCDebug(LOG_VariableController()) << tr("Registering of a new provider")
<< provider->objectName();
perrinel
Implementation of V5 acquisition
 r510 m_ProviderSet.insert(provider);
connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
&VariableAcquisitionWorker::onVariableDataAcquired);
connect(provider.get(), &IDataProvider::dataProvidedProgress,
m_VariableAcquisitionWorker.get(),
&VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
}
else {
perrinel
Add synchronization part of v5 acquisition
 r511 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
perrinel
Implementation of V5 acquisition
 r510 }
perrinel
Add code of ProvideNotInCacheRange in VC controller
 r500 }
perrinel
Add implementation of the Var Acquisition waiting
 r585
void VariableController::VariableControllerPrivate::storeVariableRequest(
QUuid varId, QUuid varRequestId, const VariableRequest &varRequest)
{
// First request for the variable. we can create an entry for it
auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
if (varIdToVarRequestIdQueueMapIt == m_VarIdToVarRequestIdQueueMap.cend()) {
auto varRequestIdQueue = std::deque<QUuid>{};
qCDebug(LOG_VariableController()) << tr("Store REQUEST in QUEUE");
varRequestIdQueue.push_back(varRequestId);
m_VarIdToVarRequestIdQueueMap.insert(std::make_pair(varId, std::move(varRequestIdQueue)));
}
else {
qCDebug(LOG_VariableController()) << tr("Store REQUEST in EXISTING QUEUE");
auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
varRequestIdQueue.push_back(varRequestId);
}
auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
if (varRequestIdToVarIdVarRequestMapIt == m_VarRequestIdToVarIdVarRequestMap.cend()) {
auto varIdToVarRequestMap = std::map<QUuid, VariableRequest>{};
varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
qCDebug(LOG_VariableController()) << tr("Store REQUESTID in MAP");
m_VarRequestIdToVarIdVarRequestMap.insert(
std::make_pair(varRequestId, std::move(varIdToVarRequestMap)));
}
else {
auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
qCDebug(LOG_VariableController()) << tr("Store REQUESTID in EXISTING MAP");
varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
}
}
QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
{
QUuid varRequestId;
auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
varRequestId = varRequestIdQueue.front();
auto varRequestIdToVarIdVarRequestMapIt
= m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
auto &varRequest = varIdToVarRequestMapIt->second;
varRequest.m_DataSeries = dataSeries;
varRequest.m_CanUpdate = true;
}
else {
qCDebug(LOG_VariableController())
<< tr("Impossible to acceptVariableRequest of a unknown variable id attached "
"to a variableRequestId")
<< varRequestId << varId;
}
}
else {
qCCritical(LOG_VariableController())
<< tr("Impossible to acceptVariableRequest of a unknown variableRequestId")
<< varRequestId;
}
qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in QUEUE ?")
<< varRequestIdQueue.size();
varRequestIdQueue.pop_front();
qCDebug(LOG_VariableController()) << tr("2: erase REQUEST in QUEUE ?")
<< varRequestIdQueue.size();
if (varRequestIdQueue.empty()) {
m_VarIdToVarRequestIdQueueMap.erase(varId);
}
}
else {
qCCritical(LOG_VariableController())
<< tr("Impossible to acceptVariableRequest of a unknown variable id") << varId;
}
return varRequestId;
}
void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
{
auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
bool processVariableUpdate = true;
auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
(varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
++varIdToVarRequestMapIt) {
processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
<< processVariableUpdate;
}
if (processVariableUpdate) {
for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
varIdToVarRequestMapIt != varIdToVarRequestMap.cend(); ++varIdToVarRequestMapIt) {
if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
auto &varRequest = varIdToVarRequestMapIt->second;
var->setRange(varRequest.m_RangeRequested);
var->setCacheRange(varRequest.m_CacheRangeRequested);
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
<< varRequest.m_RangeRequested;
qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
<< varRequest.m_CacheRangeRequested;
perrinel
Add implementation of the Var Acquisition waiting
 r585 var->mergeDataSeries(varRequest.m_DataSeries);
perrinel
Next range of a variable synchronized is now computed using:...
 r586 qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
<< varRequest.m_DataSeries->range();
perrinel
Add implementation of the Var Acquisition waiting
 r585 qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
Alexandre Leroux
Blocks UI update of a variable while it has pending requests
 r649
/// @todo MPL: confirm
// Variable update is notified only if there is no pending request for it
if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
emit var->updated();
}
perrinel
Add implementation of the Var Acquisition waiting
 r585 }
else {
qCCritical(LOG_VariableController())
<< tr("Impossible to update data to a null variable");
}
}
// cleaning varRequestId
qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in MAP ?")
<< m_VarRequestIdToVarIdVarRequestMap.size();
m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in MAP ?")
<< m_VarRequestIdToVarIdVarRequestMap.size();
}
}
else {
qCCritical(LOG_VariableController())
<< tr("Cannot updateVariableRequest for a unknow varRequestId") << varRequestId;
}
}
void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
{
// cleaning varRequestId
m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
varRequestIdQueue.erase(
std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(), varRequestId),
varRequestIdQueue.end());
if (varRequestIdQueue.empty()) {
varIdToVarRequestIdQueueMapIt
= m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
}
else {
++varIdToVarRequestIdQueueMapIt;
}
}
}