GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r685:9917b9ec9087

commit

Alexandre Leroux -

r685:9917b9ec9087 feature/LimitNbRe...

parent child

Context file:

r685:9917b9ec9087

Collapse all files

core/src/Variable/VariableAcquisitionWorker.cpp +32 -11

             #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)
+                void cancelAcquisition(AcquisitionId id)
                 {
                     auto it = m_Acquisitions.find(id);
                     if (it != m_Acquisitions.end()) {
+                        const auto &request = it->second.m_Request;
+                        QtConcurrent::run([ provider = request.m_Provider, acqIdentifier = id ]() {
+                            provider->requestDataAborting(acqIdentifier);
+                        });
+                        eraseAcquisition(it);
+                    }
+                }
+                /// Removes from acquisitions and its indexes the acquisition represented by the iterator passed
+                /// as a parameter
+                void eraseAcquisition(std::map<AcquisitionId, Acquisition>::iterator it)
+                {
+                    if (it != m_Acquisitions.end()) {
                         // Removes from index
                         m_AcquisitionsIndex.erase(it->second.m_Variable);
                         // Removes request
                         m_Acquisitions.erase(it);
                     }
                 }
+                /// Removes from acquisitions and its indexes the acquisition represented by the identifier
+                /// passed as a parameter
+                void eraseAcquisition(AcquisitionId id) { eraseAcquisition(m_Acquisitions.find(id)); }
                 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
+                impl->lockWrite();
+                // Gets the current acquisition for the variable (if it exists) and cancels the request
+                // associated
+                auto it = impl->m_AcquisitionsIndex.find(variable);
+                if (it != impl->m_AcquisitionsIndex.end()) {
+                    impl->cancelAcquisition(it->second->m_Id);
+                }
+                impl->unlock();
             }
             void VariableAcquisitionWorker::pushVariableRequest(std::shared_ptr<Variable> variable,
                                                                 VariableRequest request)
             {
                 impl->lockWrite();
-                // Checks if there is a current request for variable
+                // Checks if there is a current request for variable and cancels it
                 auto oldAcquisitionIt = impl->m_AcquisitionsIndex.find(variable);
                 if (oldAcquisitionIt != impl->m_AcquisitionsIndex.cend()) {
                     auto &oldAcquisition = *oldAcquisitionIt->second;
-                    /// @todo ALX
+                    impl->cancelAcquisition(oldAcquisition.m_Id);
-                    //        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;
                     // 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/VariableSynchronizer.cpp +1 -1

             #include "Variable/VariableSynchronizer.h"
             #include "Variable/Variable.h"
             Q_LOGGING_CATEGORY(LOG_VariableSynchronizer, "VariableSynchronizer")
             namespace {
             using GroupId = VariableSynchronizer::GroupId;
             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{}));
+                impl->m_Groups.insert(std::make_pair(groupId, Group{groupId}));
             }
             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.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.m_Variables) {
                     impl->m_GroupsIndex.erase(variable);
                 }
                 // Removes group
                 impl->m_Groups.erase(groupIt);
             }
             void VariableSynchronizer::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // 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;
                     // Removes variable index
                     impl->m_GroupsIndex.erase(variableGroupIt);
                     // Removes variable from group
                     impl->m_Groups[groupId].m_Variables.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->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