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   Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
 237   Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
 238   Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
 239   Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
 240                                   const Handle(_pyHypothesis)& theHypothesis);
 241
 242   void SetAccessorMethod(const _pyID& theID, const char* theMethod );
 243   bool AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const;
 244   bool AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const;
 245   virtual const char* AccessorMethod() const;
 246
 247   bool IsGeomObject(const _pyID& theObjID) const;
 248   bool IsNotPublished(const _pyID& theObjID) const;
 249   bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
 250   void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
 251   { myFile2ExportedMesh[ file ] = mesh; }
 252   ExportedMeshData& FindExportedMesh( const _AString& file )
 253   { return myFile2ExportedMesh[ file ]; }
 254
 255   virtual void Process( const Handle(_pyCommand)& theCommand );
 256   virtual void Flush();
 257   virtual void ClearCommands();
 258   virtual void Free();
 259
 260   Handle( _pyHypothesisReader ) GetHypothesisReader() const;
 261
 262 private:
 263   void setNeighbourCommand( Handle(_pyCommand)& theCmd,
 264                             Handle(_pyCommand)& theOtherCmd,
 265                             const bool theIsAfter );
 266
 267 private:
 268   std::map< _pyID, Handle(_pyMesh) >       myMeshes;
 269   std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
 270   std::map< _pyID, Handle(_pyObject) >     myObjects;
 271   std::list< Handle(_pyHypothesis) >       myHypos;
 272   std::list< Handle(_pyCommand) >          myCommands;
 273   int                                      myNbCommands;
 274   Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
 275   Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
 276   Handle(_pyCommand)                       myLastCommand;
 277   int                                      myNbFilters;
 278   bool                                     myToKeepAllCommands;
 279   SALOMEDS::Study_var                      myStudy;
 280   int                                      myGeomIDNb, myGeomIDIndex;
 281   std::map< _AString, ExportedMeshData >   myFile2ExportedMesh;
 282   Handle( _pyHypothesisReader )            myHypReader;
 283
 284   DEFINE_STANDARD_RTTI (_pyGen)
 285 };
 286
 287 // -------------------------------------------------------------------------------------
 288 /*!
 289  * \brief Contains commands concerning mesh substructures
 290  */
 291 // -------------------------------------------------------------------------------------
 292 #define _pyMesh_ACCESS_METHOD "GetMesh()"
 293 class _pyMesh: public _pyObject
 294 {
 295   std::list< Handle(_pyHypothesis) > myHypos;
 296   std::list< Handle(_pyCommand) >    myAddHypCmds;
 297   std::list< Handle(_pySubMesh) >    mySubmeshes;
 298   std::list< Handle(_pyGroup) >      myGroups;
 299   std::list< Handle(_pyMeshEditor)>  myEditors;
 300   //d::list< Handle(_pyMesh) >       myFatherMeshes; // this mesh depends on
 301   std::list< Handle(_pyMesh) >       myChildMeshes; // depending on me
 302   bool                               myGeomNotInStudy;
 303   Handle(_pyCommand)                 myLastComputeCmd;
 304 public:
 305   _pyMesh(const Handle(_pyCommand) creationCmd);
 306   _pyMesh(const Handle(_pyCommand) theCreationCmd, const _pyID & id);
 307   const _pyID& GetGeom() { return GetCreationCmd()->GetArg(1); }
 308   void AddGroup( const Handle(_pyGroup)& g ) { myGroups.push_back( g ); }
 309   void AddEditor( const Handle(_pyMeshEditor)& e ) { myEditors.push_back( e ); }
 310   bool IsNotGeomPublished() { return myGeomNotInStudy; }
 311   virtual void Process( const Handle(_pyCommand)& theCommand);
 312   virtual void Flush();
 313   virtual void SetRemovedFromStudy(const bool isRemoved);
 314   virtual bool CanClear();
 315   virtual void ClearCommands();
 316   virtual void Free() { /*myFatherMeshes.clear();*/ myChildMeshes.clear(); }
 317   virtual const char* AccessorMethod() const { return _pyMesh_ACCESS_METHOD; }
 318 private:
 319   void addFatherMesh( const Handle(_pyMesh)& mesh );
 320   void addFatherMesh( const _pyID& meshID );
 321   static bool NeedMeshAccess( const Handle(_pyCommand)& theCommand );
 322   static void AddMeshAccess( const Handle(_pyCommand)& theCommand )
 323   { theCommand->SetObject( theCommand->GetObject() + "." _pyMesh_ACCESS_METHOD ); }
 324
 325   DEFINE_STANDARD_RTTI (_pyMesh)
 326 };
 327 #undef _pyMesh_ACCESS_METHOD
 328
 329 // -------------------------------------------------------------------------------------
 330 /*!
 331  * \brief MeshEditor convert its commands to ones of mesh
 332  */
 333 // -------------------------------------------------------------------------------------
 334 class _pyMeshEditor: public _pyObject
 335 {
 336   _pyID    myMesh;
 337   _AString myCreationCmdStr;
 338 public:
 339   _pyMeshEditor(const Handle(_pyCommand)& theCreationCmd);
 340   _pyID GetMesh() const { return myMesh; }
 341   virtual void Process( const Handle(_pyCommand)& theCommand);
 342   virtual void Flush() {}
 343   virtual bool CanClear();
 344
 345   DEFINE_STANDARD_RTTI (_pyMesh)
 346 };
 347
 348 // -------------------------------------------------------------------------------------
 349 /*!
 350  * \brief Root class for hypothesis
 351  */
 352 // -------------------------------------------------------------------------------------
 353 class _pyHypothesis: public _pyObject
 354 {
 355   friend class _pyHypothesisReader;
 356 protected:
 357   bool    myIsAlgo, myIsWrapped;
 358   _pyID   myGeom,   myMesh;
 359   struct CreationMethod {
 360     _AString              myMethod; // method of algo or mesh creating a hyp
 361     // myArgNb(i)-th arg of myArgMethods(i) of hyp becomes an i-th arg of myAlgoMethod
 362     std::vector<_AString> myArgMethods;
 363     std::vector<int>      myArgNb; // arg nb countered from 1
 364     std::vector<_AString> myArgs; // creation arguments
 365   };
 366   void setCreationArg( const int argNb, const _AString& arg );
 367   // a hypothesis can be created by different algos by different methods
 368   typedef std::map<_AString, CreationMethod > TType2CrMethod;
 369   TType2CrMethod                myAlgoType2CreationMethod;
 370   CreationMethod*               myCurCrMethod; // used for adding to myAlgoType2CreationMethod
 371   std::list<Handle(_pyCommand)> myArgCommands;
 372   std::list<Handle(_pyCommand)> myUnusedCommands;
 373   std::list<Handle(_pyObject) > myReferredObjs;
 374   // maps used to clear commands setting parameters if result of setting is
 375   // discared (e.g. by mesh.Clear())
 376   std::map<_AString, std::list<Handle(_pyCommand)> >            myMeth2Commands;
 377   std::map< _pyCommand::TAddr, std::list<Handle(_pyCommand) > > myComputeAddr2Cmds;
 378   std::list<Handle(_pyCommand) >                                myComputeCmds;
 379   void rememberCmdOfParameter( const Handle(_pyCommand) & cmd );
 380   bool isCmdUsedForCompute( const Handle(_pyCommand) & cmd,
 381                             _pyCommand::TAddr avoidComputeAddr=NULL ) const;
 382 public:
 383   _pyHypothesis(const Handle(_pyCommand)& theCreationCmd);
 384   void SetConvMethodAndType(const _AString& creationMethod, const _AString& type)
 385   { myCurCrMethod = &myAlgoType2CreationMethod[ type ];
 386     myCurCrMethod->myMethod = creationMethod; }
 387   void AddArgMethod(const _AString& method, const int argNb = 1)
 388   { myCurCrMethod->myArgMethods.push_back( method );
 389     myCurCrMethod->myArgNb.push_back( argNb ); }
 390   //const TColStd_SequenceOfAsciiString& GetArgs() const { return myArgs; }
 391   const std::list<Handle(_pyCommand)>& GetArgCommands() const { return myArgCommands; }
 392   void ClearAllCommands();
 393   virtual bool IsAlgo() const { return myIsAlgo; }
 394   bool IsValid() const { return !myAlgoType2CreationMethod.empty(); }
 395   bool IsWrapped() const { return myIsWrapped; }
 396   const _pyID & GetGeom() const { return myGeom; }
 397   void SetMesh( const _pyID& theMeshId) { if ( myMesh.IsEmpty() ) myMesh = theMeshId; }
 398   const _pyID & GetMesh() const { return myMesh; }
 399   const _AString& GetAlgoType() const
 400   { return myAlgoType2CreationMethod.begin()->first; }
 401   const _AString& GetAlgoCreationMethod() const
 402   { return myAlgoType2CreationMethod.begin()->second.myMethod; }
 403   bool CanBeCreatedBy(const _AString& algoType ) const
 404   { return myAlgoType2CreationMethod.find( algoType ) != myAlgoType2CreationMethod.end(); }
 405   const _AString& GetCreationMethod(const _AString& algoType)
 406   { return ( myCurCrMethod = & myAlgoType2CreationMethod[ algoType ])->myMethod; }
 407   static Handle(_pyHypothesis) NewHypothesis( const Handle(_pyCommand)& theCreationCmd);
 408
 409   virtual bool IsWrappable(const _pyID& theMesh) const;
 410   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
 411                                   const _pyID&              theMesh);
 412   virtual void Process( const Handle(_pyCommand)& theCommand);
 413   virtual void Flush();
 414   virtual void Free() { myReferredObjs.clear(); }
 415   virtual void Assign( const Handle(_pyHypothesis)& theOther,
 416                        const _pyID&                 theMesh );
 417   virtual bool CanClear();
 418   virtual void ClearCommands();
 419   virtual bool GetReferredMeshesAndGeom( std::list< Handle(_pyMesh) >& meshes );
 420
 421   void MeshComputed    ( const Handle(_pyCommand)& theComputeCommand );
 422   void ComputeDiscarded( const Handle(_pyCommand)& theComputeCommand );
 423   //void ComputeSaved    ( const Handle(_pyCommand)& theComputeCommand );
 424
 425
 426   DEFINE_STANDARD_RTTI (_pyHypothesis)
 427 };
 428
 429 // -------------------------------------------------------------------------------------
 430 /*!
 431  * \brief Class representing smesh.Mesh_Algorithm
 432  */
 433 // -------------------------------------------------------------------------------------
 434 class _pyAlgorithm: public _pyHypothesis
 435 {
 436 public:
 437   _pyAlgorithm(const Handle(_pyCommand)& theCreationCmd);
 438   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
 439                                   const _pyID&              theMesh);
 440   virtual const char* AccessorMethod() const { return "GetAlgorithm()"; }
 441   virtual bool IsWrappable(const _pyID& theMesh) { return !myIsWrapped; }
 442
 443   DEFINE_STANDARD_RTTI (_pyAlgorithm)
 444 };
 445
 446 // -------------------------------------------------------------------------------------
 447 /*!
 448  * \brief Class for hypotheses having several parameters modified by one method
 449  */
 450 // -------------------------------------------------------------------------------------
 451 class _pyComplexParamHypo: public _pyHypothesis
 452 {
 453 public:
 454   _pyComplexParamHypo(const Handle(_pyCommand)& theCreationCmd): _pyHypothesis(theCreationCmd) {}
 455   virtual void Process( const Handle(_pyCommand)& theCommand);
 456   virtual void Flush();
 457
 458   DEFINE_STANDARD_RTTI (_pyComplexParamHypo)
 459 };
 460 DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis);
 461
 462 // -------------------------------------------------------------------------------------
 463 /*!
 464  * \brief Class for LayerDistribution hypothesis conversion
 465  */
 466 // -------------------------------------------------------------------------------------
 467 class _pyLayerDistributionHypo: public _pyHypothesis
 468 {
 469   Handle(_pyHypothesis) my1dHyp;
 470   _AString              myAlgoMethod;
 471 public:
 472   _pyLayerDistributionHypo(const Handle(_pyCommand)& theCreationCmd, const char* algoMethod):
 473     _pyHypothesis(theCreationCmd), myAlgoMethod((char*)algoMethod) {}
 474   virtual void Process( const Handle(_pyCommand)& theCommand);
 475   virtual void Flush();
 476   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
 477                                   const _pyID&              theMesh);
 478   virtual void Free() { my1dHyp.Nullify(); }
 479
 480   DEFINE_STANDARD_RTTI (_pyLayerDistributionHypo)
 481 };
 482 DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis);
 483
 484 // -------------------------------------------------------------------------------------
 485 /*!
 486  * \brief Class representing NumberOfSegments hypothesis
 487  */
 488 // -------------------------------------------------------------------------------------
 489 class _pyNumberOfSegmentsHyp: public _pyHypothesis
 490 {
 491 public:
 492   _pyNumberOfSegmentsHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
 493   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
 494                                   const _pyID&              theMesh);
 495   void Flush();
 496
 497   DEFINE_STANDARD_RTTI (_pyNumberOfSegmentsHyp)
 498 };
 499 DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis);
 500
 501 // -------------------------------------------------------------------------------------
 502 /*!
 503  * \brief Class representing SegmentLengthAroundVertex hypothesis
 504  */
 505 // -------------------------------------------------------------------------------------
 506 class _pySegmentLengthAroundVertexHyp: public _pyHypothesis
 507 {
 508 public:
 509   _pySegmentLengthAroundVertexHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {}
 510   virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd,
 511                                   const _pyID&              theMesh);
 512   DEFINE_STANDARD_RTTI (_pySegmentLengthAroundVertexHyp)
 513 };
 514 DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis);
 515
 516 // -------------------------------------------------------------------------------------
 517 /*!
 518  * \brief SelfEraser erases creation command if no more it's commands invoked
 519  */
 520 // -------------------------------------------------------------------------------------
 521 class _pySelfEraser: public _pyObject
 522 {
 523 public:
 524   _pySelfEraser(const Handle(_pyCommand)& theCreationCmd):_pyObject(theCreationCmd) {}
 525   virtual void Flush();
 526
 527   DEFINE_STANDARD_RTTI (_pySelfEraser)
 528 };
 529 DEFINE_STANDARD_HANDLE (_pySelfEraser, _pyObject);
 530
 531 // -------------------------------------------------------------------------------------
 532 /*!
 533  * \brief SubMesh creation can be moved to the end of engine commands
 534  */
 535 // -------------------------------------------------------------------------------------
 536 class _pySubMesh:  public _pyObject
 537 {
 538   Handle(_pyObject) myCreator;
 539   Handle(_pyMesh) myMesh;
 540 public:
 541   _pySubMesh(const Handle(_pyCommand)& theCreationCmd);
 542   virtual void Process( const Handle(_pyCommand)& theCommand);
 543   virtual void Flush();
 544   virtual Handle(_pyMesh) GetMesh() { return myMesh; }
 545   virtual void Free() { myCreator.Nullify(); myMesh.Nullify(); }
 546   void SetCreator( const Handle(_pyObject)& theCreator ) { myCreator = theCreator; }
 547
 548   DEFINE_STANDARD_RTTI (_pySubMesh)
 549 };
 550 // -------------------------------------------------------------------------------------
 551 /*!
 552  * \brief To convert creation of a group by filter
 553  */
 554 // -------------------------------------------------------------------------------------
 555 class _pyGroup:  public _pySubMesh
 556 {
 557 public:
 558   _pyGroup(const Handle(_pyCommand)& theCreationCmd, const _pyID & id=_pyID())
 559     :_pySubMesh(theCreationCmd) { setID( id ); }
 560   virtual void Process( const Handle(_pyCommand)& theCommand);
 561   virtual void Flush() {}
 562
 563   DEFINE_STANDARD_RTTI (_pyGroup)
 564 };
 565
 566 // -------------------------------------------------------------------------------------
 567 /*!
 568  * \brief A filter sets a human readable name to self
 569  */
 570 // -------------------------------------------------------------------------------------
 571 class _pyFilter:  public _pyObject
 572 {
 573   _pyID myNewID;
 574   std::list< Handle(_pyObject) > myUsers;
 575 public:
 576   _pyFilter(const Handle(_pyCommand)& theCreationCmd, const _pyID& newID="");
 577   void AddUser( const Handle(_pyObject)& user) { myUsers.push_back( user ); }
 578   virtual void Process( const Handle(_pyCommand)& theCommand);
 579   virtual void Flush();
 580   virtual bool CanClear();
 581   virtual void Free() { myUsers.clear(); }
 582   const _pyID& GetNewID() const { return myNewID; }
 583
 584   DEFINE_STANDARD_RTTI (_pyFilter)
 585 };
 586 DEFINE_STANDARD_HANDLE (_pyFilter, _pyObject);
 587
 588 // -------------------------------------------------------------------------------------
 589 /*!
 590  * \brief Class reading _pyHypothesis'es from resource files of mesher Plugins
 591  */
 592 // -------------------------------------------------------------------------------------
 593 class _pyHypothesisReader: public Standard_Transient
 594 {
 595   std::map<_AString, Handle(_pyHypothesis)> myType2Hyp;
 596 public:
 597   _pyHypothesisReader();
 598   Handle(_pyHypothesis) GetHypothesis(const _AString&           hypType,
 599                                       const Handle(_pyCommand)& creationCmd) const;
 600   DEFINE_STANDARD_RTTI (_pyHypothesisReader)
 601 };
 602
 603 #endif