// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // // Copyright (C) 2003-2007 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_DumpPython.cxx // Created : Thu Mar 24 17:17:59 2005 // Author : Julia DOROVSKIKH // Module : SMESH #include "SMESH_PythonDump.hxx" #include "SMESH_2smeshpy.hxx" #include "SMESH_Comment.hxx" #include "SMESH_Filter_i.hxx" #include "SMESH_Gen_i.hxx" #include "SMESH_MeshEditor_i.hxx" #include #include #include #include #include #ifdef _DEBUG_ static int MYDEBUG = 0; #else static int MYDEBUG = 0; #endif #include "SMESH_TryCatch.hxx" namespace SMESH { size_t TPythonDump::myCounter = 0; const char theNotPublishedObjectName[] = "__NOT__Published__Object__"; TVar::TVar(CORBA::Double value):myVals(1) { myVals[0] = SMESH_Comment(value); } TVar::TVar(CORBA::Long value):myVals(1) { myVals[0] = SMESH_Comment(value); } TVar::TVar(CORBA::Short value):myVals(1) { myVals[0] = SMESH_Comment(value); } TVar::TVar(const SMESH::double_array& value):myVals(value.length()) { for ( size_t i = 0; i < value.length(); i++) myVals[i] = SMESH_Comment(value[i]); } TPythonDump:: TPythonDump():myVarsCounter(0) { ++myCounter; } TPythonDump:: ~TPythonDump() { if(--myCounter == 0){ SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); std::string aString = myStream.str(); TCollection_AsciiString aCollection(Standard_CString(aString.c_str())); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy(); if(!aStudy->_is_nil() && !aCollection.IsEmpty()) { const std::string & objEntry = SMESH_Gen_i::GetSMESHGen()->GetLastObjEntry(); if ( !objEntry.empty() ) aCollection += (TVar::ObjPrefix() + objEntry ).c_str(); aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection); if(MYDEBUG) MESSAGE(aString); // prevent misuse of already treated variables aSMESHGen->UpdateParameters(CORBA::Object_var().in(),""); } } } TPythonDump& //!< store a variable value. Write either a value or '$varID$' TPythonDump:: operator<<(const TVar& theVarValue) { const std::vector< int >& varIDs = SMESH_Gen_i::GetSMESHGen()->GetLastParamIndices(); if ( theVarValue.myVals.size() != 1 ) { myStream << "[ "; for ( size_t i = 1; i <= theVarValue.myVals.size(); ++i ) { if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 ) myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote(); else myStream << theVarValue.myVals[i-1]; if ( i < theVarValue.myVals.size() ) myStream << ", "; ++myVarsCounter; } myStream << " ]"; } else { if ( myVarsCounter < varIDs.size() && varIDs[ myVarsCounter ] >= 0 ) myStream << TVar::Quote() << varIDs[ myVarsCounter ] << TVar::Quote(); else myStream << theVarValue.myVals[0]; ++myVarsCounter; } return *this; } TPythonDump& TPythonDump:: operator<<(long int theArg){ myStream< void DumpArray(const TArray& theArray, TPythonDump & theStream) { if ( theArray.length() == 0 ) { theStream << "[]"; } else { theStream << "[ "; for (int i = 1; i <= theArray.length(); i++) { theStream << theArray[i-1]; if ( i < theArray.length() ) theStream << ", "; } theStream << " ]"; } } TPythonDump& TPythonDump::operator<<(const SMESH::long_array& theArg) { DumpArray( theArg, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::double_array& theArg) { DumpArray( theArg, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::nodes_array& theArg) { DumpArray( theArg, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::string_array& theArray) { myStream << "[ "; for (int i = 1; i <= theArray.length(); i++) { myStream << "'" << theArray[i-1] << "'"; if ( i < theArray.length() ) myStream << ", "; } myStream << " ]"; return *this; } TPythonDump& TPythonDump:: operator<<(SALOMEDS::SObject_ptr aSObject) { if ( !aSObject->_is_nil() ) { CORBA::String_var entry = aSObject->GetID(); myStream << entry.in(); } else { myStream << theNotPublishedObjectName; } return *this; } TPythonDump& TPythonDump:: operator<<(CORBA::Object_ptr theArg) { SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::SObject_wrap aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); if(!aSObject->_is_nil()) { CORBA::String_var id = aSObject->GetID(); myStream << id; } else if ( !CORBA::is_nil(theArg)) { if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object myStream << "smeshObj_" << size_t(theArg); else myStream << theNotPublishedObjectName; } else myStream << "None"; return *this; } TPythonDump& TPythonDump:: operator<<(SMESH::SMESH_Hypothesis_ptr theArg) { SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy(); SALOMEDS::SObject_wrap aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); if(aSObject->_is_nil() && !CORBA::is_nil(theArg)) myStream << "hyp_" << theArg->GetId(); else *this << aSObject; return *this; } TPythonDump& TPythonDump:: operator<<(SMESH::SMESH_IDSource_ptr theArg) { if ( CORBA::is_nil( theArg ) ) return *this << "None"; SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::SObject_wrap aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); if(!aSObject->_is_nil()) { return *this << aSObject; } if ( SMESH::Filter_i* filter = SMESH::DownCast( theArg )) { return *this << filter; } if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theArg )) { SMESH::SMESH_Mesh_var mesh = theArg->GetMesh(); SMESH::long_array_var anElementsId = theArg->GetIDs(); SMESH::array_of_ElementType_var types = theArg->GetTypes(); SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL; SALOMEDS::SObject_wrap meshSO = SMESH_Gen_i::ObjectToSObject(aStudy,mesh); if ( meshSO->_is_nil() ) // don't waste memory for dumping not published objects return *this << mesh << ".GetIDSource([], " << type << ")"; else return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")"; } return *this << theNotPublishedObjectName; } TPythonDump& TPythonDump:: operator<<(SMESH::FilterLibrary_i* theArg) { myStream<<"aFilterLibrary"<GetFunctorType(); switch(aFunctorType) { case FT_AspectRatio: myStream<< "aAspectRatio"; break; case FT_AspectRatio3D: myStream<< "aAspectRatio3D"; break; case FT_Warping: myStream<< "aWarping"; break; case FT_MinimumAngle: myStream<< "aMinimumAngle"; break; case FT_Taper: myStream<< "aTaper"; break; case FT_Skew: myStream<< "aSkew"; break; case FT_Area: myStream<< "aArea"; break; case FT_Volume3D: myStream<< "aVolume3D"; break; case FT_MaxElementLength2D: myStream<< "aMaxElementLength2D"; break; case FT_MaxElementLength3D: myStream<< "aMaxElementLength3D"; break; case FT_FreeBorders: myStream<< "aFreeBorders"; break; case FT_FreeEdges: myStream<< "aFreeEdges"; break; case FT_FreeNodes: myStream<< "aFreeNodes"; break; case FT_FreeFaces: myStream<< "aFreeFaces"; break; case FT_EqualNodes: myStream<< "aEqualNodes"; break; case FT_EqualEdges: myStream<< "aEqualEdges"; break; case FT_EqualFaces: myStream<< "aEqualFaces"; break; case FT_EqualVolumes: myStream<< "aEqualVolumes"; break; case FT_MultiConnection: myStream<< "aMultiConnection"; break; case FT_MultiConnection2D: myStream<< "aMultiConnection2D"; break; case FT_Length: myStream<< "aLength"; break; case FT_Length2D: myStream<< "aLength2D"; break; case FT_BelongToGeom: myStream<< "aBelongToGeom"; break; case FT_BelongToPlane: myStream<< "aBelongToPlane"; break; case FT_BelongToCylinder: myStream<< "aBelongToCylinder"; break; case FT_BelongToGenSurface: myStream<< "aBelongToGenSurface"; break; case FT_LyingOnGeom: myStream<< "aLyingOnGeom"; break; case FT_RangeOfIds: myStream<< "aRangeOfIds"; break; case FT_BadOrientedVolume: myStream<< "aBadOrientedVolume"; break; case FT_BareBorderVolume: myStream<< "aBareBorderVolume"; break; case FT_BareBorderFace: myStream<< "aBareBorderFace"; break; case FT_OverConstrainedVolume: myStream<< "aOverConstrainedVolume"; break; case FT_OverConstrainedFace: myStream<< "aOverConstrainedFace"; break; case FT_LinearOrQuadratic: myStream<< "aLinearOrQuadratic"; break; case FT_GroupColor: myStream<< "aGroupColor"; break; case FT_ElemGeomType: myStream<< "aElemGeomType"; break; case FT_EntityType: myStream<< "aEntityType"; break; case FT_CoplanarFaces: myStream<< "aCoplanarFaces"; break; case FT_BallDiameter: myStream<< "aBallDiameter"; break; case FT_ConnectedElements: myStream<< "aConnectedElements"; break; case FT_LessThan: myStream<< "aLessThan"; break; case FT_MoreThan: myStream<< "aMoreThan"; break; case FT_EqualTo: myStream<< "aEqualTo"; break; case FT_LogicalNOT: myStream<< "aLogicalNOT"; break; case FT_LogicalAND: myStream<< "aLogicalAND"; break; case FT_LogicalOR: myStream<< "aLogicalOR"; break; case FT_Undefined: default: myStream<< "anUndefined"; break; } myStream<GetMeshId() : -1 ); return *this; } TPythonDump& TPythonDump::operator<<(const TCollection_AsciiString & theStr) { myStream << theStr; return *this; } TPythonDump& TPythonDump::operator<<(SMESH::MED_VERSION theVersion) { switch (theVersion) { case SMESH::MED_V2_1: myStream << "SMESH.MED_V2_1"; break; case SMESH::MED_V2_2: myStream << "SMESH.MED_V2_2"; break; default: myStream << theVersion; } return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::AxisStruct & theAxis) { *this << "SMESH.AxisStruct( " << TVar( theAxis.x ) << ", " << TVar( theAxis.y ) << ", " << TVar( theAxis.z ) << ", " << TVar( theAxis.vx ) << ", " << TVar( theAxis.vy ) << ", " << TVar( theAxis.vz ) << " )"; return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::DirStruct & theDir) { const SMESH::PointStruct & P = theDir.PS; *this << "SMESH.DirStruct( SMESH.PointStruct ( " << TVar( P.x ) << ", " << TVar( P.y ) << ", " << TVar( P.z ) << " ))"; return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::PointStruct & P) { *this << "SMESH.PointStruct ( " << TVar( P.x ) << ", " << TVar( P.y ) << ", " << TVar( P.z ) << " )"; return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::ListOfGroups& theList) { DumpArray( theList, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::ListOfGroups * theList) { DumpArray( *theList, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const GEOM::ListOfGO& theList) { DumpArray( theList, *this ); return *this; } TPythonDump& TPythonDump::operator<<(const SMESH::ListOfIDSources& theList) { DumpArray( theList, *this ); return *this; } const char* TPythonDump::NotPublishedObjectName() { return theNotPublishedObjectName; } TCollection_AsciiString myLongStringStart( "TPythonDump::LongStringStart" ); TCollection_AsciiString myLongStringEnd ( "TPythonDump::LongStringEnd" ); //================================================================================ /*! * \brief Return marker of long string literal beginning * \param type - a name of functionality producing the string literal * \retval TCollection_AsciiString - the marker string to be written into * a raw python script */ //================================================================================ TCollection_AsciiString TPythonDump::LongStringStart(const char* type) { return myLongStringStart + (Standard_Integer) strlen(type) + " " + (char*) type; } //================================================================================ /*! * \brief Return marker of long string literal end * \retval TCollection_AsciiString - the marker string to be written into * a raw python script */ //================================================================================ TCollection_AsciiString TPythonDump::LongStringEnd() { return myLongStringEnd; } //================================================================================ /*! * \brief Cut out a long string literal from a string * \param theText - text possibly containing string literals * \param theFrom - position in the text to search from * \param theLongString - the retrieved literal * \param theStringType - a name of functionality produced the literal * \retval bool - true if a string literal found * * The literal is removed from theText; theFrom points position right after * the removed literal */ //================================================================================ bool TPythonDump::CutoutLongString( TCollection_AsciiString & theText, int & theFrom, TCollection_AsciiString & theLongString, TCollection_AsciiString & theStringType) { if ( theFrom < 1 || theFrom > theText.Length() ) return false; // ...script \ beg marker \ \ type \ literal \ end marker \ script... // "theText myLongStringStart7 Pattern!!! SALOME Mesh Pattern file myLongStringEndtextEnd" // 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 // 0 1 2 3 4 5 6 7 8 theFrom = theText.Location( myLongStringStart, theFrom, theText.Length() ); // = 09 if ( !theFrom ) return false; // find where literal begins int literalBeg = theFrom + myLongStringStart.Length(); // = 26 char* typeLenStr = (char*) theText.ToCString() + literalBeg - 1; // = "7 Pattern!!! SALO...." int typeLen = atoi ( typeLenStr ); // = 7 while ( *typeLenStr != ' ' ) { // look for ' ' after typeLen literalBeg++; // 26 -> 27 typeLenStr++; } literalBeg += typeLen + 1; // = 35 if ( literalBeg > theText.Length() ) return false; // where literal ends (i.e. end marker begins) int literalEnd = theText.Location( myLongStringEnd, literalBeg, theText.Length() ); // = 64 if ( !literalEnd ) literalEnd = theText.Length(); // literal theLongString = theText.SubString( literalBeg, literalEnd - 1); // "!!! SALOME Mesh Pattern file " // type theStringType = theText.SubString( literalBeg - typeLen, literalBeg - 1 ); // "Pattern" // cut off literal literalEnd += myLongStringEnd.Length(); // = 79 TCollection_AsciiString textEnd = theText.SubString( literalEnd, theText.Length() ); // "textE..." theText = theText.SubString( 1, theFrom - 1 ) + textEnd; return true; } void printException( const char* text ) { #ifdef _DEBUG_ cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << endl; #endif } } //======================================================================= //function : RemoveTabulation //purpose : //======================================================================= void RemoveTabulation( TCollection_AsciiString& theScript ) { std::string aString( theScript.ToCString() ); std::string::size_type aPos = 0; while( aPos < aString.length() ) { aPos = aString.find( "\n\t", aPos ); if( aPos == std::string::npos ) break; aString.replace( aPos, 2, "\n" ); aPos++; } theScript = aString.c_str(); } //======================================================================= //function : DumpPython //purpose : //======================================================================= Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy, CORBA::Boolean isPublished, CORBA::Boolean isMultiFile, CORBA::Boolean& isValidScript) { SALOMEDS::Study_var aStudy = SALOMEDS::Study::_narrow(theStudy); if (CORBA::is_nil(aStudy)) return new Engines::TMPFile(0); CORBA::String_var compDataType = ComponentDataType(); SALOMEDS::SObject_wrap aSO = aStudy->FindComponent( compDataType.in() ); if (CORBA::is_nil(aSO)) return new Engines::TMPFile(0); // Map study entries to object names Resource_DataMapOfAsciiStringAsciiString aMap; Resource_DataMapOfAsciiStringAsciiString aMapNames; SALOMEDS::ChildIterator_wrap Itr = aStudy->NewChildIterator(aSO); for (Itr->InitEx(true); Itr->More(); Itr->Next()) { SALOMEDS::SObject_wrap aValue = Itr->Value(); CORBA::String_var anID = aValue->GetID(); CORBA::String_var aName = aValue->GetName(); TCollection_AsciiString aGUIName ( (char*) aName.in() ); TCollection_AsciiString anEntry ( (char*) anID.in() ); if (aGUIName.Length() > 0) { aMapNames.Bind( anEntry, aGUIName ); aMap.Bind( anEntry, aGUIName ); } } // Get trace of restored study SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder(); SALOMEDS::GenericAttribute_wrap anAttr = aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject"); SALOMEDS::AttributePythonObject_var pyAttr = SALOMEDS::AttributePythonObject::_narrow(anAttr); CORBA::String_var oldValue = pyAttr->GetObject(); TCollection_AsciiString aSavedTrace (oldValue.in()); // Add trace of API methods calls and replace study entries by names TCollection_AsciiString aScript; aScript += DumpPython_impl(aStudy, aMap, aMapNames, isPublished, isMultiFile, myIsHistoricalPythonDump, isValidScript, aSavedTrace); int aLen = aScript.Length(); unsigned char* aBuffer = new unsigned char[aLen+1]; strcpy((char*)aBuffer, aScript.ToCString()); CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer; Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1); bool hasNotPublishedObjects = aScript.Location( SMESH::theNotPublishedObjectName, 1, aLen); isValidScript = isValidScript && !hasNotPublishedObjects; return aStreamFile._retn(); } //============================================================================= /*! * AddToPythonScript */ //============================================================================= void SMESH_Gen_i::AddToPythonScript (int theStudyID, const TCollection_AsciiString& theString) { if (myPythonScripts.find(theStudyID) == myPythonScripts.end()) { myPythonScripts[theStudyID] = new TColStd_HSequenceOfAsciiString; } myPythonScripts[theStudyID]->Append(theString); } //============================================================================= /*! * RemoveLastFromPythonScript */ //============================================================================= void SMESH_Gen_i::RemoveLastFromPythonScript (int theStudyID) { if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) { int aLen = myPythonScripts[theStudyID]->Length(); myPythonScripts[theStudyID]->Remove(aLen); } } //======================================================================= //function : SavePython //purpose : //======================================================================= void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy) { // Dump trace of API methods calls TCollection_AsciiString aScript = GetNewPythonLines(theStudy->StudyId()); // Check contents of PythonObject attribute CORBA::String_var compDataType = ComponentDataType(); SALOMEDS::SObject_wrap aSO = theStudy->FindComponent( compDataType.in() ); SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder(); SALOMEDS::GenericAttribute_wrap anAttr = aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject"); SALOMEDS::AttributePythonObject_var pyAttr = SALOMEDS::AttributePythonObject::_narrow(anAttr); CORBA::String_var oldValue = pyAttr->GetObject(); TCollection_AsciiString oldScript (oldValue.in()); if (oldScript.Length() > 0) { oldScript += "\n"; oldScript += aScript; } else { oldScript = aScript; } // Store in PythonObject attribute pyAttr->SetObject(oldScript.ToCString(), 1); // Clean trace of API methods calls CleanPythonTrace(theStudy->StudyId()); } // impl //============================================================================= /*! * FindEntries: Returns a sequence of start/end positions of entries in the string */ //============================================================================= Handle(TColStd_HSequenceOfInteger) FindEntries (TCollection_AsciiString& theString) { Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger; Standard_Integer aLen = theString.Length(); Standard_Boolean isFound = Standard_False; char* arr = (char*) theString.ToCString(); Standard_Integer i = 0, j; while(i < aLen) { int c = (int)arr[i]; j = i+1; if ( isdigit( c )) { //Is digit? isFound = Standard_False; while((j < aLen) && ( isdigit(c) || c == ':' )) { //Check if it is an entry c = (int)arr[j++]; if(c == ':') isFound = Standard_True; } if (isFound) { int prev = (i < 1) ? 0 : (int)arr[i - 1]; // to distinguish from a sketcher command: // last char should be a digit, not ":", // previous char should not be '"'. if (arr[j-2] != ':' && prev != '"') { aSeq->Append(i+1); // +1 because AsciiString starts from 1 aSeq->Append(j-1); } } } i = j; } return aSeq; } namespace { //================================================================================ /*! * \brief Make a string be a valid python name * \param aName - a string to fix * \retval bool - true if aName was not modified */ //================================================================================ bool fixPythonName(TCollection_AsciiString & aName) { bool isValidName = true; int nbUnderscore = 0; int p; // replace not allowed chars by underscore const char* name = aName.ToCString(); for ( p = 0; name[p]; ++p ) { if ( !isalnum( name[p] ) && name[p] != '_' ) { if ( p == 0 || p+1 == aName.Length() || name[p-1] == '_') { aName.Remove( p+1, 1 ); // remove __ and _ from the start and the end --p; name = aName.ToCString(); } else { aName.SetValue( p+1, '_'); nbUnderscore++; } isValidName = false; } } // aName must not start with a digit if ( aName.IsIntegerValue() ) { aName.Insert( 1, 'a' ); isValidName = false; } // shorten names like CartesianParameters3D_400_400_400_1000000_1 const int nbAllowedUnderscore = 3; /* changed from 2 to 3 by an user request posted to SALOME Forum */ if ( aName.Length() > 20 && nbUnderscore > nbAllowedUnderscore ) { p = aName.Location( "_", 20, aName.Length()); if ( p > 1 ) aName.Trunc( p-1 ); } return isValidName; } //================================================================================ /*! * \brief Return Python module names of available plug-ins. */ //================================================================================ std::vector getPluginNames() { std::vector pluginNames; std::vector< std::string > xmlPaths = SMESH_Gen::GetPluginXMLPaths(); LDOMParser xmlParser; for ( size_t i = 0; i < xmlPaths.size(); ++i ) { bool error = xmlParser.parse( xmlPaths[i].c_str() ); if ( error ) { TCollection_AsciiString data; INFOS( xmlParser.GetError(data) ); continue; } // LDOM_Document xmlDoc = xmlParser.getDocument(); LDOM_NodeList nodeList = xmlDoc.getElementsByTagName( "meshers-group" ); for ( int i = 0; i < nodeList.getLength(); ++i ) { LDOM_Node node = nodeList.item( i ); LDOM_Element& elem = (LDOM_Element&) node; LDOMString idlModule = elem.getAttribute( "idl-module" ); if ( strlen( idlModule.GetString() ) > 0 ) pluginNames.push_back( idlModule.GetString() ); } } return pluginNames; } } //================================================================================ /*! * \brief Createa a Dump Python script * \param [in] theStudy - the study to dump * \param [in,out] theObjectNames - map of an entry to a study and python name * \param [in] theNames - - map of an entry to a study name * \param [in] isPublished - \c true if dump of object publication in study is needed * \param [in] isMultiFile - \c true if dump of each module goes to a separate file * \param [in] isHistoricalDump - \c true if removed object should be dumped * \param [out] aValidScript - returns \c true if the returned script seems valid * \param [in,out] theSavedTrace - the dump stored in the study. It's cleared to * decrease memory usage. * \return TCollection_AsciiString - the result dump script. */ //================================================================================ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl (SALOMEDS::Study_ptr theStudy, Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theNames, bool isPublished, bool isMultiFile, bool isHistoricalDump, bool& aValidScript, TCollection_AsciiString& theSavedTrace) { SMESH_TRY; const int aStudyID = theStudy->StudyId(); const TCollection_AsciiString aSmeshpy ( SMESH_2smeshpy::SmeshpyName() ); const TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() ); const TCollection_AsciiString anOldGen ( SMESH::TPythonDump::SMESHGenName() ); const TCollection_AsciiString helper; // to comfortably append C strings to TCollection_AsciiString const TCollection_AsciiString tab( isMultiFile ? "\t" : "" ), nt = helper + "\n" + tab; std::list< TCollection_AsciiString > lines; // lines of a script std::list< TCollection_AsciiString >::iterator linesIt; if ( isPublished ) lines.push_back( aSMESHGen + " = smeshBuilder.New(theStudy)" ); else lines.push_back( aSMESHGen + " = smeshBuilder.New(None)" ); lines.push_back( helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()" ); lines.push_back( helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()" ); // Treat dump trace of restored study if (theSavedTrace.Length() > 0) { linesIt = --lines.end(); // Split theSavedTrace into lines int from = 1, end = theSavedTrace.Length(), to; while ( from < end && ( to = theSavedTrace.Location( "\n", from, end ))) { if ( theSavedTrace.ToCString()[from-1] == '\t' ) ++from; if ( to != from ) lines.push_back( theSavedTrace.SubString( from, to - 1 )); from = to + 1; } // For the convertion of IDL API calls -> smeshBuilder.py API, "smesh" standing for SMESH_Gen // was replaces with "smeshgen" (==TPythonDump::SMESHGenName()). // Change "smesh" -> "smeshgen" in the trace saved before passage to smeshBuilder.py API bool isNewVersion = theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() ); theSavedTrace.Clear(); if ( !isNewVersion ) { const TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" ); int beg, end, from; for ( ++linesIt; linesIt != lines.end(); ++linesIt ) { TCollection_AsciiString& aSavedLine = *linesIt; end = aSavedLine.Length(), from = 1; while ( from < end && ( beg = aSavedLine.Location( aSmeshCall, from, end ))) { char charBefore = ( beg == 1 ) ? ' ' : aSavedLine.Value( beg - 1 ); if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word aSavedLine.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen" end += gen.Length(); } from = beg + aSmeshCall.Length(); } } } } // Add new dump trace of API methods calls to script lines if (myPythonScripts.find( aStudyID ) != myPythonScripts.end()) { Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[ aStudyID ]; Standard_Integer istr, aLen = aPythonScript->Length(); for (istr = 1; istr <= aLen; istr++) lines.push_back( aPythonScript->Value( istr )); } // Convert IDL API calls into smeshBuilder.py API. // Some objects are wrapped with python classes and // Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod; std::set< TCollection_AsciiString > aRemovedObjIDs; if ( !getenv("NO_2smeshpy_conversion")) SMESH_2smeshpy::ConvertScript( lines, anEntry2AccessorMethod, theObjectNames, aRemovedObjIDs, theStudy, isHistoricalDump ); bool importGeom = false; GEOM::GEOM_Gen_ptr geom = GetGeomEngine(); { // Add names of GEOM objects to theObjectNames to exclude same names of SMESH objects GEOM::string_array_var aGeomNames = geom->GetAllDumpNames(); int ign = 0, nbgn = aGeomNames->length(); for (; ign < nbgn; ign++) { TCollection_AsciiString aName = aGeomNames[ign].in(); theObjectNames.Bind(aName, "1"); } } TCollection_AsciiString anUpdatedScript; Resource_DataMapOfAsciiStringAsciiString mapRemoved; Resource_DataMapOfAsciiStringAsciiString mapEntries; // names and entries present in anUpdatedScript Standard_Integer objectCounter = 0; TCollection_AsciiString anEntry, aName, aGUIName, aBaseName("smeshObj_"); // Treat every script line and add it to anUpdatedScript for ( linesIt = lines.begin(); linesIt != lines.end(); ++linesIt ) { TCollection_AsciiString& aLine = *linesIt; anUpdatedScript += tab; { //Replace characters used instead of quote marks to quote notebook variables int pos = 1; while (( pos = aLine.Location( 1, SMESH::TVar::Quote(), pos, aLine.Length() ))) aLine.SetValue( pos, '"' ); } // Find entries to be replaced by names Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aLine); const Standard_Integer aSeqLen = aSeq->Length(); Standard_Integer aStart = 1; for (Standard_Integer i = 1; i <= aSeqLen; i += 2) { if ( aStart < aSeq->Value(i) ) anUpdatedScript += aLine.SubString( aStart, aSeq->Value(i) - 1 ); // line part before i-th entry anEntry = aLine.SubString( aSeq->Value(i), aSeq->Value(i + 1) ); // is a GEOM object? CORBA::String_var geomName = geom->GetDumpName( anEntry.ToCString() ); if ( !geomName.in() || !geomName.in()[0] ) { // is a SMESH object if ( theObjectNames.IsBound( anEntry )) { // The Object is in Study aName = theObjectNames.Find( anEntry ); // check validity of aName bool isValidName = fixPythonName( aName ); if (theObjectNames.IsBound(aName) && anEntry != theObjectNames(aName)) { // diff objects have same name - make a new name by appending a digit TCollection_AsciiString aName2; Standard_Integer i = 0; do { aName2 = aName + "_" + ++i; } while (theObjectNames.IsBound(aName2) && anEntry != theObjectNames(aName2)); aName = aName2; isValidName = false; } if ( !isValidName ) theObjectNames(anEntry) = aName; if ( aLine.Value(1) != '#' ) mapEntries.Bind(anEntry, aName); } else { // Removed Object do { aName = aBaseName + (++objectCounter); } while (theObjectNames.IsBound(aName)); if ( !aRemovedObjIDs.count( anEntry ) && aLine.Value(1) != '#') mapRemoved.Bind(anEntry, aName); theObjectNames.Bind(anEntry, aName); } theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects } else { aName = geomName.in(); importGeom = true; } anUpdatedScript += aName; aStart = aSeq->Value(i + 1) + 1; } // loop on entries within aLine if ( aSeqLen == 0 ) anUpdatedScript += aLine; else if ( aSeq->Value( aSeqLen ) < aLine.Length() ) anUpdatedScript += aLine.SubString( aSeq->Value(aSeqLen) + 1, aLine.Length() ); anUpdatedScript += '\n'; } // Make an initial part of aSript TCollection_AsciiString initPart = "import "; if ( isMultiFile ) initPart += "salome, "; initPart += " SMESH, SALOMEDS\n"; initPart += "from salome.smesh import smeshBuilder\n"; if ( importGeom && isMultiFile ) { initPart += ("\n## import GEOM dump file ## \n" "import string, os, sys, re\n" "sys.path.insert( 0, os.path.dirname(__file__) )\n" "exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",__name__)+\" import *\")\n"); } // import python files corresponding to plugins if they are used in anUpdatedScript { TCollection_AsciiString importStr; std::vector pluginNames = getPluginNames(); for ( size_t i = 0; i < pluginNames.size(); ++i ) { // Convert access to plugin members: // e.g. StdMeshers.QUAD_REDUCED -> StdMeshersBuilder.QUAD_REDUCED TCollection_AsciiString pluginAccess = (pluginNames[i] + ".").c_str() ; int iFrom = 1, iPos; while (( iPos = anUpdatedScript.Location( pluginAccess, iFrom, anUpdatedScript.Length() ))) { anUpdatedScript.Insert( iPos + pluginNames[i].size(), "Builder" ); iFrom = iPos + pluginNames[i].size() + 8; } // if any plugin member is used, import the plugin if ( iFrom > 1 ) importStr += ( helper + "\n" "from salome." + pluginNames[i].c_str() + " import " + pluginNames[i].c_str() +"Builder" ); } if ( !importStr.IsEmpty() ) initPart += importStr + "\n"; } if( isMultiFile ) initPart += "def RebuildData(theStudy):"; initPart += "\n"; anUpdatedScript.Prepend( initPart ); // Make a final part of aScript // Dump object removal TCollection_AsciiString removeObjPart; if ( !mapRemoved.IsEmpty() ) { removeObjPart += nt + "## some objects were removed"; removeObjPart += nt + "aStudyBuilder = theStudy.NewBuilder()"; Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapRemovedIt; for ( mapRemovedIt.Initialize( mapRemoved ); mapRemovedIt.More(); mapRemovedIt.Next() ) { aName = mapRemovedIt.Value(); // python name anEntry = mapRemovedIt.Key(); removeObjPart += nt + "SO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR("; removeObjPart += aName; // for object wrapped by class of smeshBuilder.py if ( anEntry2AccessorMethod.IsBound( anEntry ) ) removeObjPart += helper + "." + anEntry2AccessorMethod( anEntry ); removeObjPart += helper + "))" + nt + "if SO: aStudyBuilder.RemoveObjectWithChildren(SO)"; } } // Set object names TCollection_AsciiString setNamePart; Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapEntriesIt; for ( mapEntriesIt.Initialize( mapEntries ); mapEntriesIt.More(); mapEntriesIt.Next() ) { anEntry = mapEntriesIt.Key(); aName = mapEntriesIt.Value(); // python name if ( theNames.IsBound( anEntry )) { aGUIName = theNames.Find(anEntry); setNamePart += nt + aSMESHGen + ".SetName(" + aName; if ( anEntry2AccessorMethod.IsBound( anEntry ) ) setNamePart += helper + "." + anEntry2AccessorMethod( anEntry ); setNamePart += helper + ", '" + aGUIName + "')"; } } if ( !setNamePart.IsEmpty() ) { setNamePart.Insert( 1, nt + "## Set names of Mesh objects" ); } // Store visual properties of displayed objects TCollection_AsciiString visualPropertiesPart; if (isPublished) { //Output the script that sets up the visual parameters. CORBA::String_var compDataType = ComponentDataType(); CORBA::String_var script = theStudy->GetDefaultScript( compDataType.in(), tab.ToCString() ); if ( script.in() && script.in()[0] ) { visualPropertiesPart += nt + "### Store presentation parameters of displayed objects\n"; visualPropertiesPart += script.in(); } } anUpdatedScript += removeObjPart + '\n' + setNamePart + '\n' + visualPropertiesPart; if( isMultiFile ) anUpdatedScript += "\n\tpass"; anUpdatedScript += "\n"; // no need now as we use 'tab' and 'nt' variables depending on isMultiFile // if( !isMultiFile ) // remove unnecessary tabulation // RemoveTabulation( anUpdatedScript ); // ----------------------------------------------------------------- // put string literals describing patterns into separate functions // ----------------------------------------------------------------- TCollection_AsciiString aLongString, aFunctionType; int where = 1; set< string > functionNameSet; while ( SMESH::TPythonDump::CutoutLongString( anUpdatedScript, where, aLongString, aFunctionType )) { // make a python string literal aLongString.Prepend(":\n\treturn '''\n"); aLongString += "\n\t'''\n\tpass\n"; TCollection_AsciiString functionName; // check if the function returning this literal is already defined int posAlready = anUpdatedScript.Location( aLongString, where, anUpdatedScript.Length() ); if ( posAlready ) // already defined { // find the function name int functBeg = posAlready; char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def fuction()" while ( *script != ' ' ) { script--; functBeg--; } functBeg++; // do not take ' ' posAlready--; // do not take ':' functionName = anUpdatedScript.SubString( functBeg, posAlready ); } else // not defined yet { // find a unique function name fixPythonName( aFunctionType ); Standard_Integer nb = 0; do functionName = aFunctionType + "_" + ( nb++ ) + "()"; while ( !functionNameSet.insert( functionName.ToCString() ).second ); // define function TCollection_AsciiString funDef = helper + "def " + functionName + aLongString; if ( isMultiFile ) { anUpdatedScript += helper + "\n\n" + funDef; } else { funDef += "\n\n"; anUpdatedScript.Insert( 1, funDef); where += funDef.Length(); } } anUpdatedScript.InsertBefore( where, functionName ); // call function } aValidScript = true; return anUpdatedScript; SMESH_CATCH( SMESH::printException ); aValidScript = false; return ""; } //============================================================================= /*! * GetNewPythonLines */ //============================================================================= TCollection_AsciiString SMESH_Gen_i::GetNewPythonLines (int theStudyID) { TCollection_AsciiString aScript; // Dump trace of API methods calls if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) { Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID]; Standard_Integer istr, aLen = aPythonScript->Length(); for (istr = 1; istr <= aLen; istr++) { aScript += "\n"; aScript += aPythonScript->Value(istr); } aScript += "\n"; } return aScript; } //============================================================================= /*! * CleanPythonTrace */ //============================================================================= void SMESH_Gen_i::CleanPythonTrace (int theStudyID) { TCollection_AsciiString aScript; // Clean trace of API methods calls if (myPythonScripts.find(theStudyID) != myPythonScripts.end()) { myPythonScripts[theStudyID]->Clear(); } }