Salome HOME
IPAL53870: Dump study script creates an excess sub-mesh
[modules/smesh.git] / src / SMESH_I / SMESH_2smeshpy.hxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 // File      : SMESH_smesh.hxx
24 // Created   : Fri Nov 18 12:05:18 2005
25 // Author    : Edward AGAPOV (eap)
26 //
27 #ifndef SMESH_smesh_HeaderFile
28 #define SMESH_smesh_HeaderFile
29
30 #include <Standard_DefineHandle.hxx>
31 #include <Standard_Type.hxx>
32 #include <Standard_Transient.hxx>
33 #include <TCollection_AsciiString.hxx>
34 #include <TColStd_SequenceOfAsciiString.hxx>
35 #include <TColStd_SequenceOfInteger.hxx>
36 #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
37
38 #include <list>
39 #include <map>
40 #include <vector>
41 #include <set>
42
43 #include <Basics_OCCTVersion.hxx>
44
45 #include <SALOMEconfig.h>
46 #include CORBA_CLIENT_HEADER(SALOMEDS)
47
48 #define USE_STRING_FAMILY
49
50 // ===========================================================================================
51 /*!
52  * This file was created in order to respond to requirement of bug PAL10494:
53  * SMESH python dump uses idl interface.
54  *
55  * The creation reason is that smeshBuilder.py commands defining hypotheses encapsulate
56  * several SMESH engine method calls. As well, the dependencies between smeshBuilder.py
57  * classes differ from ones between corresponding SMESH IDL interfaces.
58  * 
59  * Everything here is for internal usage by SMESH_2smeshpy::ConvertScript()
60  * declared in SMESH_PythonDump.hxx
61  */
62 // ===========================================================================================
63
64 // ===========================================================================================
65 // =====================
66 //    INTERNAL STUFF
67 // =====================
68 // ===========================================================================================
69
70 class _pyCommand;
71 class _pyObject;
72 class _pyGen;
73 class _pyMesh;
74 class _pySubMesh;
75 class _pyHypothesis;
76 class _pyAlgorithm;
77 class _pyHypothesisReader;
78
79 DEFINE_STANDARD_HANDLE (_pyCommand         ,Standard_Transient);
80 DEFINE_STANDARD_HANDLE (_pyObject          ,Standard_Transient);
81 DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient);
82 DEFINE_STANDARD_HANDLE (_pyGen             ,_pyObject);
83 DEFINE_STANDARD_HANDLE (_pyMesh            ,_pyObject);
84 DEFINE_STANDARD_HANDLE (_pySubMesh         ,_pyObject);
85 DEFINE_STANDARD_HANDLE (_pyGroup           ,_pySubMesh);
86 DEFINE_STANDARD_HANDLE (_pyMeshEditor      ,_pyObject);
87 DEFINE_STANDARD_HANDLE (_pyHypothesis      ,_pyObject);
88 DEFINE_STANDARD_HANDLE (_pyAlgorithm       ,_pyHypothesis);
89
90 typedef TCollection_AsciiString _pyID;
91 typedef TCollection_AsciiString _AString;
92
93 // ===========================================================
94 /*!
95  * \brief Class operating on a command string looking like
96  *        ResultValue = Object.Method( Arg1, Arg2,...)
97  */
98 // ===========================================================
99
100 class _pyCommand: public Standard_Transient
101 {
102   int                             myOrderNb;            //!< position within the script
103   _AString                        myString;             //!< command text
104   _AString                        myRes, myObj, myMeth; //!< found parts of command
105   TColStd_SequenceOfAsciiString   myArgs;               //!< found arguments
106   TColStd_SequenceOfAsciiString   myResults;            //!< found results
107   TColStd_SequenceOfInteger       myBegPos;             //!< where myRes, myObj, ... begin
108   std::list< Handle(_pyCommand) > myDependentCmds; //!< commands that sould follow me in the script
109
110   enum { UNKNOWN=-1, EMPTY=0, RESULT_IND, OBJECT_IND, METHOD_IND, ARG1_IND };
111   int  GetBegPos( int thePartIndex ) const;
112   void SetBegPos( int thePartIndex, int thePosition );
113   void SetPart( int thePartIndex, const _AString& theNewPart, _AString& theOldPart);
114   void FindAllArgs() { GetArg(1); }
115
116 public:
117   _pyCommand() {};
118   _pyCommand( const _AString& theString, int theNb=-1 )
119     : myOrderNb( theNb ), myString( theString ) {};
120   _AString & GetString() { return myString; }
121   int  GetOrderNb() const { return myOrderNb; }
122   void SetOrderNb( int theNb ) { myOrderNb = theNb; }
123   typedef void* TAddr;
124   TAddr GetAddress() const { return (void*) this; }
125   int  Length() const { return myString.Length(); }
126   void Clear() { myString.Clear(); myBegPos.Clear(); myArgs.Clear(); }
127   bool IsEmpty() const { return myString.IsEmpty(); }
128   _AString GetIndentation();
129   const _AString & GetResultValue();
130   int GetNbResultValues();
131   const _AString & GetResultValue(int res);
132   const _AString & GetObject();
133   const _AString & GetMethod();
134   const _AString & GetArg( int index );
135   int GetNbArgs() { FindAllArgs(); return myArgs.Length(); }
136   int GetArgBeginning() const;
137   bool IsMethodCall();
138   bool MethodStartsFrom(const _AString& beg)
139   { GetMethod(); return ( myMeth.Location( beg, 1, myMeth.Length() ) == 1 ); }
140   void SetResultValue( const _AString& theResult )
141   { GetResultValue(); SetPart( RESULT_IND, theResult, myRes ); }
142   void SetObject(const _AString& theObject)
143   { GetObject(); SetPart( OBJECT_IND, theObject, myObj ); }
144   void SetMethod(const _AString& theMethod)
145   { GetMethod(); SetPart( METHOD_IND, theMethod, myMeth ); }
146   void SetArg( int index, const _AString& theArg);
147   void RemoveArgs();
148   void Comment();
149   static bool SkipSpaces( const _AString & theSring, int & thePos );
150   static _AString GetWord( const _AString & theSring, int & theStartPos,
151                            const bool theForward, const bool dotIsWord = false);
152   static bool IsStudyEntry( const _AString& str );
153   static bool IsID( const _AString& str );
154   static bool IsIDChar( char c )
155   { return ( isalnum( c ) || c == '_' || c == ':' ); }
156   static std::list< _pyID > GetStudyEntries( const _AString& str );
157   void AddDependantCmd( Handle(_pyCommand) cmd, bool prepend = false)
158   { if (prepend) myDependentCmds.push_front( cmd ); else myDependentCmds.push_back( cmd ); }
159   bool SetDependentCmdsAfter() const;
160
161   bool AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod );
162
163   OCCT_DEFINE_STANDARD_RTTIEXT(_pyCommand,Standard_Transient)
164 };
165
166 // -------------------------------------------------------------------------------------
167 /*!
168  * \brief Root of all objects. It counts calls of Process()
169  */
170 // -------------------------------------------------------------------------------------
171
172 class _pyObject: public Standard_Transient
173 {
174 protected:
175   _pyID                           myID;
176   Handle(_pyCommand)              myCreationCmd;
177   std::list< Handle(_pyCommand) > myProcessedCmds;
178   std::list< Handle(_pyCommand) > myArgCmds; // where this obj is used as an argument
179   bool                            myIsPublished;
180
181   void setID(const _pyID& theID);
182 public:
183   _pyObject(const Handle(_pyCommand)& theCreationCmd, const _pyID& theID=_pyID());
184   const _pyID& GetID() { return myID.IsEmpty() ? myCreationCmd->GetResultValue() : myID; }
185   static _pyID FatherID(const _pyID & childID);
186   const Handle(_pyCommand)& GetCreationCmd() { return myCreationCmd; }
187   int  GetNbCalls() const { return myProcessedCmds.size(); }
188   bool IsInStudy() const { return myIsPublished; }
189   virtual void SetRemovedFromStudy(const bool isRemoved) { myIsPublished = !isRemoved; }
190   void SetCreationCmd( Handle(_pyCommand) cmd ) { myCreationCmd = cmd; }
191   int  GetCommandNb() { return myCreationCmd->GetOrderNb(); }
192   void AddProcessedCmd( const Handle(_pyCommand) & cmd )
193   { if (myProcessedCmds.empty() || myProcessedCmds.back()!=cmd) myProcessedCmds.push_back( cmd );}
194   std::list< Handle(_pyCommand) >& GetProcessedCmds() { return myProcessedCmds; }
195   void AddArgCmd( const Handle(_pyCommand) & cmd ) { myArgCmds.push_back( cmd ); }
196   virtual void Process(const Handle(_pyCommand) & cmd) { AddProcessedCmd(cmd); }
197   virtual void Flush() = 0;
198   virtual const char* AccessorMethod() const;
199   virtual bool CanClear();
200   virtual void ClearCommands();
201   virtual void Free() {}
202
203   OCCT_DEFINE_STANDARD_RTTIEXT(_pyObject,Standard_Transient)
204 };
205
206 // -------------------------------------------------------------------------------------
207 /*!
208  * \brief Data used to restore cleared Compute() command of an exported mesh
209  * when an imported mesh is created
210  */
211 // -------------------------------------------------------------------------------------
212 struct ExportedMeshData
213 {
214   Handle(_pyMesh)    myMesh;
215   Handle(_pyCommand) myLastComputeCmd;
216   _AString           myLastComputeCmdString;
217   ExportedMeshData() {}
218   ExportedMeshData( const Handle(_pyMesh)& mesh, Handle(_pyCommand) computeCmd):
219     myMesh( mesh ), myLastComputeCmd( computeCmd )
220   {
221     if ( !myLastComputeCmd.IsNull())
222       myLastComputeCmdString = myLastComputeCmd->GetString();
223   }
224 };
225
226 // -------------------------------------------------------------------------------------
227 /*!
228  * \brief A container of strings groupped by prefix. It is used for a faster search of
229  *        objects requiring to KeepAgrCmds() in commands. A speed up is gained because
230  *        only a common prefix (e.g. "aArea") of many object IDs is searched in a command
231  *        and not every object ID
232  */
233 // -------------------------------------------------------------------------------------
234 class _pyStringFamily
235 {
236   _AString                     _prefix;
237   std::list< _pyStringFamily > _subFams;
238   std::list< _AString >        _strings;
239   int isIn( const char* str );
240 public:
241   bool Add( const char* str );
242   bool IsInArgs( Handle( _pyCommand)& cmd, std::list<_AString>& subStr );
243   void Print( int level = 0 );
244 };
245
246 // -------------------------------------------------------------------------------------
247 /*!
248  * \brief Class corresponding to SMESH_Gen. It holds info on existing
249  *        meshes and hypotheses
250  */
251 // -------------------------------------------------------------------------------------
252 class _pyGen: public _pyObject
253 {
254 public:
255   _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
256          Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
257          std::set< TCollection_AsciiString >&      theRemovedObjIDs,
258          SALOMEDS::Study_ptr&                      theStudy,
259          const bool                                theToKeepAllCommands);
260   Handle(_pyCommand) AddCommand( const _AString& theCommand );
261   void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 );
262   void SetCommandAfter ( Handle(_pyCommand) theCmd,  Handle(_pyCommand) theAfterCmd );
263   void SetCommandBefore( Handle(_pyCommand) theCmd,  Handle(_pyCommand) theBeforeCmd );
264   Handle(_pyCommand)& GetLastCommand();
265   std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
266   void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
267
268   _pyID GenerateNewID( const _pyID& theID );
269   bool AddObject( Handle(_pyObject)& theObj );
270   void CheckObjectIsReCreated( Handle(_pyObject)& theObj );
271   void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
272   Handle(_pyObject)     FindObject( const _pyID& theObjID ) const;
273   Handle(_pySubMesh)    FindSubMesh( const _pyID& theSubMeshID );
274   Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
275   Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
276                                   const Handle(_pyHypothesis)& theHypothesis);
277
278   void SetAccessorMethod(const _pyID& theID, const char* theMethod );
279   bool AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const;
280   bool AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const;
281   virtual const char* AccessorMethod() const;
282
283   bool IsGeomObject(const _pyID& theObjID) const;
284   bool IsNotPublished(const _pyID& theObjID) const;
285   void ObjectCreationRemoved(const _pyID& theObjID);
286 #ifdef USE_STRING_FAMILY
287   void KeepAgrCmds(const _pyID& theObjID) { myKeepAgrCmdsIDs.Add( theObjID.ToCString() ); }
288 #else
289   void KeepAgrCmds(const _pyID& theObjID) { myKeepAgrCmdsIDs.push_back( theObjID ); }
290 #endif
291   bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
292   void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
293   { myFile2ExportedMesh[ file ] = mesh; }
294   ExportedMeshData& FindExportedMesh( const _AString& file )
295   { return myFile2ExportedMesh[ file ]; }
296
297   virtual void Process( const Handle(_pyCommand)& theCommand );
298   virtual void Flush();
299   virtual void ClearCommands();
300   virtual void Free();
301
302   Handle( _pyHypothesisReader ) GetHypothesisReader() const;
303
304 private:
305   void setNeighbourCommand( Handle(_pyCommand)& theCmd,
306                             Handle(_pyCommand)& theOtherCmd,
307                             const bool theIsAfter );
308   //void addFilterUser( Handle(_pyCommand)& theCmd, const Handle(_pyObject)& user );
309
310 private:
311   std::map< _pyID, Handle(_pyMesh) >        myMeshes;
312   std::map< _pyID, Handle(_pyMeshEditor) >  myMeshEditors;
313   std::map< _pyID, Handle(_pyHypothesis) >  myHypos;
314   std::map< _pyID, Handle(_pyObject) >      myObjects;
315   std::list< Handle(_pyObject) >            myOrderedObjects; // to know order of myObjects creation
316 #ifdef USE_STRING_FAMILY
317   _pyStringFamily                           myKeepAgrCmdsIDs;
318 #else
319   std::list< _pyID >                        myKeepAgrCmdsIDs;
320 #endif
321   std::list< Handle(_pyCommand) >           myCommands;
322   int                                       myNbCommands;
323   Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
324   Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
325   std::set< TCollection_AsciiString >&      myRemovedObjIDs;
326   Handle(_pyCommand)                        myLastCommand;
327   int                                       myNbFilters;
328   bool                                      myToKeepAllCommands;
329   SALOMEDS::Study_var                       myStudy;
330   int                                       myGeomIDNb, myGeomIDIndex;
331   std::map< _AString, ExportedMeshData >    myFile2ExportedMesh;
332   Handle( _pyHypothesisReader )             myHypReader;
333
334   OCCT_DEFINE_STANDARD_RTTIEXT(_pyGen,_pyObject)
335 };
336
337 // -------------------------------------------------------------------------------------
338 /*!
339  * \brief Contains commands concerning mesh substructures
340  */
341 // -------------------------------------------------------------------------------------
342 #define _pyMesh_ACCESS_METHOD "GetMesh()"
343 class _pyMesh: public _pyObject
344 {
345   std::list< Handle(_pyHypothesis) > myHypos;
346   std::list< Handle(_pyCommand) >    myAddHypCmds, myNotConvertedAddHypCmds;
347   std::list< Handle(_pySubMesh) >    mySubmeshes;
348   std::list< Handle(_pyGroup) >      myGroups;
349   std::list< Handle(_pyMeshEditor)>  myEditors;
350   //d::list< Handle(_pyMesh) >       myFatherMeshes; // this mesh depends on
351   std::list< Handle(_pyMesh) >       myChildMeshes; // depending on me
352   bool                               myGeomNotInStudy;
353   Handle(_pyCommand)                 myLastComputeCmd;
354 public:
355   _pyMesh(const Handle(_pyCommand) creationCmd);
356   _pyMesh(const Handle(_pyCommand) theCreationCmd, const _pyID & id);
357   const _pyID& GetGeom() { return GetCreationCmd()->GetArg(1); }
358   void AddGroup( const Handle(_pyGroup)& g ) { myGroups.push_back( g ); }
359   void AddEditor( const Handle(_pyMeshEditor)& e ) { myEditors.push_back( e ); }
360   bool IsNotGeomPublished() { return myGeomNotInStudy; }
361   virtual void Process( const Handle(_pyCommand)& theCommand);
362   virtual void Flush();
363   virtual void SetRemovedFromStudy(const bool isRemoved);
364   virtual bool CanClear();
365   virtual void ClearCommands();
366   virtual void Free() { /*myFatherMeshes.clear();*/ myChildMeshes.clear(); }
367   virtual const char* AccessorMethod() const { return _pyMesh_ACCESS_METHOD; }
368 private:
369   void addFatherMesh( const Handle(_pyMesh)& mesh );
370   void addFatherMesh( const _pyID& meshID );
371   static bool NeedMeshAccess( const Handle(_pyCommand)& theCommand );
372   static void AddMeshAccess( const Handle(_pyCommand)& theCommand )
373   { theCommand->SetObject( theCommand->GetObject() + "." _pyMesh_ACCESS_METHOD ); }
374
375   OCCT_DEFINE_STANDARD_RTTIEXT(_pyMesh,_pyObject)
376 };
377 #undef _pyMesh_ACCESS_METHOD 
378
379 // -------------------------------------------------------------------------------------
380 /*!
381  * \brief MeshEditor convert its commands to ones of mesh
382  */
383 // -------------------------------------------------------------------------------------
384 class _pyMeshEditor: public _pyObject
385 {
386   _pyID    myMesh;
387   _AString myCreationCmdStr;
388 public:
389   _pyMeshEditor(const Handle(_pyCommand)& theCreationCmd);
390   _pyID GetMesh() const { return myMesh; }
391   virtual void Process( const Handle(_pyCommand)& theCommand);
392   virtual void Flush() {}
393   virtual bool CanClear();
394
395   OCCT_DEFINE_STANDARD_RTTIEXT(_pyMesh,_pyObject)
396 };
397
398 // -------------------------------------------------------------------------------------
399 /*!
400  * \brief Root class for hypothesis
401  */
402 // -------------------------------------------------------------------------------------
403 class _pyHypothesis: public _pyObject
404 {
405   friend class _pyHypothesisReader;
406 protected:
407   bool    myIsAlgo, myIsWrapped;
408   _pyID   myGeom,   myMesh;
409   struct CreationMethod {
410     _AString              myMethod; // method of algo or mesh creating a hyp
411     // myArgNb(i)-th arg of myArgMethods(i) of hyp becomes an i-th arg of myMethod
412     std::vector<_AString> myArgMethods;
413     std::vector<int>      myArgNb; // arg nb countered from 1
414     std::vector<_AString> myArgs; // creation arguments
415   };
416   void setCreationArg( const int argNb, const _AString& arg );
417   // a hypothesis can be created by different algos by different methods
418   typedef std::map<_AString, CreationMethod > TType2CrMethod;
419   TType2CrMethod                myAlgoType2CreationMethod;
420   std::set< _AString >          myAccumulativeMethods;
421   CreationMethod*               myCurCrMethod; // used for adding to myAlgoType2CreationMethod
422   std::list<Handle(_pyCommand)> myArgCommands;
423   std::list<Handle(_pyCommand)> myUnusedCommands;
424   std::list<Handle(_pyObject) > myReferredObjs;
425   // maps used to clear commands setting parameters if result of setting is
426   // discared (e.g. by mesh.Clear())
427   std::map<_AString, std::list<Handle(_pyCommand)> >            myMeth2Commands;
428   std::map< _pyCommand::TAddr, std::list<Handle(_pyCommand) > > myComputeAddr2Cmds;
429   std::list<Handle(_pyCommand) >                                myComputeCmds;
430   void rememberCmdOfParameter( const Handle(_pyCommand) & cmd );
431   bool isCmdUsedForCompute( const Handle(_pyCommand) & cmd,
432                             _pyCommand::TAddr avoidComputeAddr=NULL ) const;
433 public:
434   _pyHypothesis(const Handle(_pyCommand)& theCreationCmd);
435   void SetConvMethodAndType(const _AString& creationMethod, const _AString& type)
436   { myCurCrMethod = &myAlgoType2CreationMethod[ type ];
437     myCurCrMethod->myMethod = creationMethod; }
438   void AddArgMethod(const _AString& method, const int argNb = 1)
439   { myCurCrMethod->myArgMethods.push_back( method );
440     myCurCrMethod->myArgNb.push_back( argNb ); }
441   void AddAccumulativeMethod( const _AString& method)
442   { myAccumulativeMethods.insert( method ); }
443   //const TColStd_SequenceOfAsciiString& GetArgs() const { return myArgs; }
444   const std::list<Handle(_pyCommand)>& GetArgCommands() const { return myArgCommands; }
445   void ClearAllCommands();
446   virtual bool IsAlgo() const { return myIsAlgo; }
447   bool IsValid() const { return !myAlgoType2CreationMethod.empty(); }
448   bool IsWrapped() const { return myIsWrapped; }
449   const _pyID & GetGeom() const { return myGeom; }
450   void SetMesh( const _pyID& theMeshId) { if ( myMesh.IsEmpty() ) myMesh = theMeshId; }
451   const _pyID & GetMesh() const { return myMesh; }
452   const _AString& GetAlgoType() const
453   { return myAlgoType2CreationMethod.begin()->first; }
454   const _AString& GetAlgoCreationMethod() const
455   { return myAlgoType2CreationMethod.begin()->second.myMethod; }
456   bool CanBeCreatedBy(const _AString& algoType ) const
457   { return myAlgoType2CreationMethod.find( algoType ) != myAlgoType2CreationMethod.end(); }
458   const _AString& GetCreationMethod(const _AString& algoType)
459   { return ( myCurCrMethod = & myAlgoType2CreationMethod[ algoType ])->myMethod; }
460   static Handle(_pyHypothesis) NewHypothesis( const Handle(_pyCommand)& theCreationCmd);
461
462   virtual bool IsWrappable(const _pyID& theMesh) const;
463   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
464                                   const _pyID&              theMesh);
465   virtual void Process( const Handle(_pyCommand)& theCommand);
466   virtual void Flush();
467   virtual void Free() { myReferredObjs.clear(); }
468   virtual void Assign( const Handle(_pyHypothesis)& theOther,
469                        const _pyID&                 theMesh );
470   virtual bool CanClear();
471   virtual void ClearCommands();
472   virtual bool GetReferredMeshesAndGeom( std::list< Handle(_pyMesh) >& meshes );
473
474   void MeshComputed    ( const Handle(_pyCommand)& theComputeCommand );
475   void ComputeDiscarded( const Handle(_pyCommand)& theComputeCommand );
476   //void ComputeSaved    ( const Handle(_pyCommand)& theComputeCommand );
477
478
479   OCCT_DEFINE_STANDARD_RTTIEXT(_pyHypothesis,_pyObject)
480 };
481
482 // -------------------------------------------------------------------------------------
483 /*!
484  * \brief Class representing smesh.Mesh_Algorithm
485  */
486 // -------------------------------------------------------------------------------------
487 class _pyAlgorithm: public _pyHypothesis
488 {
489 public:
490   _pyAlgorithm(const Handle(_pyCommand)& theCreationCmd);
491   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
492                                   const _pyID&              theMesh);
493   virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
494   virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
495
496   OCCT_DEFINE_STANDARD_RTTIEXT(_pyAlgorithm,_pyHypothesis)
497 };
498
499 // -------------------------------------------------------------------------------------
500 /*!
501  * \brief Class for hypotheses having several parameters modified by one method
502  */
503 // -------------------------------------------------------------------------------------
504 class _pyComplexParamHypo: public _pyHypothesis
505 {
506 public:
507   _pyComplexParamHypo(const Handle(_pyCommand)& theCreationCmd): _pyHypothesis(theCreationCmd) {}
508   virtual void Process( const Handle(_pyCommand)& theCommand);
509   virtual void Flush();
510
511   OCCT_DEFINE_STANDARD_RTTIEXT(_pyComplexParamHypo,_pyHypothesis)
512 };
513 DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
514
515 // -------------------------------------------------------------------------------------
516 /*!
517  * \brief Class for LayerDistribution hypothesis conversion
518  */
519 // -------------------------------------------------------------------------------------
520 class _pyLayerDistributionHypo: public _pyHypothesis
521 {
522   Handle(_pyHypothesis) my1dHyp;
523   _AString              myAlgoMethod;
524 public:
525   _pyLayerDistributionHypo(const Handle(_pyCommand)& theCreationCmd, const char* algoMethod):
526     _pyHypothesis(theCreationCmd), myAlgoMethod((char*)algoMethod) {}
527   virtual void Process( const Handle(_pyCommand)& theCommand);
528   virtual void Flush();
529   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
530                                   const _pyID&              theMesh);
531   virtual void Free() { my1dHyp.Nullify(); }
532
533   OCCT_DEFINE_STANDARD_RTTIEXT(_pyLayerDistributionHypo,_pyHypothesis)
534 };
535 DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
536
537 // -------------------------------------------------------------------------------------
538 /*!
539  * \brief Class representing NumberOfSegments hypothesis
540  */
541 // -------------------------------------------------------------------------------------
542 class _pyNumberOfSegmentsHyp: public _pyHypothesis
543 {
544 public:
545   _pyNumberOfSegmentsHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
546   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
547                                   const _pyID&              theMesh);
548   void Flush();
549
550   OCCT_DEFINE_STANDARD_RTTIEXT(_pyNumberOfSegmentsHyp,_pyHypothesis)
551 };
552 DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
553
554 // -------------------------------------------------------------------------------------
555 /*!
556  * \brief Class representing SegmentLengthAroundVertex hypothesis
557  */
558 // -------------------------------------------------------------------------------------
559 class _pySegmentLengthAroundVertexHyp: public _pyHypothesis
560 {
561 public:
562   _pySegmentLengthAroundVertexHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
563   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
564                                   const _pyID&              theMesh);
565   OCCT_DEFINE_STANDARD_RTTIEXT(_pySegmentLengthAroundVertexHyp,_pyHypothesis)
566 };
567 DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
568
569 // -------------------------------------------------------------------------------------
570 /*!
571  * \brief SelfEraser erases creation command if no more it's commands invoked
572  */
573 // -------------------------------------------------------------------------------------
574 class _pySelfEraser: public _pyObject
575 {
576   bool myIgnoreOwnCalls; // not to erase only if this obj is used as argument
577 public:
578   _pySelfEraser(const Handle(_pyCommand)& theCreationCmd);
579   void IgnoreOwnCalls() { myIgnoreOwnCalls = true; }
580   virtual void Flush();
581   virtual bool CanClear();
582   static bool IsAliveCmd( const Handle(_pyCommand)& theCmd );
583
584   OCCT_DEFINE_STANDARD_RTTIEXT(_pySelfEraser,_pyObject)
585 };
586 DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
587
588 // -------------------------------------------------------------------------------------
589 /*!
590  * \brief SubMesh creation can be moved to the end of engine commands
591  */
592 // -------------------------------------------------------------------------------------
593 class _pySubMesh:  public _pyObject
594 {
595   Handle(_pyObject) myCreator;
596   Handle(_pyMesh) myMesh;
597 public:
598   _pySubMesh(const Handle(_pyCommand)& theCreationCmd, bool toKeepAgrCmds=true);
599   virtual void Process( const Handle(_pyCommand)& theCommand);
600   virtual void Flush();
601   virtual Handle(_pyMesh) GetMesh() { return myMesh; }
602   virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
603   void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
604   static bool CanBeArgOfMethod(const _AString& theMethodName);
605
606   OCCT_DEFINE_STANDARD_RTTIEXT(_pySubMesh,_pyObject)
607 };
608 // -------------------------------------------------------------------------------------
609 /*!
610  * \brief A filter sets a human readable name to self
611  */
612 // -------------------------------------------------------------------------------------
613 class _pyFilter:  public _pyObject
614 {
615   _pyID myNewID, myMesh;
616   //std::list< Handle(_pyObject) > myUsers;
617 public:
618   _pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID="");
619   //void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
620   virtual void Process( const Handle(_pyCommand)& theCommand);
621   virtual void Flush();
622   //virtual bool CanClear();
623   //virtual void Free() { myUsers.clear(); }
624   const _pyID& GetNewID() const { return myNewID; }
625
626   OCCT_DEFINE_STANDARD_RTTIEXT(_pyFilter,_pyObject)
627 };
628 DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
629
630 // -------------------------------------------------------------------------------------
631 /*!
632  * \brief To convert creation of a group by filter
633  */
634 // -------------------------------------------------------------------------------------
635 class _pyGroup:  public _pySubMesh // use myMesh of _pySubMesh
636 {
637   Handle(_pyFilter) myFilter;
638   bool              myCanClearCreationCmd;
639 public:
640   _pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id=_pyID());
641   virtual void Process( const Handle(_pyCommand)& theCommand);
642   virtual void Flush();
643   virtual void Free() { myFilter.Nullify(); }
644   virtual bool CanClear();
645   void RemovedWithContents();
646
647   OCCT_DEFINE_STANDARD_RTTIEXT(_pyGroup,_pySubMesh)
648 };
649
650 // -------------------------------------------------------------------------------------
651 /*!
652  * \brief Class reading _pyHypothesis'es from resource files of mesher Plugins
653  */
654 // -------------------------------------------------------------------------------------
655 class _pyHypothesisReader: public Standard_Transient
656 {
657   std::map<_AString, Handle(_pyHypothesis)> myType2Hyp;
658 public:
659   _pyHypothesisReader();
660   Handle(_pyHypothesis) GetHypothesis(const _AString&           hypType,
661                                       const Handle(_pyCommand)& creationCmd) const;
662   OCCT_DEFINE_STANDARD_RTTIEXT(_pyHypothesisReader,Standard_Transient)
663 };
664
665 #endif