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

                 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);

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

                 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)

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

                 this->waitForFinish();
             }
+            void VariableAcquisitionWorker::cancelVariableRequest(std::shared_ptr<Variable> variable)
+            {
+                /// @todo ALX
+            }
             void VariableAcquisitionWorker::pushVariableRequest(std::shared_ptr<Variable> variable,
                                                                 VariableRequest request)
             {
                     auto &acquisition = it->second;
                     auto &request = acquisition.m_Request;
-                    qInfo(LOG_VariableAcquisitionWorker()) << "Data acquired for " << printRange(range);
                     // Store the result
                     request.addResult(dataSeries);

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

                 // 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())
             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,

core/src/Variable/VariableSynchronizer.cpp +15 -16

             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
                 }
                 // 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));
                 }
                 // Removes indexes
-                for (const auto &variable : groupIt->second) {
+                for (const auto &variable : groupIt->second.m_Variables) {
                     impl->m_GroupsIndex.erase(variable);
                 }
                 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 (groupIt == impl->m_Groups.end()) {
+                if (variableGroupIt != impl->m_GroupsIndex.end()) {
-                    qCWarning(LOG_VariableSynchronizer())
+                    auto groupId = variableGroupIt->second->m_Id;
-                        << tr("Can't remove variable from synchronization group: no group exists under the "
-                              "passed identifier");
-                    return;
                     // Removes variable index
-                impl->m_GroupsIndex.erase(variable);
+                    impl->m_GroupsIndex.erase(variableGroupIt);
                     // Removes variable from group
-                groupIt->second.erase(variable);
+                    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
+                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