X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH_I%2FSMESH_2smeshpy.hxx;h=7d49bc614e33a1bdbf11b98d518a6cfcdce55c25;hb=f718a0e5e479d524621a39cf1372a4af6ec9813f;hp=78117eaa347062daa770bfa9616ba7f65cef9f95;hpb=4ff5bd61540272713e48de1eee75625028c32155;p=modules%2Fsmesh.git diff --git a/src/SMESH_I/SMESH_2smeshpy.hxx b/src/SMESH_I/SMESH_2smeshpy.hxx index 78117eaa3..7d49bc614 100644 --- a/src/SMESH_I/SMESH_2smeshpy.hxx +++ b/src/SMESH_I/SMESH_2smeshpy.hxx @@ -1,3 +1,22 @@ +// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// // File : SMESH_smesh.hxx // Created : Fri Nov 18 12:05:18 2005 // Author : Edward AGAPOV (eap) @@ -15,6 +34,7 @@ #include #include +// =========================================================================================== /*! * \brief Tool converting SMESH engine calls into commands defined in smesh.py * @@ -30,6 +50,7 @@ * * See comments to _pyHypothesis class to know how to assure convertion of a new hypothesis */ +// =========================================================================================== class Resource_DataMapOfAsciiStringAsciiString; @@ -55,9 +76,11 @@ public: static char* GenName() { return "smesh.smesh"; } }; +// =========================================================================================== // ===================== // INTERNAL STUFF // ===================== +// =========================================================================================== class _pyCommand; class _pyObject; @@ -73,24 +96,31 @@ DEFINE_STANDARD_HANDLE (_pyMesh ,_pyObject); DEFINE_STANDARD_HANDLE (_pyHypothesis,_pyObject); DEFINE_STANDARD_HANDLE (_pyAlgorithm ,_pyHypothesis); +typedef TCollection_AsciiString _pyID; + +// =========================================================== /*! * \brief Class operating on a command string looking like * ResultValue = Object.Method( Arg1, Arg2,...) */ +// =========================================================== + class _pyCommand: public Standard_Transient { - int myOrderNb; // position within the script - TCollection_AsciiString myString; - TCollection_AsciiString myRes, myObj, myMeth; - TColStd_SequenceOfAsciiString myArgs; - TColStd_SequenceOfInteger myBegPos; //!< where myRes, myObj, ... begin - std::list< Handle(_pyCommand) > myDependentCmds; + int myOrderNb; //!< position within the script + TCollection_AsciiString myString; //!< command text + TCollection_AsciiString myRes, myObj, myMeth; //!< found parts of command + TColStd_SequenceOfAsciiString myArgs; //!< found arguments + TColStd_SequenceOfInteger myBegPos; //!< where myRes, myObj, ... begin + std::list< Handle(_pyCommand) > myDependentCmds; //!< commands that sould follow me in the script + enum { UNKNOWN=-1, EMPTY=0, RESULT_IND, OBJECT_IND, METHOD_IND, ARG1_IND }; int GetBegPos( int thePartIndex ); void SetBegPos( int thePartIndex, int thePosition ); void SetPart( int thePartIndex, const TCollection_AsciiString& theNewPart, TCollection_AsciiString& theOldPart); void FindAllArgs() { GetArg(1); } + public: _pyCommand() {}; _pyCommand( const TCollection_AsciiString& theString, int theNb ) @@ -101,6 +131,7 @@ public: int Length() { return myString.Length(); } void Clear() { myString.Clear(); myBegPos.Clear(); } bool IsEmpty() const { return myString.IsEmpty(); } + TCollection_AsciiString GetIndentation(); const TCollection_AsciiString & GetResultValue(); const TCollection_AsciiString & GetObject(); const TCollection_AsciiString & GetMethod(); @@ -119,17 +150,20 @@ public: static TCollection_AsciiString GetWord( const TCollection_AsciiString & theSring, int & theStartPos, const bool theForward, const bool dotIsWord = false); - void AddDependantCmd( Handle(_pyCommand) cmd) - { return myDependentCmds.push_back( cmd ); } + void AddDependantCmd( Handle(_pyCommand) cmd, bool prepend = false) + { if (prepend) myDependentCmds.push_front( cmd ); else myDependentCmds.push_back( cmd ); } bool SetDependentCmdsAfter() const; + bool AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod ); + DEFINE_STANDARD_RTTI (_pyCommand) }; +// ------------------------------------------------------------------------------------- /*! * \brief Root of all objects */ -typedef TCollection_AsciiString _pyID; +// ------------------------------------------------------------------------------------- class _pyObject: public Standard_Transient { @@ -142,20 +176,23 @@ public: int GetCommandNb() { return myCreationCmd->GetOrderNb(); } virtual void Process(const Handle(_pyCommand) & theCommand) = 0; virtual void Flush() = 0; + virtual const char* AccessorMethod() const; DEFINE_STANDARD_RTTI (_pyObject) }; +// ------------------------------------------------------------------------------------- /*! * \brief Class corresponding to SMESH_Gen. It holds info on existing * meshes and hypotheses */ +// ------------------------------------------------------------------------------------- class _pyGen: public _pyObject { public: _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod); //~_pyGen(); - void AddCommand( const TCollection_AsciiString& theCommand ); + Handle(_pyCommand) AddCommand( const TCollection_AsciiString& theCommand ); void Process( const Handle(_pyCommand)& theCommand ); void Flush(); Handle(_pyHypothesis) FindHyp( const _pyID& theHypID ); @@ -165,35 +202,47 @@ public: void SetCommandAfter( Handle(_pyCommand) theCmd, Handle(_pyCommand) theAfterCmd ); std::list< Handle(_pyCommand) >& GetCommands() { return myCommands; } void SetAccessorMethod(const _pyID& theID, const char* theMethod ); + bool AddMeshAccessorMethod( Handle(_pyCommand) theCmd ) const; + bool AddAlgoAccessorMethod( Handle(_pyCommand) theCmd ) const; + const char* AccessorMethod() const { return SMESH_2smeshpy::GenName(); } private: std::map< _pyID, Handle(_pyMesh) > myMeshes; std::list< Handle(_pyHypothesis) > myHypos; std::list< Handle(_pyCommand) > myCommands; int myNbCommands; + bool myHasPattern; Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod; DEFINE_STANDARD_RTTI (_pyGen) }; +// ------------------------------------------------------------------------------------- /*! * \brief Contains commands concerning mesh substructures */ +// ------------------------------------------------------------------------------------- +#define _pyMesh_ACCESS_METHOD "GetMesh()" class _pyMesh: public _pyObject { + std::list< Handle(_pyHypothesis) > myHypos; std::list< Handle(_pyCommand) > myAddHypCmds; - std::list< Handle(_pyCommand) > mySubmeshes; + std::list< Handle(_pyCommand) > mySubmeshes; + bool myHasEditor; public: _pyMesh(const Handle(_pyCommand) theCreationCmd); const _pyID& GetGeom() { return GetCreationCmd()->GetArg(1); } void Process( const Handle(_pyCommand)& theCommand); void Flush(); + const char* AccessorMethod() const { return _pyMesh_ACCESS_METHOD; } private: static void AddMeshAccess( const Handle(_pyCommand)& theCommand ) - { theCommand->SetObject( theCommand->GetObject() + ".GetMesh()" ); } + { theCommand->SetObject( theCommand->GetObject() + "." _pyMesh_ACCESS_METHOD ); } DEFINE_STANDARD_RTTI (_pyMesh) }; +#undef _pyMesh_ACCESS_METHOD +// ------------------------------------------------------------------------------------- /*! * \brief Root class for hypothesis * @@ -210,23 +259,35 @@ private: * to derive a specific class from _pyHypothesis that would redefine Process(), * see _pyComplexParamHypo for example */ +// ------------------------------------------------------------------------------------- class _pyHypothesis: public _pyObject { protected: - bool myIsAlgo, /*myIsLocal, */myIsWrapped, myIsConverted; - int myDim, myAdditionCmdNb; + bool myIsAlgo, myIsWrapped; //myIsLocal, myIsConverted; + //int myDim/*, myAdditionCmdNb*/; _pyID myGeom, myMesh; TCollection_AsciiString myCreationMethod, myType; TColStd_SequenceOfAsciiString myArgs; TColStd_SequenceOfAsciiString myArgMethods; + TColStd_SequenceOfInteger myNbArgsByMethod; std::list myArgCommands; std::list myUnknownCommands; public: _pyHypothesis(const Handle(_pyCommand)& theCreationCmd); + void SetConvMethodAndType(const char* creationMethod, const char* type=0) + { myCreationMethod = (char*)creationMethod; if ( type ) myType = (char*)type; } +// void SetDimMethodType(const int dim, const char* creationMethod, const char* type=0) +// { myDim = dim; myCreationMethod = (char*)creationMethod; if ( type ) myType = (char*)type; } + void AddArgMethod(const char* method, const int nbArgs = 1) + { myArgMethods.Append( (char*)method ); myNbArgsByMethod.Append( nbArgs ); } + const TColStd_SequenceOfAsciiString& GetArgs() const { return myArgs; } + const TCollection_AsciiString& GetCreationMethod() const { return myCreationMethod; } + const std::list& GetArgCommands() const { return myArgCommands; } + void ClearAllCommands(); virtual bool IsAlgo() const { return myIsAlgo; } bool IsWrapped() const { return myIsWrapped; } - bool & IsConverted() { return myIsConverted; } - int GetDim() const { return myDim; } + //bool & IsConverted() { return myIsConverted; } + //int GetDim() const { return myDim; } const _pyID & GetGeom() const { return myGeom; } void SetMesh( const _pyID& theMeshId) { if ( myMesh.IsEmpty() ) myMesh = theMeshId; } const _pyID & GetMesh() const { return myMesh; } @@ -243,9 +304,27 @@ public: DEFINE_STANDARD_RTTI (_pyHypothesis) }; +// ------------------------------------------------------------------------------------- +/*! + * \brief Class representing smesh.Mesh_Algorithm + */ +// ------------------------------------------------------------------------------------- +class _pyAlgorithm: public _pyHypothesis +{ +public: + _pyAlgorithm(const Handle(_pyCommand)& theCreationCmd); + virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd, + const _pyID& theMesh); + const char* AccessorMethod() const { return "GetAlgorithm()"; } + + DEFINE_STANDARD_RTTI (_pyAlgorithm) +}; + +// ------------------------------------------------------------------------------------- /*! * \brief Class for hypotheses having several parameters modified by one method */ +// ------------------------------------------------------------------------------------- class _pyComplexParamHypo: public _pyHypothesis { public: @@ -256,32 +335,56 @@ public: }; DEFINE_STANDARD_HANDLE (_pyComplexParamHypo, _pyHypothesis); +// ------------------------------------------------------------------------------------- +/*! + * \brief Class for LayerDistribution hypothesis conversion + */ +// ------------------------------------------------------------------------------------- +class _pyLayerDistributionHypo: public _pyHypothesis +{ + Handle(_pyHypothesis) my1dHyp; +public: + _pyLayerDistributionHypo(const Handle(_pyCommand)& theCreationCmd): + _pyHypothesis(theCreationCmd) {} + void Process( const Handle(_pyCommand)& theCommand); + void Flush(); + bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd, + const _pyID& theMesh); + + DEFINE_STANDARD_RTTI (_pyLayerDistributionHypo) +}; +DEFINE_STANDARD_HANDLE (_pyLayerDistributionHypo, _pyHypothesis); +// ------------------------------------------------------------------------------------- /*! * \brief Class representing NumberOfSegments hypothesis */ +// ------------------------------------------------------------------------------------- class _pyNumberOfSegmentsHyp: public _pyHypothesis { public: _pyNumberOfSegmentsHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {} virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd, const _pyID& theMesh); + void Flush(); DEFINE_STANDARD_RTTI (_pyNumberOfSegmentsHyp) }; DEFINE_STANDARD_HANDLE (_pyNumberOfSegmentsHyp, _pyHypothesis); +// ------------------------------------------------------------------------------------- /*! - * \brief Class representing smesh.Mesh_Algorithm + * \brief Class representing SegmentLengthAroundVertex hypothesis */ -class _pyAlgorithm: public _pyHypothesis +// ------------------------------------------------------------------------------------- +class _pySegmentLengthAroundVertexHyp: public _pyHypothesis { public: - _pyAlgorithm(const Handle(_pyCommand)& theCreationCmd); + _pySegmentLengthAroundVertexHyp(const Handle(_pyCommand)& theCrCmd): _pyHypothesis(theCrCmd) {} virtual bool Addition2Creation( const Handle(_pyCommand)& theAdditionCmd, const _pyID& theMesh); - - DEFINE_STANDARD_RTTI (_pyAlgorithm) + DEFINE_STANDARD_RTTI (_pySegmentLengthAroundVertexHyp) }; +DEFINE_STANDARD_HANDLE (_pySegmentLengthAroundVertexHyp, _pyHypothesis); #endif