GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r684:90684a2a46fa

commit

Alexandre Leroux -

r684:90684a2a46fa

parent child

Context file:

r684:90684a2a46fa

Collapse all files

core/include/Variable/VariableAcquisitionWorker.h +1 0

             #ifndef SCIQLOP_VARIABLEACQUISITIONWORKER_H
             #define SCIQLOP_VARIABLEACQUISITIONWORKER_H
             #include "CoreGlobal.h"
             #include <Data/DataProviderParameters.h>
             #include <QLoggingCategory>
             #include <QObject>
             #include <QUuid>
             #include <Data/AcquisitionDataPacket.h>
             #include <Data/IDataSeries.h>
             #include <Data/SqpRange.h>
             #include <Data/VariableRequest.h>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker)
             class Variable;
             class IDataProvider;
             /// This class aims to handle all acquisition request
             class SCIQLOP_CORE_EXPORT VariableAcquisitionWorker : public QObject {
                 Q_OBJECT
             public:
                 explicit VariableAcquisitionWorker(QObject *parent = 0);
                 virtual ~VariableAcquisitionWorker();
+                void cancelVariableRequest(std::shared_ptr<Variable> variable);
                 void pushVariableRequest(std::shared_ptr<Variable> variable, VariableRequest request);
                 void abortProgressRequested(QUuid vIdentifier);
                 void initialize();
                 void finalize();
             signals:
                 void dataProvided(std::shared_ptr<Variable> variable, VariableRequest request);
                 void variableRequestInProgress(QUuid vIdentifier, double progress);
             public slots:
                 void onDataAcquired(QUuid acquisitionId, std::shared_ptr<IDataSeries> dataSeries,
                                     SqpRange range);
                 void onVariableAcquisitionCanceled(QUuid acqIdentifier);
                 void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
             private:
                 void waitForFinish();
                 class VariableAcquisitionWorkerPrivate;
                 spimpl::unique_impl_ptr<VariableAcquisitionWorkerPrivate> impl;
             private slots:
                 void executeAcquisition(QUuid acquisitionId);
             };
             #endif // SCIQLOP_VARIABLEACQUISITIONWORKER_H

core/include/Variable/VariableSynchronizer.h +3 -4

             #ifndef SCIQLOP_VARIABLESYNCHRONIZER_H
             #define SCIQLOP_VARIABLESYNCHRONIZER_H
             #include "CoreGlobal.h"
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QUuid>
             #include <memory>
             #include <set>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VariableSynchronizer)
             class Variable;
             /**
              * @brief The VariableAcquisitionWorker class handles synchronization between variables
              */
             class SCIQLOP_CORE_EXPORT VariableSynchronizer : public QObject {
                 Q_OBJECT
             public:
                 using GroupId = QUuid;
                 explicit VariableSynchronizer(QObject *parent = 0);
                 /**
                  * Adds a synchronization group under the identifier passed as a parameter. If a group with this
                  * identifier already exists, the method does nothing.
                  * @param groupId the group identifier
                  */
                 void addGroup(GroupId groupId) noexcept;
                 /**
                  * Adds a variable to a synchronization group. If the variable is already registered under
                  * another group, or the synchronization doesn't exist, the method does nothing
                  * @param variable the variable to synchronize
                  * @param groupId the synchronization group identifier
                  */
                 void addVariable(std::shared_ptr<Variable> variable, GroupId groupId) noexcept;
                 /**
                  * Removes the synchronization group under the identifier passed as a parameter. If no group
                  * exists with this identifier, the method does nothing.
                  * @param groupId the group identifier
                  */
                 void removeGroup(GroupId groupId) noexcept;
                 /**
-                 * Removes a variable from a synchronization group. If the synchronization group doesn't exist
+                 * Removes a variable from its synchronization group. If the variable isn't in a synchronization
-                 * or if the variable isn't in it, the method does nothing
+                 * group, the method does nothing
                  * @param variable the variable to desynchronize
-                 * @param groupId the synchronization group identifier
                  */
-                void removeVariable(std::shared_ptr<Variable> variable, GroupId groupId) noexcept;
+                void removeVariable(std::shared_ptr<Variable> variable) noexcept;
                 /// @return the variables in the same group than the variable passed as a parameter (including
                 /// the variable)
                 std::set<std::shared_ptr<Variable> >
                 synchronizedVariables(std::shared_ptr<Variable> variable) const noexcept;
             private:
                 class VariableSynchronizerPrivate;
                 spimpl::unique_impl_ptr<VariableSynchronizerPrivate> impl;
             };
             #endif // SCIQLOP_VARIABLESYNCHRONIZER_H

core/src/Variable/VariableAcquisitionWorker.cpp +5 -2

             #include "Variable/VariableAcquisitionWorker.h"
             #include "Variable/Variable.h"
             #include <Data/IDataProvider.h>
             #include <Data/SqpRange.h>
             #include <unordered_map>
             #include <utility>
             #include <QMutex>
             #include <QReadWriteLock>
             #include <QThread>
             #include <QtConcurrent/QtConcurrent>
             Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
             namespace {
             using AcquisitionId = QUuid;
             using VariableId = QUuid;
             struct Acquisition {
                 std::shared_ptr<Variable> m_Variable{nullptr};
                 VariableRequest m_Request{};
                 AcquisitionId m_Id{QUuid::createUuid()};
             };
             } // namespace
             struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
                 explicit VariableAcquisitionWorkerPrivate() : m_Lock{QReadWriteLock::Recursive} {}
                 void lockRead() { m_Lock.lockForRead(); }
                 void lockWrite() { m_Lock.lockForWrite(); }
                 void unlock() { m_Lock.unlock(); }
                 void eraseAcquisition(AcquisitionId id)
                 {
                     auto it = m_Acquisitions.find(id);
                     if (it != m_Acquisitions.end()) {
                         // Removes from index
                         m_AcquisitionsIndex.erase(it->second.m_Variable);
                         // Removes request
                         m_Acquisitions.erase(it);
                     }
                 }
                 std::map<AcquisitionId, Acquisition>::iterator insertAcquisition(Acquisition acquisition)
                 {
                     auto variable = acquisition.m_Variable;
                     // Inserts acquisition
                     auto result
                         = m_Acquisitions.insert(std::make_pair(acquisition.m_Id, std::move(acquisition)));
                     if (result.second) {
                         // Inserts index
                         m_AcquisitionsIndex[variable] = &result.first->second;
                         return result.first;
                     }
                     else {
                         return m_Acquisitions.end();
                     }
                 }
                 QMutex m_WorkingMutex;
                 QReadWriteLock m_Lock;
                 std::map<AcquisitionId, Acquisition> m_Acquisitions;
                 std::map<std::shared_ptr<Variable>, Acquisition *> m_AcquisitionsIndex;
             };
             VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
             {
             }
             VariableAcquisitionWorker::~VariableAcquisitionWorker()
             {
                 qCInfo(LOG_VariableAcquisitionWorker())
                     << tr("VariableAcquisitionWorker destruction") << QThread::currentThread();
                 this->waitForFinish();
             }
+            void VariableAcquisitionWorker::cancelVariableRequest(std::shared_ptr<Variable> variable)
+            {
+                /// @todo ALX
+            }
             void VariableAcquisitionWorker::pushVariableRequest(std::shared_ptr<Variable> variable,
                                                                 VariableRequest request)
             {
                 impl->lockWrite();
                 // Checks if there is a current request for variable
                 auto oldAcquisitionIt = impl->m_AcquisitionsIndex.find(variable);
                 if (oldAcquisitionIt != impl->m_AcquisitionsIndex.cend()) {
                     auto &oldAcquisition = *oldAcquisitionIt->second;
                     /// @todo ALX
                     //        QtConcurrent::run(
                     //            [ provider = request->m_Provider, acqIdentifier = request->m_AcqIdentifier ]()
                     //            {
                     //                provider->requestDataAborting(acqIdentifier);
                     //            });
                     impl->eraseAcquisition(oldAcquisition.m_Id);
                 }
                 // Sets request for variable
                 Acquisition newAcquisition{variable, std::move(request)};
                 auto newAcquisitionIt = impl->insertAcquisition(std::move(newAcquisition));
                 if (newAcquisitionIt != impl->m_Acquisitions.end()) {
                     impl->unlock();
                     QMetaObject::invokeMethod(this, "executeAcquisition", Qt::QueuedConnection,
                                               Q_ARG(QUuid, newAcquisitionIt->first));
                 }
                 else {
                     impl->unlock();
                 }
             }
             void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
             {
                 // TODO
             }
             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
                 // TODO
             }
             void VariableAcquisitionWorker::onDataAcquired(QUuid acquisitionId,
                                                            std::shared_ptr<IDataSeries> dataSeries,
                                                            SqpRange range)
             {
                 impl->lockWrite();
                 auto it = impl->m_Acquisitions.find(acquisitionId);
                 if (it != impl->m_Acquisitions.cend()) {
                     auto &acquisition = it->second;
                     auto &request = acquisition.m_Request;
-                    qInfo(LOG_VariableAcquisitionWorker()) << "Data acquired for " << printRange(range);
                     // Store the result
                     request.addResult(dataSeries);
                     if (request.isFinished()) {
                         emit dataProvided(acquisition.m_Variable, std::move(request));
                         impl->eraseAcquisition(acquisitionId);
                     }
                 }
                 impl->unlock();
             }
             void VariableAcquisitionWorker::onVariableAcquisitionCanceled(QUuid acqIdentifier)
             {
             }
             void VariableAcquisitionWorker::initialize()
             {
                 qCDebug(LOG_VariableAcquisitionWorker())
                     << tr("VariableAcquisitionWorker init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
             }
             void VariableAcquisitionWorker::finalize()
             {
                 impl->m_WorkingMutex.unlock();
             }
             void VariableAcquisitionWorker::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};
             }
             void VariableAcquisitionWorker::executeAcquisition(QUuid acquisitionId)
             {
                 impl->lockRead();
                 auto it = impl->m_Acquisitions.find(acquisitionId);
                 if (it != impl->m_Acquisitions.cend()) {
                     auto &request = it->second.m_Request;
                     impl->unlock();
                     request.m_Provider->requestDataLoading(acquisitionId, request.m_ProviderParameters);
                 }
                 else {
                     impl->unlock();
                     // TODO log no acqIdentifier recognized
                 }
             }

core/src/Variable/VariableController.cpp +9 -1

             #include <Variable/Variable.h>
             #include <Variable/VariableAcquisitionWorker.h>
             #include <Variable/VariableCacheStrategy.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Variable/VariableSynchronizer.h>
             #include <Data/AcquisitionUtils.h>
             #include <Data/DataProviderParameters.h>
             #include <Data/IDataProvider.h>
             #include <Data/IDataSeries.h>
             #include <Data/VariableRequest.h>
             #include <Time/TimeController.h>
             #include <QMutex>
             #include <QThread>
             #include <QUuid>
             #include <QtCore/QItemSelectionModel>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
             namespace {
             SqpRange computeSynchroRangeRequested(const SqpRange &varRange, const SqpRange &graphRange,
                                                   const SqpRange &oldGraphRange)
             {
                 auto zoomType = AcquisitionUtils::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 deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         varRangeRequested.m_TStart += deltaRight;
                         varRangeRequested.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         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;
             }
             } // namespace
             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_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
                           m_VariableSynchronizer{std::make_unique<VariableSynchronizer>()},
                           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> variable, const SqpRange &rangeRequested)
                 {
                     Q_ASSERT(variable != nullptr);
                     if (!m_VariableModel->containsVariable(variable)) {
                         qCCritical(LOG_VariableController())
                             << QObject::tr("Can't process request for variable %1: variable is not registered")
                                    .arg(variable->name());
                         return;
                     }
                     variable->setRange(rangeRequested);
                     // Gets ranges in/out of variable range
                     auto requestRange
                         = m_VariableCacheStrategy->computeStrategyRanges(variable->range(), rangeRequested);
                     auto notInCacheRanges = variable->provideNotInCacheRangeList(requestRange.second);
                     // Creates request for out-of-cache ranges
                     if (!notInCacheRanges.isEmpty()) {
                         // Gets provider for request
                         if (auto provider = m_Providers.at(variable)) {
                             DataProviderParameters providerParameters{std::move(notInCacheRanges),
                                                                       variable->metadata()};
                             VariableRequest request{requestRange.first, requestRange.second, provider,
                                                     std::move(providerParameters)};
                             m_VariableAcquisitionWorker->pushVariableRequest(variable, std::move(request));
                         }
                         // Calls UI update for in-cache range
                         auto inCacheRanges = variable->provideInCacheRangeList(requestRange.second);
                         if (!inCacheRanges.isEmpty()) {
                             emit q->updateVarDisplaying(variable, inCacheRanges.first());
                         }
                     }
                     else {
                         // No request to make: we simply update variable ranges
                         variable->setCacheRange(requestRange.second);
                         emit variable->updated();
                     }
                 }
                 void registerProvider(std::shared_ptr<IDataProvider> provider)
                 {
                     Q_ASSERT(provider != nullptr);
                     connect(provider.get(), &IDataProvider::dataProvided, m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onDataAcquired);
                     connect(provider.get(), &IDataProvider::dataProvidedProgress,
                             m_VariableAcquisitionWorker.get(),
                             &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
                 }
                 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;
                 /// Handler for variables synchronization
                 std::unique_ptr<VariableSynchronizer> m_VariableSynchronizer;
                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> > m_Providers;
                 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::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();
             }
             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);
                     // Registers provider
                     auto variableProvider = impl->m_Providers.at(variable);
                     auto duplicateProvider = variableProvider != nullptr ? variableProvider->clone() : nullptr;
                     impl->m_Providers[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);
+                // Deletes from synchronization group
+                impl->m_VariableSynchronizer->removeVariable(variable);
+                // Cancels pending requests
+                impl->m_VariableAcquisitionWorker->cancelVariableRequest(variable);
                 // Deletes provider
                 auto nbProvidersDeleted = impl->m_Providers.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);
                 }
             }
             void VariableController::abortProgress(std::shared_ptr<Variable> variable)
             {
             }
             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, range, metadata)) {
                     // Associate the provider
                     auto newVariableProvider = provider != nullptr ? provider->clone() : nullptr;
                     impl->m_Providers[newVariable] = newVariableProvider;
                     if (newVariableProvider) {
                         impl->registerProvider(newVariableProvider);
                     }
                     impl->processRequest(newVariable, range);
                     return newVariable;
                 }
             }
             void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
             {
                 // TODO check synchronisation and Rescale
                 qCDebug(LOG_VariableController())
                     << "VariableController::onDateTimeOnSelection" << QThread::currentThread()->objectName();
                 auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
                         selectedVariable->setRange(dateTime);
                         impl->processRequest(selectedVariable, dateTime);
                         // notify that rescale operation has to be done
                         emit rangeChanged(selectedVariable, dateTime);
                     }
                 }
             }
             void VariableController::onDataProvided(std::shared_ptr<Variable> variable, VariableRequest request)
             {
                 Q_ASSERT(variable != nullptr);
                 if (!impl->m_VariableModel->containsVariable(variable)) {
                     qCCritical(LOG_VariableController())
                         << QObject::tr("Can't update date of variable %1: variable is not registered (anymore)")
                                .arg(variable->name());
                     return;
                 }
                 variable->setCacheRange(request.m_CacheRangeRequested);
                 variable->mergeDataSeries(request.m_Result);
                 emit variable->updated();
             }
             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
                 /// @todo ALX
                 //    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)
             {
                 /// @todo ALX
                 //    qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
                 //                                      << QThread::currentThread()->objectName();
                 //    auto it = impl->m_VariableToIdentifierMap.find(variable);
                 //    if (it != impl->m_VariableToIdentifierMap.cend()) {
                 //        impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
                 //    }
                 //    else {
                 //        qCWarning(LOG_VariableController())
                 //            << tr("Aborting progression of inexistant variable detected !!!")
                 //            << QThread::currentThread()->objectName();
                 //    }
             }
             void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_VariableSynchronizer->addGroup(synchronizationGroupId);
             }
             void VariableController::onRemoveSynchronizationGroupId(QUuid synchronizationGroupId)
             {
                 impl->m_VariableSynchronizer->removeGroup(synchronizationGroupId);
             }
             void VariableController::onAddSynchronized(std::shared_ptr<Variable> variable,
                                                        QUuid synchronizationGroupId)
             {
                 impl->m_VariableSynchronizer->addVariable(variable, synchronizationGroupId);
             }
             void VariableController::desynchronize(std::shared_ptr<Variable> variable,
                                                    QUuid synchronizationGroupId)
             {
-                impl->m_VariableSynchronizer->removeVariable(variable, synchronizationGroupId);
+                // As a variable can't be into more than one synchronization group,we don't need group id here
+                Q_UNUSED(synchronizationGroupId);
+                impl->m_VariableSynchronizer->removeVariable(variable);
             }
             void VariableController::onRequestDataLoading(const QVector<std::shared_ptr<Variable> > &variables,
                                                           const SqpRange &range, const SqpRange &oldRange,
                                                           bool synchronise)
             {
                 // Set of variables that have been processed
                 std::set<std::shared_ptr<Variable> > processedVariables;
                 std::map<std::shared_ptr<Variable>, SqpRange> oldRanges;
                 // Process requests for all variables
                 for (const auto &var : variables) {
                     impl->processRequest(var, range);
                     processedVariables.insert(var);
                 }
                 // Handles synchronisation
                 if (synchronise) {
                     for (const auto &variable : variables) {
                         // Finds the variables in the same synchronization group
                         auto synchronizedVariables
                             = impl->m_VariableSynchronizer->synchronizedVariables(variable);
                         for (const auto &synchronizedVariable : synchronizedVariables) {
                             // Processes variable (if it hasn't been already processed)
                             if (processedVariables.count(synchronizedVariable) == 0) {
                                 auto rangeRequested = computeSynchroRangeRequested(
                                     synchronizedVariable->range(), range, oldRange);
                                 impl->processRequest(synchronizedVariable, rangeRequested);
                                 processedVariables.insert(synchronizedVariable);
                             }
                         }
                     }
                 }
             }
             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};
             }

core/src/Variable/VariableSynchronizer.cpp +17 -18

             #include "Variable/VariableSynchronizer.h"
             #include "Variable/Variable.h"
             Q_LOGGING_CATEGORY(LOG_VariableSynchronizer, "VariableSynchronizer")
             namespace {
             using GroupId = VariableSynchronizer::GroupId;
-            using Group = std::set<std::shared_ptr<Variable> >;
+            struct Group {
+                GroupId m_Id;
+                std::set<std::shared_ptr<Variable> > m_Variables;
+            };
             } // namespace
             struct VariableSynchronizer::VariableSynchronizerPrivate {
                 std::map<GroupId, Group> m_Groups;
                 std::map<std::shared_ptr<Variable>, Group *> m_GroupsIndex;
             };
             VariableSynchronizer::VariableSynchronizer(QObject *parent)
                     : QObject{parent}, impl{spimpl::make_unique_impl<VariableSynchronizerPrivate>()}
             {
             }
             void VariableSynchronizer::addGroup(GroupId groupId) noexcept
             {
                 if (impl->m_Groups.count(groupId) == 1) {
                     qCWarning(LOG_VariableSynchronizer())
                         << tr("Can't create new synchronization group: a "
                               "group already exists under the passed identifier");
                     return;
                 }
                 impl->m_Groups.insert(std::make_pair(groupId, Group{}));
             }
             void VariableSynchronizer::addVariable(std::shared_ptr<Variable> variable, GroupId groupId) noexcept
             {
                 if (impl->m_GroupsIndex.count(variable) == 1) {
                     qCWarning(LOG_VariableSynchronizer())
                         << tr("Can't add variable to a new synchronization group: the variable is already in a "
                               "synchronization group");
                     return;
                 }
                 auto groupIt = impl->m_Groups.find(groupId);
                 if (groupIt == impl->m_Groups.end()) {
                     qCWarning(LOG_VariableSynchronizer())
                         << tr("Can't add variable to the synchronization group: no group exists under the "
                               "passed identifier");
                     return;
                 }
                 // Registers variable
-                groupIt->second.insert(variable);
+                groupIt->second.m_Variables.insert(variable);
                 // Creates index for variable
                 impl->m_GroupsIndex.insert(std::make_pair(variable, &groupIt->second));
             }
             void VariableSynchronizer::removeGroup(GroupId groupId) noexcept
             {
                 auto groupIt = impl->m_Groups.find(groupId);
                 if (groupIt == impl->m_Groups.end()) {
                     qCWarning(LOG_VariableSynchronizer()) << tr(
                         "Can't remove synchronization group: no group exists under the passed identifier");
                     return;
                 }
                 // Removes indexes
-                for (const auto &variable : groupIt->second) {
+                for (const auto &variable : groupIt->second.m_Variables) {
                     impl->m_GroupsIndex.erase(variable);
                 }
                 // Removes group
                 impl->m_Groups.erase(groupIt);
             }
-            void VariableSynchronizer::removeVariable(std::shared_ptr<Variable> variable,
+            void VariableSynchronizer::removeVariable(std::shared_ptr<Variable> variable) noexcept
-                                                      GroupId groupId) noexcept
             {
-                auto groupIt = impl->m_Groups.find(groupId);
+                // Finds group in which the variable is
+                auto variableGroupIt = impl->m_GroupsIndex.find(variable);
+                if (variableGroupIt != impl->m_GroupsIndex.end()) {
+                    auto groupId = variableGroupIt->second->m_Id;
-                if (groupIt == impl->m_Groups.end()) {
+                    // Removes variable index
-                    qCWarning(LOG_VariableSynchronizer())
+                    impl->m_GroupsIndex.erase(variableGroupIt);
-                        << tr("Can't remove variable from synchronization group: no group exists under the "
-                              "passed identifier");
-                    return;
-                // Removes variable index
+                    // Removes variable from group
-                impl->m_GroupsIndex.erase(variable);
+                    impl->m_Groups[groupId].m_Variables.erase(variable);
+                }
-                // Removes variable from group
-                groupIt->second.erase(variable);
             }
             std::set<std::shared_ptr<Variable> >
             VariableSynchronizer::synchronizedVariables(std::shared_ptr<Variable> variable) const noexcept
             {
                 auto groupIndexIt = impl->m_GroupsIndex.find(variable);
-                return groupIndexIt != impl->m_GroupsIndex.end() ? *groupIndexIt->second
+                return groupIndexIt != impl->m_GroupsIndex.end() ? groupIndexIt->second->m_Variables
                                                                  : std::set<std::shared_ptr<Variable> >{};
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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