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
-                  * or if the variable isn't in it, the method does nothing
+                  * Removes a variable from its synchronization group. If the variable isn't in a synchronization
+                  * 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,
-                                                       GroupId groupId) noexcept
+             void VariableSynchronizer::removeVariable(std::shared_ptr<Variable> variable) noexcept
              {
-                 auto groupIt = impl->m_Groups.find(groupId);
-                 if (groupIt == impl->m_Groups.end()) {
-                     qCWarning(LOG_VariableSynchronizer())
-                         << tr("Can't remove variable from synchronization group: no group exists under the "
-                               "passed identifier");
-                     return;
+                 }
+                 // 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(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