1 // Copyright (C) 2014-2017 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
21 #ifndef Model_Objects_H_
22 #define Model_Objects_H_
25 #include <ModelAPI_Document.h>
26 #include <ModelAPI_Feature.h>
27 #include <ModelAPI_Result.h>
28 #include <ModelAPI_ResultParameter.h>
30 #include <TDocStd_Document.hxx>
31 #include <NCollection_DataMap.hxx>
32 #include <TDF_Label.hxx>
33 #include <TDF_LabelList.hxx>
38 // for TDF_Label map usage
39 static Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper);
40 static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2);
42 /**\class Model_Objects
44 * \brief Manager of objects of the document. Normally one this class corresponds to
45 * one document and just helper to manage objects (ModelAPI_Objects) inside of the document
46 * on the level of data storage.
51 //! Registers the fieature in the data structure
52 //! \param theFeature feature that must be added to the data structure
53 //! \param theAfterThis the feature will be added after this feature;
54 //! if it is null, the added feature will be the first
55 void addFeature(FeaturePtr theFeature, const FeaturePtr theAfterThis);
57 //! Return a list of features, which refers to the feature
58 //! \param theFeature a feature
59 //! \param theRefs a list of reference features
60 //! \param isSendError a flag whether the error message should be send
61 void refsToFeature(FeaturePtr theFeature,
62 std::set<FeaturePtr>& theRefs,
63 const bool isSendError = true);
65 //! Removes the feature from the document (with result)
66 //! \param theFeature a removed feature
67 void removeFeature(FeaturePtr theFeature);
69 //! Moves the feature to make it after the given one in the history.
70 void moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis);
72 //! Returns the existing feature by the label
73 //! \param theLabel base label of the feature
74 FeaturePtr feature(TDF_Label theLabel) const;
76 //! Returns the existing object: result or feature
77 //! \param theLabel base label of the object
78 ObjectPtr object(TDF_Label theLabel);
80 //! Returns the first found object in the group by the object name
81 //! \param theGroupID group that contains an object
82 //! \param theName name of the object to search
83 //! \returns null if such object is not found
84 std::shared_ptr<ModelAPI_Object> objectByName(
85 const std::string& theGroupID, const std::string& theName);
87 //! Returns the result by the result name
88 ResultPtr findByName(const std::string theName);
91 //! Returns the object index in the group. Object must be visible. Otherwise returns -1.
92 //! \param theObject object of this document
93 //! \returns index started from zero, or -1 if object is invisible or belongs to another document
94 const int index(std::shared_ptr<ModelAPI_Object> theObject);
96 //! Returns the feature in the group by the index (started from zero)
97 //! \param theGroupID group that contains a feature
98 //! \param theIndex zero-based index of feature in the group
99 ObjectPtr object(const std::string& theGroupID, const int theIndex);
101 //! Returns the number of features in the group
102 int size(const std::string& theGroupID);
104 //! Returns all (and disabled) results of the given type.
105 //! Not fast method (iterates all features).
106 void allResults(const std::string& theGroupID, std::list<ResultPtr>& theResults);
108 //! Returns the number of all features: in the history or not
109 int numInternalFeatures();
110 //! Returns the feature by zero-based index: features in the history or not
111 std::shared_ptr<ModelAPI_Feature> internalFeature(const int theIndex);
113 //! Returns feature by the id of the feature (produced by the Data "featureId" method)
114 std::shared_ptr<ModelAPI_Feature> featureById(const int theId);
117 /// Creates a construction result
118 std::shared_ptr<ModelAPI_ResultConstruction> createConstruction(
119 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
120 /// Creates a body result
121 std::shared_ptr<ModelAPI_ResultBody> createBody(
122 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
123 /// Creates a part result
124 std::shared_ptr<ModelAPI_ResultPart> createPart(
125 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
126 /// Copies a part result, keeping the reference to origin
127 std::shared_ptr<ModelAPI_ResultPart> copyPart(
128 const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
129 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
130 /// Creates a group result
131 std::shared_ptr<ModelAPI_ResultGroup> createGroup(
132 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
133 /// Creates a field result
134 std::shared_ptr<ModelAPI_ResultField> createField(
135 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
136 /// Creates a parameter result
137 std::shared_ptr<ModelAPI_ResultParameter> createParameter(
138 const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
140 //! Returns a feature by result (owner of result)
141 std::shared_ptr<ModelAPI_Feature>
142 feature(const std::shared_ptr<ModelAPI_Result>& theResult);
144 //! Sets the owner of this manager
145 void setOwner(DocumentPtr theDoc);
147 //! Returns the owner of this manager
148 DocumentPtr owner() {return myDoc;}
150 //! Deletes all managed features wit hemmitting of corresponded signal
155 //! Returns (creates if needed) the features label
156 TDF_Label featuresLabel() const;
158 //! Initializes feature with a unique name in this group (unique name is generated as
159 //! feature type + "_" + index
160 void setUniqueName(FeaturePtr theFeature);
162 //! Synchronizes myFeatures list with the updated document
163 //! \param theUpdated list of labels that are marked as modified, so featrues must be also
164 //! \param theUpdateReferences causes the update of back-references
165 //! \param theExecuteFeatures requires re-execute modified persistent features
166 //! (not needed on undo/redo/abort/open)
167 //! \param theOpen - on open nothing must be reexecuted, except not persistent results
168 //! \param theFlush makes flush all events in the end of all modifications of this method
169 void synchronizeFeatures(const TDF_LabelList& theUpdated, const bool theUpdateReferences,
170 const bool theOpen, const bool theExecuteFeatures, const bool theFlush);
171 //! Synchronizes the BackReferences list in Data of Features and Results
172 void synchronizeBackRefs();
174 //! Creates manager on the OCAF document main label
175 Model_Objects(TDF_Label theMainLab);
177 //! Initializes the data fields of the feature
178 void initData(ObjectPtr theObj, TDF_Label theLab, const int theTag);
180 //! Allows to store the result in the data tree of the document
181 //! (attaches 'data' of result to tree)
182 void storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
183 std::shared_ptr<ModelAPI_Result> theResult,
184 const int theResultIndex = 0);
186 //! returns the label of result by index; creates this label if it was not created before
187 TDF_Label resultLabel(const std::shared_ptr<ModelAPI_Data>& theFeatureData,
188 const int theResultIndex);
190 //! Updates the results list of the feature basing on the current data tree
191 //! theProcessed is used to avoid update twice (since the function is recursive)
192 void updateResults(FeaturePtr theFeature, std::set<FeaturePtr>& theProcessed);
194 /// Internally makes document know that feature was removed or added in history after creation
195 void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
197 /// Internally makes document know that feature was removed or added in history after creation
198 void updateHistory(const std::string theGroup);
200 /// Clears the history arrays related to this object
201 void clearHistory(ObjectPtr theObj);
203 /// Creates the history: up to date with the current state
204 void createHistory(const std::string& theGroupID);
206 /// Returns the next (from the history point of view) feature, any: invisible or disabled
207 /// \param theCurrent previous to the resulting feature
208 /// \param theReverse if it is true, iterates in reverced order (next becomes previous)
209 FeaturePtr nextFeature(FeaturePtr theCurrent, const bool theReverse = false);
210 /// Returns to the first (from the history point of view) feature, any: invisible or disabled
211 FeaturePtr firstFeature();
212 /// Returns to the last (from the history point of view) feature, any: invisible or disabled
213 FeaturePtr lastFeature();
214 /// Returns true if theLater is in history of features creation later than theCurrent
215 bool isLater(FeaturePtr theLater, FeaturePtr theCurrent) const;
217 /// Returns the result group identifier of the given feature (for this at least one result must
218 /// be created before)
219 std::string featureResultGroup(FeaturePtr theFeature);
221 //! Returns all features of the document including the hidden features which are not in
222 //! history. Not very fast method, for calling once, not in big cycles.
223 std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures();
225 //! synchronises back references for the given object basing on the collected data
226 void synchronizeBackRefsForObject(
227 const std::set<std::shared_ptr<ModelAPI_Attribute>>& theNewRefs, ObjectPtr theObject);
229 /// Just removes all features without touching the document data (to be able undo)
230 virtual void eraseAllFeatures();
233 TDF_Label myMain; ///< main label of the data storage
235 DocumentPtr myDoc; ///< doc,ument, owner of this objects manager: needed for events creation
237 /// All managed features (not only in history of OB)
238 /// For optimization mapped by labels
239 NCollection_DataMap<TDF_Label, FeaturePtr> myFeatures;
241 /// Map from group id to the array that contains all objects located in history.
242 /// Each array is updated by demand from scratch, by browing all the features in the history.
243 std::map<std::string, std::vector<ObjectPtr> > myHistory;
245 friend class Model_Document;
246 friend class Model_Session;
247 friend class Model_Update;
248 friend class Model_AttributeReference;
249 friend class Model_AttributeRefAttr;
250 friend class Model_AttributeRefList;
251 friend class Model_AttributeSelection;
252 friend class Model_SelectionNaming;