]> SALOME platform Git repositories - modules/shaper.git/commitdiff
Salome HOME
Optimization of working in big document (like Usine EDF case with near to 10000 featu...
authormpv <mpv@opencascade.com>
Mon, 10 Dec 2018 12:53:27 +0000 (15:53 +0300)
committermpv <mpv@opencascade.com>
Mon, 10 Dec 2018 12:53:53 +0000 (15:53 +0300)
1. Working with current feature (on add of the new feature).
2. Creation of the unique name of the feature.

src/Model/Model_Document.cpp
src/Model/Model_Objects.cpp
src/Model/Model_Objects.h

index 7d0feab8bf87c8c3e2d1aa6613dcfd3399e0250b..99a624ae09f4746f66d7ef5f9a21596db44d6cf9 100755 (executable)
@@ -1083,8 +1083,9 @@ void Model_Document::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
   FeaturePtr anAfterThisSub = theAfterThis;
   if (aCompositeAfter.get()) {
     FeaturePtr aSub = aCompositeAfter;
+    int anIndex = kUNDEFINED_FEATURE_INDEX;
     do {
-      FeaturePtr aNext = myObjs->nextFeature(aSub);
+      FeaturePtr aNext = myObjs->nextFeature(aSub, anIndex);
       if (!isSub(aCompositeAfter, aNext)) {
         anAfterThisSub = aSub;
         break;
@@ -1180,8 +1181,9 @@ std::shared_ptr<ModelAPI_Feature> Model_Document::currentFeature(const bool theV
     TDF_Label aLab = aRef->Get();
     FeaturePtr aResult = myObjs->feature(aLab);
     if (theVisible) { // get nearest visible (in history) going up
+      int anIndex = kUNDEFINED_FEATURE_INDEX;
       while(aResult.get() &&  !aResult->isInHistory()) {
-        aResult = myObjs->nextFeature(aResult, true);
+        aResult = myObjs->nextFeature(aResult, anIndex, true);
       }
     }
     return aResult;
@@ -1217,9 +1219,10 @@ void Model_Document::setCurrentFeature(
 
   if (theVisible && !theCurrent.get()) {
     // needed to avoid disabling of PartSet initial constructions
+    int anIndex = kUNDEFINED_FEATURE_INDEX;
     FeaturePtr aNext =
-      theCurrent.get() ? myObjs->nextFeature(theCurrent) : myObjs->firstFeature();
-    for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent)) {
+      theCurrent.get() ? myObjs->nextFeature(theCurrent, anIndex, false) : myObjs->firstFeature();
+    for (; aNext.get(); aNext = myObjs->nextFeature(theCurrent, anIndex, false)) {
       if (aNext->isInHistory()) {
         break; // next in history is not needed
       } else { // next not in history is good for making current
@@ -1253,7 +1256,8 @@ void Model_Document::setCurrentFeature(
   FeaturePtr anIter = myObjs->lastFeature();
   bool aWasChanged = false;
   bool isCurrentParameter = theCurrent.get() && theCurrent->getKind() == "Parameter";
-  for(; anIter.get(); anIter = myObjs->nextFeature(anIter, true)) {
+  int anIndex = kUNDEFINED_FEATURE_INDEX;
+  for(; anIter.get(); anIter = myObjs->nextFeature(anIter, anIndex, true)) {
     // check this before passed become enabled: the current feature is enabled!
     if (anIter == theCurrent) aPassed = true;
 
@@ -1315,7 +1319,8 @@ void Model_Document::setCurrentFeatureUp()
   // problems if it is true: here and in "setCurrentFeature"
   FeaturePtr aCurrent = currentFeature(false);
   if (aCurrent.get()) { // if not, do nothing because null is the upper
-    FeaturePtr aPrev = myObjs->nextFeature(aCurrent, true);
+    int anIndex = kUNDEFINED_FEATURE_INDEX;
+    FeaturePtr aPrev = myObjs->nextFeature(aCurrent, anIndex, true);
     // make the higher level composite as current (sketch becomes disabled if line is enabled)
     if (aPrev.get()) {
       FeaturePtr aComp = ModelAPI_Tools::compositeOwner(aPrev);
index 352c2e60c82b78bf34f98d7c07713a0341cc7006..d7ecf71879dc3ee3b39e5f34eadef130e13f536b 100644 (file)
@@ -47,6 +47,8 @@
 #include <TDF_LabelMap.hxx>
 #include <TDF_ListIteratorOfLabelList.hxx>
 
+int kUNDEFINED_FEATURE_INDEX = -1;
+
 static const std::string& groupNameFoldering(const std::string& theGroupID,
                                              const bool theAllowFolder)
 {
@@ -148,7 +150,7 @@ static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced, TDF_
   } else {  // extend array by one more element
     Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(),
                                                                         aRefs->Upper() + 1);
-    int aPassedPrev = 0; // prev feature is found and passed
+    int aPassedPrev = 0; // previous feature is found and passed
     if (thePrevLab.IsNull()) { // null means that inserted feature must be the first
       aNewArray->SetValue(aRefs->Lower(), theReferenced);
       aPassedPrev = 1;
@@ -382,7 +384,7 @@ void Model_Objects::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis)
 
   Handle(TDataStd_HLabelArray1) aNewArray =
     new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper());
-  int aPassedMovedFrom = 0; // the prev feature location is found and passed
+  int aPassedMovedFrom = 0; // the previous feature location is found and passed
   int aPassedMovedTo = 0; // the feature is added and this location is passed
   if (!theAfterThis.get()) { // null means that inserted feature must be the first
     aNewArray->SetValue(aRefs->Lower(), aMovedLab);
@@ -741,31 +743,17 @@ void Model_Objects::setUniqueName(FeaturePtr theFeature)
   // first count all features of such kind to start with index = count + 1
   int aNumObjects = -1; // this feature is already in this map
   NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFIter(myFeatures);
+  std::set<std::string> allNames;
   for (; aFIter.More(); aFIter.Next()) {
     if (aFIter.Value()->getKind() == theFeature->getKind())
       aNumObjects++;
+    allNames.insert(aFIter.Value()->data()->name());
   }
   // generate candidate name
   aName = composeName(theFeature->getKind(), aNumObjects + 1);
   // check this is unique, if not, increase index by 1
-  for (aFIter.Initialize(myFeatures); aFIter.More();) {
-    FeaturePtr aFeature = aFIter.Value();
-    bool isSameName = aFeature->data()->name() == aName;
-    if (!isSameName) {  // check also results to avoid same results names (actual for Parts)
-      const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aFeature->results();
-      std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
-      for (; aRIter != aResults.cend(); aRIter++) {
-        isSameName = (*aRIter)->data()->name() == aName;
-      }
-    }
-
-    if (isSameName) {
-      aNumObjects++;
-      aName = composeName(theFeature->getKind(), aNumObjects + 1);
-      // reinitialize iterator to make sure a new name is unique
-      aFIter.Initialize(myFeatures);
-    } else
-      aFIter.Next();
+  for(aNumObjects++; allNames.find(aName) != allNames.end(); aNumObjects++) {
+    aName = composeName(theFeature->getKind(), aNumObjects + 1);
   }
   theFeature->data()->setName(aName);
 }
@@ -866,7 +854,7 @@ void Model_Objects::synchronizeFeatures(
       ObjectPtr aFeature = isFolder ? ObjectPtr(new ModelAPI_Folder)
                                     : ObjectPtr(aSession->createFeature(aFeatureID, anOwner));
       if (!aFeature.get()) {
-        // somethig is wrong, most probably, the opened document has invalid structure
+        // something is wrong, most probably, the opened document has invalid structure
         Events_InfoMessage("Model_Objects", "Invalid type of object in the document").send();
         aLabIter.Value()->Label().ForgetAllAttributes();
         continue;
@@ -967,7 +955,7 @@ void Model_Objects::synchronizeFeatures(
   }
   // update results of the features (after features created because
   // they may be connected, like sketch and sub elements)
-  // After synchronisation of back references because sketch
+  // After synchronization of back references because sketch
   // must be set in sub-elements before "execute" by updateResults
   std::set<FeaturePtr> aProcessed; // composites must be updated after their subs (issue 360)
   TDF_ChildIDIterator aLabIter2(featuresLabel(), TDataStd_Comment::GetID());
@@ -1006,14 +994,14 @@ void Model_Objects::synchronizeFeatures(
     anOwner->setExecuteFeatures(true);
 }
 
-/// synchronises back references for the given object basing on the collected data
+/// synchronizes back references for the given object basing on the collected data
 void Model_Objects::synchronizeBackRefsForObject(const std::set<AttributePtr>& theNewRefs,
   ObjectPtr theObject)
 {
   if (!theObject.get() || !theObject->data()->isValid())
     return; // invalid
   std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theObject->data());
-  // iterate new list to compare with curent
+  // iterate new list to compare with current
   std::set<AttributePtr>::iterator aNewIter = theNewRefs.begin();
   for(; aNewIter != theNewRefs.end(); aNewIter++) {
     if (aData->refsToMe().find(*aNewIter) == aData->refsToMe().end()) {
@@ -1115,9 +1103,9 @@ static void collectReferences(std::shared_ptr<ModelAPI_Data> theData,
 void Model_Objects::synchronizeBackRefs()
 {
   // collect all back references in the separated container: to update everything at once,
-  // without additional Concealment switchin on and off: only the final modification
+  // without additional Concealment switching on and off: only the final modification
 
-  // referenced (slave) objects to referencing attirbutes
+  // referenced (slave) objects to referencing attributes
   std::map<ObjectPtr, std::set<AttributePtr> > allRefs;
   NCollection_DataMap<TDF_Label, FeaturePtr>::Iterator aFeatures(myFeatures);
   for(; aFeatures.More(); aFeatures.Next()) {
@@ -1158,7 +1146,7 @@ void Model_Objects::synchronizeBackRefs()
     FeaturePtr aFeature = aFeatures.Value();
     std::list<ResultPtr> aResults;
     ModelAPI_Tools::allResults(aFeature, aResults);
-    // update the concealment status for disply in isConcealed of ResultBody
+    // update the concealment status for display in isConcealed of ResultBody
     std::list<ResultPtr>::iterator aRIter = aResults.begin();
     for(; aRIter != aResults.cend(); aRIter++) {
       (*aRIter)->isConcealed();
@@ -1371,7 +1359,8 @@ std::shared_ptr<ModelAPI_Folder> Model_Objects::createFolder(
     std::shared_ptr<Model_Data> aPrevData =
         std::dynamic_pointer_cast<Model_Data>(theBeforeThis->data());
     if (aPrevData.get()) {
-      aPrevFeatureLab = nextLabel(aPrevData->label().Father(), true);
+      int anIndex = kUNDEFINED_FEATURE_INDEX;
+      aPrevFeatureLab = nextLabel(aPrevData->label().Father(), anIndex, true);
     }
   } else { // find the label of the last feature
     Handle(TDataStd_ReferenceArray) aRefs;
@@ -1490,7 +1479,7 @@ std::shared_ptr<ModelAPI_Folder> Model_Objects::findFolder(
 
     if (!aLastFeatureInFolder.IsNull()) {
       if (IsEqual(aCurLabel, aLastFeatureInFolder))
-        aLastFeatureInFolder.Nullify(); // the last feature in the folder is achived
+        aLastFeatureInFolder.Nullify(); // the last feature in the folder is achieved
       continue;
     }
 
@@ -1949,32 +1938,35 @@ ResultPtr Model_Objects::findByName(const std::string theName)
   return aResult;
 }
 
-TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, const bool theReverse)
+TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse)
 {
   Handle(TDataStd_ReferenceArray) aRefs;
   if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) {
-    for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { // iterate all existing features
+    int aStart = theIndex == kUNDEFINED_FEATURE_INDEX ? aRefs->Lower() : theIndex;
+    for(int a = aStart; a <= aRefs->Upper(); a++) { // iterate all existing features
       TDF_Label aCurLab = aRefs->Value(a);
       if (aCurLab.IsEqual(theCurrent)) {
         a += theReverse ? -1 : 1;
-        if (a >= aRefs->Lower() && a <= aRefs->Upper())
+        if (a >= aRefs->Lower() && a <= aRefs->Upper()) {
+          theIndex = a;
           return aRefs->Value(a);
-        break; // finish iiteration: it's last feature
+        }
+        break; // finish iteration: it's last feature
       }
     }
   }
   return TDF_Label();
 }
 
-FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, const bool theReverse)
+FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse)
 {
   std::shared_ptr<Model_Data> aData = std::static_pointer_cast<Model_Data>(theCurrent->data());
   if (aData.get() && aData->isValid()) {
     TDF_Label aFeatureLabel = aData->label().Father();
     do {
-      TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse);
+      TDF_Label aNextLabel = nextLabel(aFeatureLabel, theIndex, theReverse);
       if (aNextLabel.IsNull())
-        break; // last or something is wrong
+        break; // the last or something is wrong
       FeaturePtr aFound = feature(aNextLabel);
       if (aFound)
         return aFound; // the feature is found
index 0991cf21077dba0fe2b3bcc38a0caafd91f4ebbf..26e6e6d19b70b2613a762e44521f1eaccedfec91 100644 (file)
@@ -40,6 +40,8 @@
 static Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper);
 static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2);
 
+extern int kUNDEFINED_FEATURE_INDEX;
+
 /**\class Model_Objects
  * \ingroup DataModel
  * \brief Manager of objects of the document. Normally one this class corresponds to
@@ -49,7 +51,7 @@ static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLa
 class Model_Objects
 {
  public:
-  //! Registers the fieature in the data structure
+  //! Registers the feature in the data structure
   //! \param theFeature feature that must be added to the data structure
   //! \param theAfterThis the feature will be added after this feature;
   //!        if it is null, the added feature will be the first
@@ -167,7 +169,7 @@ class Model_Objects
       const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
       const bool theBelow);
   //! Search a folder containing the given feature.
-  //! Addtionally calculates a zero-based index of the feature in this folder.
+  //! Additionally calculates a zero-based index of the feature in this folder.
   //! \param theFeature feature to search
   //! \param theIndexInFolder zero-based index in the folder or -1 if the feature is top-level.
   //! \return the folder containing the feature or empty pointer if the feature is top-level.
@@ -176,7 +178,7 @@ class Model_Objects
       int& theIndexInFolder);
   //! Add a list of features to the folder. The correctness of the adding is not performed
   //! (such checks have been done in corresponding find.. method).
-  //! \return \c true if the movement is successfull
+  //! \return \c true if the movement is successful
   bool moveToFolder(const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
                     const std::shared_ptr<ModelAPI_Folder>& theFolder);
   //! Remove features from the folder
@@ -194,7 +196,7 @@ class Model_Objects
   //! Returns the owner of this manager
   DocumentPtr owner() {return myDoc;}
 
-  //! Deletes all managed features wit hemmitting of corresponded signal
+  //! Deletes all managed features with emitting of corresponded signal
   ~Model_Objects();
 
  protected:
@@ -206,15 +208,15 @@ class Model_Objects
   //! feature type + "_" + index
   void setUniqueName(FeaturePtr theFeature);
 
-  //! Initializes the foldet with an unique name ("Folder_" + index)
+  //! Initializes the folder with an unique name ("Folder_" + index)
   void setUniqueName(FolderPtr theFolder);
 
   //! Synchronizes myFeatures list with the updated document
-  //! \param theUpdated list of labels that are marked as modified, so featrues must be also
+  //! \param theUpdated list of labels that are marked as modified, so features must be also
   //! \param theUpdateReferences causes the update of back-references
   //! \param theExecuteFeatures requires re-execute modified persistent features
   //!            (not needed on undo/redo/abort/open)
-  //! \param theOpen - on open nothing must be reexecuted, except not persistent results
+  //! \param theOpen - on open nothing must be re-executed, except not persistent results
   //! \param theFlush makes flush all events in the end of all modifications of this method
   void synchronizeFeatures(const TDF_LabelList& theUpdated, const bool theUpdateReferences,
     const bool theOpen, const bool theExecuteFeatures, const bool theFlush);
@@ -255,8 +257,9 @@ class Model_Objects
 
   /// Returns the next (from the history point of view) feature, any: invisible or disabled
   /// \param theCurrent previous to the resulting feature
-  /// \param theReverse if it is true, iterates in reverced order (next becomes previous)
-  FeaturePtr nextFeature(FeaturePtr theCurrent, const bool theReverse = false);
+  /// \param theReverse if it is true, iterates in reversed order (next becomes previous)
+  /// \param theIndex may be used for optimization: index of theCurrent in references array
+  FeaturePtr nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse = false);
   /// Returns to the first (from the history point of view) feature, any: invisible or disabled
   FeaturePtr firstFeature();
   /// Returns to the last (from the history point of view) feature, any: invisible or disabled
@@ -266,8 +269,8 @@ class Model_Objects
 
   /// Returns the next or previous label
   /// \param theCurrent given label
-  /// \param theReverse if it is true, iterates in reverced order (next becomes previous)
-  TDF_Label nextLabel(TDF_Label theCurrent, const bool theReverse = false);
+  /// \param theReverse if it is true, iterates in reversed order (next becomes previous)
+  TDF_Label nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse = false);
 
   /// Returns the result group identifier of the given feature (for this at least one result must
   /// be created before)
@@ -281,14 +284,14 @@ class Model_Objects
   //! history. Not very fast method, for calling once, not in big cycles.
   std::list<std::shared_ptr<ModelAPI_Object> > allObjects();
 
-  //! synchronises back references for the given object basing on the collected data
+  //! synchronizes back references for the given object basing on the collected data
   void synchronizeBackRefsForObject(
     const std::set<std::shared_ptr<ModelAPI_Attribute>>& theNewRefs, ObjectPtr theObject);
 
   /// Just removes all features without touching the document data (to be able undo)
   virtual void eraseAllFeatures();
 
-  // Check whether the pre-image of the result had user-defined name.
+  // Check whether the predefined-image of the result had user-defined name.
   // If yes, return this name.
   bool hasCustomName(DataPtr theFeatureData,
                      ResultPtr theResult,
@@ -301,7 +304,7 @@ class Model_Objects
  private:
   TDF_Label myMain; ///< main label of the data storage
 
-  DocumentPtr myDoc; ///< doc,ument, owner of this objects manager: needed for events creation
+  DocumentPtr myDoc; ///< document, owner of this objects manager: needed for events creation
 
   /// All managed features (not only in history of OB)
   /// For optimization mapped by labels
@@ -311,7 +314,7 @@ class Model_Objects
   NCollection_DataMap<TDF_Label, ObjectPtr> myFolders;
 
   /// Map from group id to the array that contains all objects located in history.
-  /// Each array is updated by demand from scratch, by browing all the features in the history.
+  /// Each array is updated by demand from scratch, by browsing all the features in the history.
   std::map<std::string, std::vector<ObjectPtr> > myHistory;
 
   friend class Model_Document;