]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESH_I/SMESH_2smeshpy.hxx
Salome HOME
Porting documentation on the Doxygen-1.8.0
[modules/smesh.git] / src / SMESH_I / SMESH_2smeshpy.hxx
1 // Copyright (C) 2007-2011  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.
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
37 #include <list>
38 #include <map>
39 #include <vector>
40
41 #include <SALOMEconfig.h>
42 #include CORBA_CLIENT_HEADER(SALOMEDS)
43
44 // ===========================================================================================
45 /*!
46  * This file was created in order to respond to requirement of bug PAL10494:
47  * SMESH python dump uses idl interface.
48  *
49  * The creation reason is that smesh.py commands defining hypotheses encapsulate
50  * several SMESH engine method calls. As well, the dependencies between smesh.py
51  * classes differ from ones between corresponding SMESH IDL interfaces.
52  * 
53  * Everything here is for internal usage by SMESH_2smeshpy::ConvertScript()
54  * declared in SMESH_PythonDump.hxx
55  */
56 // ===========================================================================================
57
58 class Resource_DataMapOfAsciiStringAsciiString;
59
60 // ===========================================================================================
61 // =====================
62 //    INTERNAL STUFF
63 // =====================
64 // ===========================================================================================
65
66 class _pyCommand;
67 class _pyObject;
68 class _pyGen;
69 class _pyMesh;
70 class _pySubMesh;
71 class _pyHypothesis;
72 class _pyAlgorithm;
73 class _pyHypothesisReader;
74
75 DEFINE_STANDARD_HANDLE (_pyCommand         ,Standard_Transient);
76 DEFINE_STANDARD_HANDLE (_pyObject          ,Standard_Transient);
77 DEFINE_STANDARD_HANDLE (_pyHypothesisReader,Standard_Transient);
78 DEFINE_STANDARD_HANDLE (_pyGen             ,_pyObject);
79 DEFINE_STANDARD_HANDLE (_pyMesh            ,_pyObject);
80 DEFINE_STANDARD_HANDLE (_pySubMesh         ,_pyObject);
81 DEFINE_STANDARD_HANDLE (_pyGroup           ,_pySubMesh);
82 DEFINE_STANDARD_HANDLE (_pyMeshEditor      ,_pyObject);
83 DEFINE_STANDARD_HANDLE (_pyHypothesis      ,_pyObject);
84 DEFINE_STANDARD_HANDLE (_pyAlgorithm       ,_pyHypothesis);
85
86 typedef TCollection_AsciiString _pyID;
87 typedef TCollection_AsciiString _AString;
88
89 // ===========================================================
90 /*!
91  * \brief Class operating on a command string looking like
92  *        ResultValue = Object.Method( Arg1, Arg2,...)
93  */
94 // ===========================================================
95
96 class _pyCommand: public Standard_Transient
97 {
98   int                             myOrderNb;            //!< position within the script
99   _AString                        myString;             //!< command text
100   _AString                        myRes, myObj, myMeth; //!< found parts of command
101   TColStd_SequenceOfAsciiString   myArgs;               //!< found arguments
102   TColStd_SequenceOfInteger       myBegPos;             //!< where myRes, myObj, ... begin
103   std::list< Handle(_pyCommand) > myDependentCmds; //!< commands that sould follow me in the script
104
105   enum { UNKNOWN=-1, EMPTY=0, RESULT_IND, OBJECT_IND, METHOD_IND, ARG1_IND };
106   int  GetBegPos( int thePartIndex );
107   void SetBegPos( int thePartIndex, int thePosition );
108   void SetPart( int thePartIndex, const _AString& theNewPart, _AString& theOldPart);
109   void FindAllArgs() { GetArg(1); }
110
111 public:
112   _pyCommand() {};
113   _pyCommand( const _AString& theString, int theNb=-1 )
114     : myString( theString ), myOrderNb( theNb ) {};
115   _AString & GetString() { return myString; }
116   int GetOrderNb() const { return myOrderNb; }
117   void SetOrderNb( int theNb ) { myOrderNb = theNb; }
118   typedef void* TAddr;
119   TAddr GetAddress() const { return (void*) this; }
120   int Length() { return myString.Length(); }
121   void Clear() { myString.Clear(); myBegPos.Clear(); myArgs.Clear(); }
122   bool IsEmpty() const { return myString.IsEmpty(); }
123   _AString GetIndentation();
124   const _AString & GetResultValue();
125   const int GetNbResultValues();
126   const _AString & GetResultValue(int res);
127   const _AString & GetObject();
128   const _AString & GetMethod();
129   const _AString & GetArg( int index );
130   int GetNbArgs() { FindAllArgs(); return myArgs.Length(); }
131   bool MethodStartsFrom(const _AString& beg)
132   { GetMethod(); return ( myMeth.Location( beg, 1, myMeth.Length() ) == 1 ); }
133   void SetResultValue( const _AString& theResult )
134   { GetResultValue(); SetPart( RESULT_IND, theResult, myRes ); }
135   void SetObject(const _AString& theObject)
136   { GetObject(); SetPart( OBJECT_IND, theObject, myObj ); }
137   void SetMethod(const _AString& theMethod)
138   { GetMethod(); SetPart( METHOD_IND, theMethod, myMeth ); }
139   void SetArg( int index, const _AString& theArg);
140   void RemoveArgs();
141   void Comment();
142   static bool SkipSpaces( const _AString & theSring, int & thePos );
143   static _AString GetWord( const _AString & theSring, int & theStartPos,
144                            const bool theForward, const bool dotIsWord = false);
145   static bool IsStudyEntry( const _AString& str );
146   static std::list< _pyID > GetStudyEntries( const _AString& str );
147   void AddDependantCmd( Handle(_pyCommand) cmd, bool prepend = false)
148   { if (prepend) myDependentCmds.push_front( cmd ); else myDependentCmds.push_back( cmd ); }
149   bool SetDependentCmdsAfter() const;
150
151   bool AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod );
152
153   DEFINE_STANDARD_RTTI (_pyCommand)
154 };
155
156 // -------------------------------------------------------------------------------------
157 /*!
158  * \brief Root of all objects. It counts calls of Process()
159  */
160 // -------------------------------------------------------------------------------------
161
162 class _pyObject: public Standard_Transient
163 {
164 protected:
165   _pyID                           myID;
166   Handle(_pyCommand)              myCreationCmd;
167   std::list< Handle(_pyCommand) > myProcessedCmds;
168   bool                            myIsPublished;
169
170   void setID(const _pyID& theID);
171 public:
172   _pyObject(const Handle(_pyCommand)& theCreationCmd, const _pyID& theID=_pyID());
173   const _pyID& GetID() { return myID.IsEmpty() ? myCreationCmd->GetResultValue() : myID; }
174   static _pyID FatherID(const _pyID & childID);
175   const Handle(_pyCommand)& GetCreationCmd() { return myCreationCmd; }
176   int GetNbCalls() const { return myProcessedCmds.size(); }
177   bool IsInStudy() const { return myIsPublished; }
178   virtual void SetRemovedFromStudy(const bool isRemoved) { myIsPublished = !isRemoved; }
179   void SetCreationCmd( Handle(_pyCommand) cmd ) { myCreationCmd = cmd; }
180   int GetCommandNb() { return myCreationCmd->GetOrderNb(); }
181   void AddProcessedCmd( const Handle(_pyCommand) & cmd )
182   { if (myProcessedCmds.empty() || myProcessedCmds.back()!=cmd) myProcessedCmds.push_back( cmd );}
183   std::list< Handle(_pyCommand) >& GetProcessedCmds() { return myProcessedCmds; }
184   virtual void Process(const Handle(_pyCommand) & cmd) { AddProcessedCmd(cmd); }
185   virtual void Flush() = 0;
186   virtual const char* AccessorMethod() const;
187   virtual bool CanClear() { return !myIsPublished; }
188   virtual void ClearCommands();
189   virtual void Free() {}
190
191   DEFINE_STANDARD_RTTI (_pyObject)
192 };
193
194 // -------------------------------------------------------------------------------------
195 /*!
196  * \brief Data used to restore cleared Compute() command of an exported mesh
197  * when an imported mesh is created
198  */
199 // -------------------------------------------------------------------------------------
200 struct ExportedMeshData
201 {
202   Handle(_pyMesh)    myMesh;
203   Handle(_pyCommand) myLastComputeCmd;
204   _AString           myLastComputeCmdString;
205   ExportedMeshData() {}
206   ExportedMeshData( const Handle(_pyMesh)& mesh, Handle(_pyCommand) computeCmd):
207     myMesh( mesh ), myLastComputeCmd( computeCmd )
208   {
209     if ( !myLastComputeCmd.IsNull())
210       myLastComputeCmdString = myLastComputeCmd->GetString();
211   }
212 };
213
214 // -------------------------------------------------------------------------------------
215 /*!
216  * \brief Class corresponding to SMESH_Gen. It holds info on existing
217  *        meshes and hypotheses
218  */
219 // -------------------------------------------------------------------------------------
220 class _pyGen: public _pyObject
221 {
222 public:
223   _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
224          Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
225          SALOMEDS::Study_ptr&                      theStudy,
226          const bool                                theToKeepAllCommands);
227   Handle(_pyCommand) AddCommand( const _AString& theCommand );
228   void ExchangeCommands( Handle(_pyCommand) theCmd1, Handle(_pyCommand) theCmd2 );
229   void SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd );
230   void SetCommandBefore( Handle(_pyCommand) theCmd, Handle(_pyCommand) theBeforeCmd );
231   Handle(_pyCommand)& GetLastCommand();
232   std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; }
233
234   _pyID GenerateNewID( const _pyID& theID );
235   void AddObject( Handle(_pyObject)& theObj );
236   void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
237   Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
238   Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
239   Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
240   Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
241                                   const Handle(_pyHypothesis)& theHypothesis);
242
243   void SetAccessorMethod(const _pyID& theID, const char* theMethod );
244   bool AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const;
245   bool AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const;
246   virtual const char* AccessorMethod() const;
247
248   bool IsGeomObject(const _pyID& theObjID) const;
249   bool IsNotPublished(const _pyID& theObjID) const;
250   bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
251   void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
252   { myFile2ExportedMesh[ file ] = mesh; }
253   ExportedMeshData& FindExportedMesh( const _AString& file )
254   { return myFile2ExportedMesh[ file ]; }
255
256   virtual void Process( const Handle(_pyCommand)& theCommand );
257   virtual void Flush();
258   virtual void ClearCommands();
259   virtual void Free();
260
261   Handle( _pyHypothesisReader ) GetHypothesisReader() const;
262
263 private:
264   void setNeighbourCommand( Handle(_pyCommand)& theCmd,
265                             Handle(_pyCommand)& theOtherCmd,
266                             const bool theIsAfter );
267   
268 private:
269   std::map< _pyID, Handle(_pyMesh) >       myMeshes;
270   std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
271   std::map< _pyID, Handle(_pyObject) >     myObjects;
272   std::list< Handle(_pyHypothesis) >       myHypos;
273   std::list< Handle(_pyCommand) >          myCommands;
274   int                                      myNbCommands;
275   Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
276   Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
277   Handle(_pyCommand)                       myLastCommand;
278   int                                      myNbFilters;
279   bool                                     myToKeepAllCommands;
280   SALOMEDS::Study_var                      myStudy;
281   int                                      myGeomIDNb, myGeomIDIndex;
282   std::map< _AString, ExportedMeshData >   myFile2ExportedMesh;
283   Handle( _pyHypothesisReader )            myHypReader;
284
285   DEFINE_STANDARD_RTTI (_pyGen)
286 };
287
288 // -------------------------------------------------------------------------------------
289 /*!
290  * \brief Contains commands concerning mesh substructures
291  */
292 // -------------------------------------------------------------------------------------
293 #define _pyMesh_ACCESS_METHOD "GetMesh()"
294 class _pyMesh: public _pyObject
295 {
296   std::list< Handle(_pyHypothesis) > myHypos;
297   std::list< Handle(_pyCommand) >    myAddHypCmds;
298   std::list< Handle(_pySubMesh) >    mySubmeshes;
299   std::list< Handle(_pyGroup) >      myGroups;
300   std::list< Handle(_pyMeshEditor)>  myEditors;
301   //d::list< Handle(_pyMesh) >       myFatherMeshes; // this mesh depends on
302   std::list< Handle(_pyMesh) >       myChildMeshes; // depending on me
303   bool                               myGeomNotInStudy;
304   Handle(_pyCommand)                 myLastComputeCmd;
305 public:
306   _pyMesh(const Handle(_pyCommand) creationCmd);
307   _pyMesh(const Handle(_pyCommand) theCreationCmd, const _pyID & id);
308   const _pyID& GetGeom() { return GetCreationCmd()->GetArg(1); }
309   void AddGroup( const Handle(_pyGroup)& g ) { myGroups.push_back( g ); }
310   void AddEditor( const Handle(_pyMeshEditor)& e ) { myEditors.push_back( e ); }
311   bool IsNotGeomPublished() { return myGeomNotInStudy; }
312   virtual void Process( const Handle(_pyCommand)& theCommand);
313   virtual void Flush();
314   virtual void SetRemovedFromStudy(const bool isRemoved);
315   virtual bool CanClear();
316   virtual void ClearCommands();
317   virtual void Free() { /*myFatherMeshes.clear();*/ myChildMeshes.clear(); }
318   virtual const char* AccessorMethod() const { return _pyMesh_ACCESS_METHOD; }
319 private:
320   void addFatherMesh( const Handle(_pyMesh)& mesh );
321   void addFatherMesh( const _pyID& meshID );
322   static bool NeedMeshAccess( const Handle(_pyCommand)& theCommand );
323   static void AddMeshAccess( const Handle(_pyCommand)& theCommand )
324   { theCommand->SetObject( theCommand->GetObject() + "." _pyMesh_ACCESS_METHOD ); }
325
326   DEFINE_STANDARD_RTTI (_pyMesh)
327 };
328 #undef _pyMesh_ACCESS_METHOD 
329
330 // -------------------------------------------------------------------------------------
331 /*!
332  * \brief MeshEditor convert its commands to ones of mesh
333  */
334 // -------------------------------------------------------------------------------------
335 class _pyMeshEditor: public _pyObject
336 {
337   _pyID    myMesh;
338   _AString myCreationCmdStr;
339 public:
340   _pyMeshEditor(const Handle(_pyCommand)& theCreationCmd);
341   _pyID GetMesh() const { return myMesh; }
342   virtual void Process( const Handle(_pyCommand)& theCommand);
343   virtual void Flush() {}
344   virtual bool CanClear();
345
346   DEFINE_STANDARD_RTTI (_pyMesh)
347 };
348
349 // -------------------------------------------------------------------------------------
350 /*!
351  * \brief Root class for hypothesis
352  */
353 // -------------------------------------------------------------------------------------
354 class _pyHypothesis: public _pyObject
355 {
356   friend class _pyHypothesisReader;
357 protected:
358   bool    myIsAlgo, myIsWrapped;
359   _pyID   myGeom,   myMesh;
360   struct CreationMethod {
361     _AString              myMethod; // method of algo or mesh creating a hyp
362     // myArgNb(i)-th arg of myArgMethods(i) of hyp becomes an i-th arg of myAlgoMethod
363     std::vector<_AString> myArgMethods;
364     std::vector<int>      myArgNb; // arg nb countered from 1
365     std::vector<_AString> myArgs; // creation arguments
366   };
367   void setCreationArg( const int argNb, const _AString& arg );
368   // a hypothesis can be created by different algos by different methods
369   typedef std::map<_AString, CreationMethod > TType2CrMethod;
370   TType2CrMethod                myAlgoType2CreationMethod;
371   CreationMethod*               myCurCrMethod; // used for adding to myAlgoType2CreationMethod
372   std::list<Handle(_pyCommand)> myArgCommands;
373   std::list<Handle(_pyCommand)> myUnusedCommands;
374   std::list<Handle(_pyObject) > myReferredObjs;
375   // maps used to clear commands setting parameters if result of setting is
376   // discared (e.g. by mesh.Clear())
377   std::map<_AString, std::list<Handle(_pyCommand)> >            myMeth2Commands;
378   std::map< _pyCommand::TAddr, std::list<Handle(_pyCommand) > > myComputeAddr2Cmds;
379   std::list<Handle(_pyCommand) >                                myComputeCmds;
380   void rememberCmdOfParameter( const Handle(_pyCommand) & cmd );
381   bool isCmdUsedForCompute( const Handle(_pyCommand) & cmd,
382                             _pyCommand::TAddr avoidComputeAddr=NULL ) const;
383 public:
384   _pyHypothesis(const Handle(_pyCommand)& theCreationCmd);
385   void SetConvMethodAndType(const _AString& creationMethod, const _AString& type)
386   { myCurCrMethod = &myAlgoType2CreationMethod[ type ];
387     myCurCrMethod->myMethod = creationMethod; }
388   void AddArgMethod(const _AString& method, const int argNb = 1)
389   { myCurCrMethod->myArgMethods.push_back( method );
390     myCurCrMethod->myArgNb.push_back( argNb ); }
391   //const TColStd_SequenceOfAsciiString& GetArgs() const { return myArgs; }
392   const std::list<Handle(_pyCommand)>& GetArgCommands() const { return myArgCommands; }
393   void ClearAllCommands();
394   virtual bool IsAlgo() const { return myIsAlgo; }
395   bool IsValid() const { return !myAlgoType2CreationMethod.empty(); }
396   bool IsWrapped() const { return myIsWrapped; }
397   const _pyID & GetGeom() const { return myGeom; }
398   void SetMesh( const _pyID& theMeshId) { if ( myMesh.IsEmpty() ) myMesh = theMeshId; }
399   const _pyID & GetMesh() const { return myMesh; }
400   const _AString& GetAlgoType() const
401   { return myAlgoType2CreationMethod.begin()->first; }
402   const _AString& GetAlgoCreationMethod() const
403   { return myAlgoType2CreationMethod.begin()->second.myMethod; }
404   bool CanBeCreatedBy(const _AString& algoType ) const
405   { return myAlgoType2CreationMethod.find( algoType ) != myAlgoType2CreationMethod.end(); }
406   const _AString& GetCreationMethod(const _AString& algoType)
407   { return ( myCurCrMethod = & myAlgoType2CreationMethod[ algoType ])->myMethod; }
408   static Handle(_pyHypothesis) NewHypothesis( const Handle(_pyCommand)& theCreationCmd);
409
410   virtual bool IsWrappable(const _pyID& theMesh) const;
411   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
412                                   const _pyID&              theMesh);
413   virtual void Process( const Handle(_pyCommand)& theCommand);
414   virtual void Flush();
415   virtual void Free() { myReferredObjs.clear(); }
416   virtual void Assign( const Handle(_pyHypothesis)& theOther,
417                        const _pyID&                 theMesh );
418   virtual bool CanClear();
419   virtual void ClearCommands();
420   virtual bool GetReferredMeshesAndGeom( std::list< Handle(_pyMesh) >& meshes );
421
422   void MeshComputed    ( const Handle(_pyCommand)& theComputeCommand );
423   void ComputeDiscarded( const Handle(_pyCommand)& theComputeCommand );
424   //void ComputeSaved    ( const Handle(_pyCommand)& theComputeCommand );
425
426
427   DEFINE_STANDARD_RTTI (_pyHypothesis)
428 };
429
430 // -------------------------------------------------------------------------------------
431 /*!
432  * \brief Class representing smesh.Mesh_Algorithm
433  */
434 // -------------------------------------------------------------------------------------
435 class _pyAlgorithm: public _pyHypothesis
436 {
437 public:
438   _pyAlgorithm(const Handle(_pyCommand)& theCreationCmd);
439   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
440                                   const _pyID&              theMesh);
441   virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
442   virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
443
444   DEFINE_STANDARD_RTTI (_pyAlgorithm)
445 };
446
447 // -------------------------------------------------------------------------------------
448 /*!
449  * \brief Class for hypotheses having several parameters modified by one method
450  */
451 // -------------------------------------------------------------------------------------
452 class _pyComplexParamHypo: public _pyHypothesis
453 {
454 public:
455   _pyComplexParamHypo(const Handle(_pyCommand)& theCreationCmd): _pyHypothesis(theCreationCmd) {}
456   virtual void Process( const Handle(_pyCommand)& theCommand);
457   virtual void Flush();
458
459   DEFINE_STANDARD_RTTI (_pyComplexParamHypo)
460 };
461 DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
462
463 // -------------------------------------------------------------------------------------
464 /*!
465  * \brief Class for LayerDistribution hypothesis conversion
466  */
467 // -------------------------------------------------------------------------------------
468 class _pyLayerDistributionHypo: public _pyHypothesis
469 {
470   Handle(_pyHypothesis) my1dHyp;
471   _AString              myAlgoMethod;
472 public:
473   _pyLayerDistributionHypo(const Handle(_pyCommand)& theCreationCmd, const char* algoMethod):
474     _pyHypothesis(theCreationCmd), myAlgoMethod((char*)algoMethod) {}
475   virtual void Process( const Handle(_pyCommand)& theCommand);
476   virtual void Flush();
477   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
478                                   const _pyID&              theMesh);
479   virtual void Free() { my1dHyp.Nullify(); }
480
481   DEFINE_STANDARD_RTTI (_pyLayerDistributionHypo)
482 };
483 DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
484
485 // -------------------------------------------------------------------------------------
486 /*!
487  * \brief Class representing NumberOfSegments hypothesis
488  */
489 // -------------------------------------------------------------------------------------
490 class _pyNumberOfSegmentsHyp: public _pyHypothesis
491 {
492 public:
493   _pyNumberOfSegmentsHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
494   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
495                                   const _pyID&              theMesh);
496   void Flush();
497
498   DEFINE_STANDARD_RTTI (_pyNumberOfSegmentsHyp)
499 };
500 DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
501
502 // -------------------------------------------------------------------------------------
503 /*!
504  * \brief Class representing SegmentLengthAroundVertex hypothesis
505  */
506 // -------------------------------------------------------------------------------------
507 class _pySegmentLengthAroundVertexHyp: public _pyHypothesis
508 {
509 public:
510   _pySegmentLengthAroundVertexHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
511   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
512                                   const _pyID&              theMesh);
513   DEFINE_STANDARD_RTTI (_pySegmentLengthAroundVertexHyp)
514 };
515 DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
516
517 // -------------------------------------------------------------------------------------
518 /*!
519  * \brief SelfEraser erases creation command if no more it's commands invoked
520  */
521 // -------------------------------------------------------------------------------------
522 class _pySelfEraser: public _pyObject
523 {
524 public:
525   _pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
526     :_pyObject(theCreationCmd) { myIsPublished = true; }
527   virtual void Flush();
528
529   DEFINE_STANDARD_RTTI (_pySelfEraser)
530 };
531 DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
532
533 // -------------------------------------------------------------------------------------
534 /*!
535  * \brief SubMesh creation can be moved to the end of engine commands
536  */
537 // -------------------------------------------------------------------------------------
538 class _pySubMesh:  public _pyObject
539 {
540   Handle(_pyObject) myCreator;
541   Handle(_pyMesh) myMesh;
542 public:
543   _pySubMesh(const Handle(_pyCommand)& theCreationCmd);
544   virtual void Process( const Handle(_pyCommand)& theCommand);
545   virtual void Flush();
546   virtual Handle(_pyMesh) GetMesh() { return myMesh; }
547   virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
548   void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
549
550   DEFINE_STANDARD_RTTI (_pySubMesh)
551 };
552 // -------------------------------------------------------------------------------------
553 /*!
554  * \brief A filter sets a human readable name to self
555  */
556 // -------------------------------------------------------------------------------------
557 class _pyFilter:  public _pyObject
558 {
559   _pyID myNewID, myMesh;
560   std::list< Handle(_pyObject) > myUsers;
561 public:
562   _pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID="");
563   void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
564   virtual void Process( const Handle(_pyCommand)& theCommand);
565   virtual void Flush();
566   virtual bool CanClear();
567   virtual void Free() { myUsers.clear(); }
568   const _pyID& GetNewID() const { return myNewID; }
569
570   DEFINE_STANDARD_RTTI (_pyFilter)
571 };
572 DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
573
574 // -------------------------------------------------------------------------------------
575 /*!
576  * \brief To convert creation of a group by filter
577  */
578 // -------------------------------------------------------------------------------------
579 class _pyGroup:  public _pySubMesh
580 {
581   Handle(_pyFilter) myFilter;
582 public:
583   _pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id=_pyID());
584   virtual void Process( const Handle(_pyCommand)& theCommand);
585   virtual void Flush() {}
586   virtual void Free() { myFilter.Nullify(); }
587
588   DEFINE_STANDARD_RTTI (_pyGroup)
589 };
590
591 // -------------------------------------------------------------------------------------
592 /*!
593  * \brief Class reading _pyHypothesis'es from resource files of mesher Plugins
594  */
595 // -------------------------------------------------------------------------------------
596 class _pyHypothesisReader: public Standard_Transient
597 {
598   std::map<_AString, Handle(_pyHypothesis)> myType2Hyp;
599 public:
600   _pyHypothesisReader();
601   Handle(_pyHypothesis) GetHypothesis(const _AString&           hypType,
602                                       const Handle(_pyCommand)& creationCmd) const;
603   DEFINE_STANDARD_RTTI (_pyHypothesisReader)
604 };
605
606 #endif