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 should 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