ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-28 13:10:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022318: [CEA] Problems with study dump in SMESH

Browse Source 
Merge from V7_main
This commit is contained in:
eap 2013-09-18 12:52:58 +00:00
parent e7368b90ca
commit c843da8f61
9 changed files with 631 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

385
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -180,7 +180,8 @@ namespace {
if ( cmd->GetString().Location( TPythonDump::NotPublishedObjectName(), 1, cmd->Length() ))
{
bool isResultPublished = false;
for ( int i = 0; i < cmd->GetNbResultValues(); i++ )
const int nbRes = cmd->GetNbResultValues();
for ( int i = 0; i < nbRes; i++ )
{
_pyID objID = cmd->GetResultValue( i+1 );
if ( cmd->IsStudyEntry( objID ))
@ -195,7 +196,12 @@ namespace {
}
// check if an Object was created in the script
_AString comment;
const _pyID& obj = cmd->GetObject();
_pyID obj = cmd->GetObject();
if ( !obj.IsEmpty() && obj.Value( obj.Length() ) == ')' )
// remove an accessor method
obj = _pyCommand( obj ).GetObject();
const bool isMethodCall = cmd->IsMethodCall();
if ( !obj.IsEmpty() && isMethodCall && !presentObjects.count( obj ) )
{
@ -448,30 +454,26 @@ namespace {
//================================================================================
void
SMESH_2smeshpy::ConvertScript(TCollection_AsciiString& theScript,
SMESH_2smeshpy::ConvertScript(std::list< TCollection_AsciiString >& theScriptLines,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands)
{
std::list< TCollection_AsciiString >::iterator lineIt;
// process notebook variables
{
SMESH_NoteBook aNoteBook;
int from = 1, end = theScript.Length(), to;
while ( from < end && ( to = theScript.Location( "\n", from, end )))
{
if ( to != from )
// cut out and store a command
aNoteBook.AddCommand( theScript.SubString( from, to - 1 ));
from = to + 1;
}
theScript.Clear();
for ( lineIt = theScriptLines.begin(); lineIt != theScriptLines.end(); ++lineIt )
aNoteBook.AddCommand( *lineIt );
theScriptLines.clear();
aNoteBook.ReplaceVariables();
theScript = aNoteBook.GetResultScript();
aNoteBook.GetResultLines( theScriptLines );
}
// convert to smeshBuilder.py API
@ -482,16 +484,10 @@ SMESH_2smeshpy::ConvertScript(TCollection_AsciiString& theScrip
theStudy,
theToKeepAllCommands );
// split theScript into separate commands
int from = 1, end = theScript.Length(), to;
while ( from < end && ( to = theScript.Location( "\n", from, end )))
{
if ( to != from )
// cut out and store a command
theGen->AddCommand( theScript.SubString( from, to - 1 ));
from = to + 1;
}
theScript.Clear();
for ( lineIt = theScriptLines.begin(); lineIt != theScriptLines.end(); ++lineIt )
theGen->AddCommand( *lineIt );
theScriptLines.clear();
// finish conversion
theGen->Flush();
@ -527,12 +523,10 @@ SMESH_2smeshpy::ConvertScript(TCollection_AsciiString& theScrip
CheckObjectPresence( *cmd, createdObjects );
if ( !(*cmd)->IsEmpty() ) {
aPrevCmd = (*cmd)->GetString();
theScript += "\n";
theScript += aPrevCmd;
theScriptLines.push_back( aPrevCmd );
}
}
}
theScript += "\n";
theGen->Free();
theGen.Nullify();
@ -635,17 +629,23 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
// Method( SMESH.PointStruct(x,y,z)... -> Method( [x,y,z]...
//StructToList( aCommand );
const TCollection_AsciiString& method = aCommand->GetMethod();
// not to erase _pySelfEraser's etc. used as args in some commands
{
#ifdef USE_STRING_FAMILY
_pyID objID;
if ( myKeepAgrCmdsIDs.IsIn( theCommand, objID ))
std::list<_pyID> objIDs;
if ( myKeepAgrCmdsIDs.IsInArgs( aCommand, objIDs ))
{
Handle(_pyObject) obj = FindObject( objID );
if ( !obj.IsNull() )
std::list<_pyID>::iterator objID = objIDs.begin();
for ( ; objID != objIDs.end(); ++objID )
{
obj->AddArgCmd( aCommand );
//cout << objID << " found in " << theCommand << endl;
Handle(_pyObject) obj = FindObject( *objID );
if ( !obj.IsNull() )
{
obj->AddArgCmd( aCommand );
//cout << objID << " found in " << theCommand << endl;
}
}
}
#else
@ -687,8 +687,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
else if ( aCommand->GetMethod() == "GetSubMesh" ) { // SubMesh creation
_pyID subMeshID = aCommand->GetResultValue();
Handle(_pySubMesh) subMesh = new _pySubMesh( aCommand );
CheckObjectIsReCreated( subMesh );
myObjects.insert( make_pair( subMeshID, subMesh ));
AddObject( subMesh );
}
// Method( mesh.GetIDSource([id1,id2]) -> Method( [id1,id2]
@ -710,8 +709,6 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
//addFilterUser( aCommand, theGen ); // protect filters from clearing
const TCollection_AsciiString& method = aCommand->GetMethod();
// some commands of SMESH_MeshEditor create meshes and groups
_pyID meshID, groups;
if ( method.Search("MakeMesh") != -1 )
@ -957,11 +954,11 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
method == "CreateMeshesFromCGNS" ||
method == "CreateMeshesFromGMF" ) // command result is ( [mesh1,mesh2], status )
{
for ( int ind = 0; ind < theCommand->GetNbResultValues(); ind++ )
std::list< _pyID > meshIDs = theCommand->GetStudyEntries( theCommand->GetResultValue() );
std::list< _pyID >::iterator meshID = meshIDs.begin();
for ( ; meshID != meshIDs.end(); ++meshID )
{
_pyID meshID = theCommand->GetResultValue(ind+1);
if ( !theCommand->IsStudyEntry( meshID ) ) continue;
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
Handle(_pyMesh) mesh = new _pyMesh( theCommand, *meshID );
AddObject( mesh );
}
if ( method == "CreateMeshesFromGMF" )
@ -1029,7 +1026,7 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
method == "CreateMeasurements" )
{
Handle(_pyObject) obj = new _pySelfEraser( theCommand );
if ( !myObjects.insert( make_pair( obj->GetID(), obj )).second )
if ( !AddObject( obj ) )
theCommand->Clear(); // already created
}
// Concatenate( [mesh1, ...], ... )
@ -1125,10 +1122,15 @@ void _pyGen::Flush()
id_hyp->second->GetCreationCmd()->SetObject( SMESH_2smeshpy::GenName() );
}
// Flush other objects
for ( id_obj = myObjects.begin(); id_obj != myObjects.end(); ++id_obj )
if ( ! id_obj->second.IsNull() )
id_obj->second->Flush();
// Flush other objects. 2 times, for objects depending on Flush() of later created objects
std::list< Handle(_pyObject) >::reverse_iterator robj = myOrderedObjects.rbegin();
for ( ; robj != myOrderedObjects.rend(); ++robj )
if ( ! robj->IsNull() )
(*robj)->Flush();
std::list< Handle(_pyObject) >::iterator obj = myOrderedObjects.begin();
for ( ; obj != myOrderedObjects.end(); ++obj )
if ( ! obj->IsNull() )
(*obj)->Flush();
myLastCommand->SetOrderNb( ++myNbCommands );
myCommands.push_back( myLastCommand );
@ -1143,23 +1145,23 @@ void _pyGen::Flush()
void _pyGen::PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const
{
map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
for ( ; id_obj != myObjects.end(); ++id_obj )
{
if ( !id_obj->second->IsKind( STANDARD_TYPE( _pySubMesh ))) continue;
for ( int iArg = theCmdUsingSubmesh->GetNbArgs(); iArg; --iArg )
{
const _pyID& arg = theCmdUsingSubmesh->GetArg( iArg );
if ( arg.IsEmpty() || arg.Value( 1 ) == '"' || arg.Value( 1 ) == '\'' )
continue;
list< _pyID > idList = theCmdUsingSubmesh->GetStudyEntries( arg );
list< _pyID >::iterator id = idList.begin();
for ( ; id != idList.end(); ++id )
if ( id_obj->first == *id )
// _pySubMesh::Process() does what we need
Handle(_pySubMesh)::DownCast( id_obj->second )->Process( theCmdUsingSubmesh );
}
}
// map< _pyID, Handle(_pyObject) >::const_iterator id_obj = myObjects.begin();
// for ( ; id_obj != myObjects.end(); ++id_obj )
// {
// if ( !id_obj->second->IsKind( STANDARD_TYPE( _pySubMesh ))) continue;
// for ( int iArg = theCmdUsingSubmesh->GetNbArgs(); iArg; --iArg )
// {
// const _pyID& arg = theCmdUsingSubmesh->GetArg( iArg );
// if ( arg.IsEmpty() || arg.Value( 1 ) == '"' || arg.Value( 1 ) == '\'' )
// continue;
// list< _pyID > idList = theCmdUsingSubmesh->GetStudyEntries( arg );
// list< _pyID >::iterator id = idList.begin();
// for ( ; id != idList.end(); ++id )
// if ( id_obj->first == *id )
// // _pySubMesh::Process() does what we need
// Handle(_pySubMesh)::DownCast( id_obj->second )->Process( theCmdUsingSubmesh );
// }
// }
}
//================================================================================
@ -1179,9 +1181,15 @@ void _pyGen::ClearCommands()
if ( !id_hyp->second.IsNull() )
id_hyp->second->ClearCommands();
map< _pyID, Handle(_pyObject) >::iterator id_obj = myObjects.begin();
for ( ; id_obj != myObjects.end(); ++id_obj )
id_obj->second->ClearCommands();
// Other objects. 2 times, for objects depending on ClearCommands() of later created objects
std::list< Handle(_pyObject) >::reverse_iterator robj = myOrderedObjects.rbegin();
for ( ; robj != myOrderedObjects.rend(); ++robj )
if ( ! robj->IsNull() )
(*robj)->ClearCommands();
std::list< Handle(_pyObject) >::iterator obj = myOrderedObjects.begin();
for ( ; obj != myOrderedObjects.end(); ++obj )
if ( ! obj->IsNull() )
(*obj)->ClearCommands();
}
//================================================================================
@ -1476,20 +1484,27 @@ _pyID _pyGen::GenerateNewID( const _pyID& theID )
*/
//================================================================================
void _pyGen::AddObject( Handle(_pyObject)& theObj )
bool _pyGen::AddObject( Handle(_pyObject)& theObj )
{
if ( theObj.IsNull() ) return;
if ( theObj.IsNull() ) return false;
CheckObjectIsReCreated( theObj );
if ( theObj->IsKind( STANDARD_TYPE( _pyMesh )))
myMeshes.insert( make_pair( theObj->GetID(), Handle(_pyMesh)::DownCast( theObj )));
bool add;
else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor )))
myMeshEditors.insert( make_pair( theObj->GetID(), Handle(_pyMeshEditor)::DownCast( theObj )));
else
myObjects.insert( make_pair( theObj->GetID(), theObj ));
if ( theObj->IsKind( STANDARD_TYPE( _pyMesh ))) {
add = myMeshes.insert( make_pair( theObj->GetID(),
Handle(_pyMesh)::DownCast( theObj ))).second;
}
else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor ))) {
add = myMeshEditors.insert( make_pair( theObj->GetID(),
Handle(_pyMeshEditor)::DownCast( theObj ))).second;
}
else {
add = myObjects.insert( make_pair( theObj->GetID(), theObj )).second;
if ( add ) myOrderedObjects.push_back( theObj );
}
return add;
}
//================================================================================
@ -1960,7 +1975,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
{
addCmd = *cmd;
cmd = addHypCmds.erase( cmd );
if ( !theGen->IsToKeepAllCommands() ) {
if ( !theGen->IsToKeepAllCommands() && CanClear() ) {
addCmd->Clear();
theCommand->Clear();
}
@ -3421,7 +3436,7 @@ bool _pyAlgorithm::Addition2Creation( const Handle(_pyCommand)& theCmd,
*/
//================================================================================
int _pyCommand::GetBegPos( int thePartIndex )
int _pyCommand::GetBegPos( int thePartIndex ) const
{
if ( IsEmpty() )
return EMPTY;
@ -3461,7 +3476,7 @@ TCollection_AsciiString _pyCommand::GetIndentation()
GetWord( myString, end, true );
else
end = GetBegPos( RESULT_IND );
return myString.SubString( 1, end - 1 );
return myString.SubString( 1, Max( end - 1, 1 ));
}
//================================================================================
@ -3501,16 +3516,8 @@ const TCollection_AsciiString & _pyCommand::GetResultValue()
int _pyCommand::GetNbResultValues()
{
int nb = 0;
int begPos = 1;
int endPos = myString.Location( "=", 1, Length() );
while ( begPos < endPos )
{
_AString str = GetWord( myString, begPos, true );
begPos = begPos+ str.Length();
nb++;
}
return (nb-1);
GetResultValue(1);
return myResults.Length();
}
@ -3521,32 +3528,38 @@ int _pyCommand::GetNbResultValues()
* \retval const TCollection_AsciiString & - ResultValue with res index substring
*/
//================================================================================
TCollection_AsciiString _pyCommand::GetResultValue(int res)
const _AString& _pyCommand::GetResultValue(int res)
{
int begPos = 1;
if ( SkipSpaces( myString, begPos ) && myString.Value( begPos ) == '[' )
++begPos; // skip [, else the whole list is returned
int endPos = myString.Location( "=", 1, Length() );
int Nb=0;
while ( begPos < endPos) {
_AString result = GetWord( myString, begPos, true );
begPos = begPos + result.Length();
Nb++;
if(res == Nb) {
result.RemoveAll('[');
result.RemoveAll(']');
return result;
if ( GetResultValue().IsEmpty() )
return theEmptyString;
if ( myResults.IsEmpty() )
{
int begPos = 1;
if ( SkipSpaces( myRes, begPos ) && myRes.Value( begPos ) == '[' )
++begPos; // skip [, else the whole list is returned
while ( begPos < myRes.Length() ) {
_AString result = GetWord( myRes, begPos, true );
begPos += result.Length();
// if(res == Nb) {
// result.RemoveAll('[');
// result.RemoveAll(']');
// return result;
// }
// if(Nb>res)
// break;
myResults.Append( result );
}
if(Nb>res)
break;
}
if ( res > 0 && res <= myResults.Length() )
return myResults( res );
return theEmptyString;
}
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Object.Meth()
* \retval const TCollection_AsciiString & - Object substring
* \retval const TCollection_AsciiString & - Object substring
*/
//================================================================================
@ -3729,6 +3742,24 @@ const TCollection_AsciiString & _pyCommand::GetArg( int index )
return myArgs( index );
}
//================================================================================
/*!
* \brief Return position where arguments begin
*/
//================================================================================
int _pyCommand::GetArgBeginning() const
{
int pos = GetBegPos( ARG1_IND );
if ( pos == UNKNOWN )
{
pos = GetBegPos( METHOD_IND ) + myMeth.Length();
if ( pos < 1 )
pos = myString.Location( "(", 4, Length() ); // 4 = strlen("b.c(")
}
return pos;
}
//================================================================================
/*!
* \brief Check if char is a word part
@ -3843,11 +3874,10 @@ bool _pyCommand::IsID( const TCollection_AsciiString& str )
{
if ( str.Length() < 1 ) return false;
if ( isdigit( str.Value( 1 )))
return IsStudyEntry( str );
const char* s = str.ToCString();
for ( int i = 1; i <= str.Length(); ++i )
if ( !isalnum( str.Value( i )) && !str.Value( i ) != '_' )
for ( int i = 0; i < str.Length(); ++i )
if ( !IsIDChar( s[i] ))
return false;
return true;
@ -4014,9 +4044,9 @@ void _pyCommand::Comment()
myString.Insert( i, "#" );
for ( int iPart = 1; iPart <= myBegPos.Length(); ++iPart )
{
int begPos = GetBegPos( iPart + 1 );
if ( begPos != UNKNOWN )
SetBegPos( iPart + 1, begPos + 1 );
int begPos = GetBegPos( iPart );
if ( begPos != UNKNOWN && begPos != EMPTY )
SetBegPos( iPart, begPos + 1 );
}
}
}
@ -4064,7 +4094,8 @@ bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod
// check that theObjectID is not just a part of a longer ID
int afterEnd = beg + theObjectID.Length();
Standard_Character c = myString.Value( afterEnd );
if ( !isalnum( c ) && c != ':' ) {
if ( !IsIDChar( c ))
{
// check if accessor method already present
if ( c != '.' ||
myString.Location( (char*) theAcsMethod, afterEnd, Length() ) != afterEnd+1) {
@ -4081,7 +4112,7 @@ bool _pyCommand::AddAccessorMethod( _pyID theObjectID, const char* theAcsMethod
added = true;
}
}
beg = afterEnd; // is a part - next search
beg = afterEnd; // is a part -> next search
}
return added;
}
@ -4156,7 +4187,8 @@ _pyID _pyObject::FatherID(const _pyID & childID)
//================================================================================
/*!
* \brief SelfEraser erases creation command if no more it's commands invoked
* \brief SelfEraser erases creation command if none of it's commands invoked
* (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
*/
//================================================================================
@ -4169,11 +4201,12 @@ _pySelfEraser::_pySelfEraser(const Handle(_pyCommand)& theCreationCmd)
//================================================================================
/*!
* \brief SelfEraser erases creation command if no more it's commands invoked
* \brief SelfEraser erases creation command if none of it's commands invoked
* (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
*/
//================================================================================
void _pySelfEraser::Flush()
bool _pySelfEraser::CanClear()
{
bool toErase = false;
if ( myIgnoreOwnCalls ) // check if this obj is used as argument
@ -4181,23 +4214,55 @@ void _pySelfEraser::Flush()
int nbArgUses = 0;
list< Handle(_pyCommand) >::iterator cmd = myArgCmds.begin();
for ( ; cmd != myArgCmds.end(); ++cmd )
nbArgUses += !(*cmd)->IsEmpty();
nbArgUses += IsAliveCmd( *cmd );
toErase = ( nbArgUses < 1 );
}
else
{
int nbCalls = GetNbCalls();
if ( nbCalls > 0 )
{
// ignore cleared commands
std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
for ( ; cmd != cmds.end(); ++cmd )
nbCalls -= (*cmd)->IsEmpty();
}
int nbCalls = 0;
std::list< Handle(_pyCommand) >& cmds = GetProcessedCmds();
std::list< Handle(_pyCommand) >::const_iterator cmd = cmds.begin();
for ( ; cmd != cmds.end(); ++cmd )
// check of cmd emptiness is not enough as object can change
nbCalls += ( ( *cmd )->GetString().Search( GetID() ) > 0 );
toErase = ( nbCalls < 1 );
}
if ( toErase )
return toErase;
}
//================================================================================
/*!
* \brief Check if a command is or can be cleared
*/
//================================================================================
bool _pySelfEraser::IsAliveCmd( const Handle(_pyCommand)& theCmd )
{
if ( theCmd->IsEmpty() )
return false;
if ( !theGen->IsToKeepAllCommands() )
{
const _pyID& objID = theCmd->GetObject();
Handle( _pyObject ) obj = theGen->FindObject( objID );
if ( !obj.IsNull() )
return !obj->CanClear();
}
return true;
}
//================================================================================
/*!
* \brief SelfEraser erases creation command if none of it's commands invoked
* (e.g. filterManager) or it's not used as a command argument (e.g. a filter)
*/
//================================================================================
void _pySelfEraser::Flush()
{
if ( CanClear() )
{
myIsPublished = false;
_pyObject::ClearCommands();
@ -4552,10 +4617,12 @@ void _pyFilter::Process( const Handle(_pyCommand)& theCommand)
theCommand->SetMethod( "GetFilterFromCriteria" );
// Swap "aFilterManager.CreateFilter()" and "smesh.GetFilterFromCriteria(criteria)"
// GetCreationCmd()->Clear();
// GetCreationCmd()->GetString() = theCommand->GetString();
// theCommand->Clear();
// theCommand->AddDependantCmd( GetCreationCmd() );
// why swap?
GetCreationCmd()->Clear();
GetCreationCmd()->GetString() = theCommand->GetString();
theCommand->Clear();
theCommand->AddDependantCmd( GetCreationCmd() );
}
else if ( theCommand->GetMethod() == "SetMesh" )
{
@ -4950,31 +5017,42 @@ bool _pyStringFamily::Add( const char* str )
*/
//================================================================================
bool _pyStringFamily::IsIn( const _AString& longStr, _AString& subStr )
bool _pyStringFamily::IsInArgs( Handle( _pyCommand)& cmd, std::list<_AString>& subStr )
{
const char* s = longStr.ToCString();
const _AString& longStr = cmd->GetString();
const char* s = longStr.ToCString();
// look in _subFams
std::list< _pyStringFamily >::iterator itSub = _subFams.begin();
int pos, len;
int nbFound = 0, pos, len, from, argBeg = cmd->GetArgBeginning();
if ( argBeg < 4 || argBeg > longStr.Length() )
return false;
for ( ; itSub != _subFams.end(); ++itSub )
{
if (( pos = longStr.Search( itSub->_prefix )-1) > 6-1 ) // 6 = strlen("a=b.c(")
if (( len = itSub->isIn( s + pos + itSub->_prefix.Length() )) >= 0 )
from = argBeg;
while (( pos = longStr.Location( itSub->_prefix, from, longStr.Length() )))
if (( len = itSub->isIn( s + pos-1 + itSub->_prefix.Length() )) >= 0 )
{
subStr = _AString( s + pos, len + itSub->_prefix.Length() );
return true;
subStr.push_back( _AString( s + pos-1, len + itSub->_prefix.Length() ));
from = pos + len + itSub->_prefix.Length();
nbFound++;
}
else
{
from += itSub->_prefix.Length();
}
}
// look among _strings
std::list< _AString >::iterator itStr = _strings.begin();
for ( ; itStr != _strings.end(); ++itStr )
if ( longStr.Search( *itStr ) > itStr->Length() )
{
subStr = *itStr;
return true;
}
return false;
if (( pos = longStr.Location( *itStr, argBeg, longStr.Length() )))
// check that object ID does not continue after len
if ( !cmd->IsIDChar( s[ pos + itStr->Length() - 1 ] ))
{
subStr.push_back( *itStr );
nbFound++;
}
return nbFound;
}
//================================================================================
@ -4988,7 +5066,7 @@ bool _pyStringFamily::IsIn( const _AString& longStr, _AString& subStr )
int _pyStringFamily::isIn( const char* str )
{
std::list< _pyStringFamily >::iterator itSub = _subFams.begin();
int len;
int len = -1;
for ( ; itSub != _subFams.end(); ++itSub )
{
int cmp = strncmp( str, itSub->_prefix.ToCString(), itSub->_prefix.Length() );
@ -5005,20 +5083,27 @@ int _pyStringFamily::isIn( const char* str )
std::list< _AString >::iterator itStr = _strings.begin();
bool firstEmpty = itStr->IsEmpty();
if ( firstEmpty )
++itStr;
++itStr, len = 0;
for ( ; itStr != _strings.end(); ++itStr )
{
int cmp = strncmp( str, itStr->ToCString(), itStr->Length() );
if ( cmp == 0 )
return itStr->Length();
else if ( cmp < 0 )
{
len = itStr->Length();
break;
}
else if ( cmp < 0 )
{
break;
}
}
if ( firstEmpty )
return 0;
// check that object ID does not continue after len
if ( len >= 0 && _pyCommand::IsIDChar( str[len] ))
len = -1;
}
return -1;
return len;
}
//================================================================================

19
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -102,11 +102,12 @@ class _pyCommand: public Standard_Transient
_AString myString; //!< command text
_AString myRes, myObj, myMeth; //!< found parts of command
TColStd_SequenceOfAsciiString myArgs; //!< found arguments
TColStd_SequenceOfAsciiString myResults; //!< found results
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 );
int GetBegPos( int thePartIndex ) const;
void SetBegPos( int thePartIndex, int thePosition );
void SetPart( int thePartIndex, const _AString& theNewPart, _AString& theOldPart);
void FindAllArgs() { GetArg(1); }
@ -120,17 +121,18 @@ public:
void SetOrderNb( int theNb ) { myOrderNb = theNb; }
typedef void* TAddr;
TAddr GetAddress() const { return (void*) this; }
int Length() { return myString.Length(); }
int Length() const { return myString.Length(); }
void Clear() { myString.Clear(); myBegPos.Clear(); myArgs.Clear(); }
bool IsEmpty() const { return myString.IsEmpty(); }
_AString GetIndentation();
const _AString & GetResultValue();
int GetNbResultValues();
_AString GetResultValue(int res);
const _AString& GetResultValue(int res);
const _AString & GetObject();
const _AString & GetMethod();
const _AString & GetArg( int index );
int GetNbArgs() { FindAllArgs(); return myArgs.Length(); }
int GetArgBeginning() const;
bool IsMethodCall();
bool MethodStartsFrom(const _AString& beg)
{ GetMethod(); return ( myMeth.Location( beg, 1, myMeth.Length() ) == 1 ); }
@ -148,6 +150,8 @@ public:
const bool theForward, const bool dotIsWord = false);
static bool IsStudyEntry( const _AString& str );
static bool IsID( const _AString& str );
static bool IsIDChar( char c )
{ return ( isalnum( c ) || c == '_' || c == ':' ); }
static std::list< _pyID > GetStudyEntries( const _AString& str );
void AddDependantCmd( Handle(_pyCommand) cmd, bool prepend = false)
{ if (prepend) myDependentCmds.push_front( cmd ); else myDependentCmds.push_back( cmd ); }
@ -234,7 +238,7 @@ class _pyStringFamily
int isIn( const char* str );
public:
bool Add( const char* str );
bool IsIn( const _AString& str, _AString& subStr );
bool IsInArgs( Handle( _pyCommand)& cmd, std::list<_AString>& subStr );
void Print( int level = 0 );
};
@ -261,7 +265,7 @@ public:
void PlaceSubmeshAfterItsCreation( Handle(_pyCommand) theCmdUsingSubmesh ) const;
_pyID GenerateNewID( const _pyID& theID );
void AddObject( Handle(_pyObject)& theObj );
bool AddObject( Handle(_pyObject)& theObj );
void CheckObjectIsReCreated( Handle(_pyObject)& theObj );
void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
@ -305,8 +309,9 @@ private:
private:
std::map< _pyID, Handle(_pyMesh) > myMeshes;
std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
std::map< _pyID, Handle(_pyObject) > myObjects;
std::map< _pyID, Handle(_pyHypothesis) > myHypos;
std::map< _pyID, Handle(_pyObject) > myObjects;
std::list< Handle(_pyObject) > myOrderedObjects; // to know order of myObjects creation
#ifdef USE_STRING_FAMILY
_pyStringFamily myKeepAgrCmdsIDs;
#else
@ -572,6 +577,8 @@ public:
_pySelfEraser(const Handle(_pyCommand)& theCreationCmd);
void IgnoreOwnCalls() { myIgnoreOwnCalls = true; }
virtual void Flush();
virtual bool CanClear();
static bool IsAliveCmd( const Handle(_pyCommand)& theCmd );
DEFINE_STANDARD_RTTI (_pySelfEraser)
};

578
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -25,15 +25,17 @@
// Module : SMESH
#include "SMESH_PythonDump.hxx"
#include "SMESH_Gen_i.hxx"
#include "SMESH_Filter_i.hxx"
#include "SMESH_MeshEditor_i.hxx"
#include "SMESH_2smeshpy.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 <LDOMParser.hxx>
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
#include <TColStd_HSequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx>
#include <SMESH_Comment.hxx>
#ifdef _DEBUG_
static int MYDEBUG = 0;
@ -77,7 +79,7 @@ namespace SMESH
}
}
TPythonDump& //!< to store a variable value
TPythonDump& //!< store a variable value. Write either a value or '$varID$'
TPythonDump::
operator<<(const TVar& theVarValue)
{
@ -274,7 +276,7 @@ namespace SMESH
if(aSObject->_is_nil() && !CORBA::is_nil(theArg))
myStream << "hyp_" << theArg->GetId();
else
*this << CORBA::Object_ptr( theArg );
*this << aSObject;
return *this;
}
@ -288,16 +290,24 @@ namespace SMESH
SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
if(!aSObject->_is_nil())
return *this << aSObject;
if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theArg ))
return *this << filter;
SMESH::SMESH_Mesh_var mesh = theArg->GetMesh();
if ( !theArg->_is_equivalent( mesh ))
{
SMESH::long_array_var anElementsId = theArg->GetIDs();
SMESH::array_of_ElementType_var types = theArg->GetTypes();
SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL;
return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
return *this << aSObject;
}
if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( 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_var 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;
}
@ -332,9 +342,9 @@ namespace SMESH
{
if ( theArg ) {
FunctorType aFunctorType = theArg->GetFunctorType();
switch(aFunctorType){
case FT_AspectRatio: myStream<< "anAspectRatio"; break;
case FT_AspectRatio3D: myStream<< "anAspectRatio3D"; break;
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;
@ -559,6 +569,13 @@ namespace SMESH
return true;
}
void printException( const char* text )
{
#ifdef _DEBUG_
cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << endl;
#endif
}
}
//=======================================================================
@ -600,7 +617,6 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
// Map study entries to object names
Resource_DataMapOfAsciiStringAsciiString aMap;
Resource_DataMapOfAsciiStringAsciiString aMapNames;
//TCollection_AsciiString s ("qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_");
SALOMEDS::ChildIterator_var Itr = aStudy->NewChildIterator(aSO);
for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
@ -608,21 +624,22 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
CORBA::String_var anID = aValue->GetID();
CORBA::String_var aName = aValue->GetName();
TCollection_AsciiString aGUIName ( (char*) aName.in() );
TCollection_AsciiString anEnrty ( (char*) anID.in() );
TCollection_AsciiString anEntry ( (char*) anID.in() );
if (aGUIName.Length() > 0) {
aMapNames.Bind( anEnrty, aGUIName );
aMap.Bind( anEnrty, aGUIName );
aMapNames.Bind( anEntry, aGUIName );
aMap.Bind( anEntry, aGUIName );
}
}
// Get trace of restored study
//SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this());
SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
TCollection_AsciiString aSavedTrace (oldValue);
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;
@ -684,8 +701,10 @@ void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy)
SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject();
TCollection_AsciiString oldScript (oldValue);
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";
@ -695,7 +714,7 @@ void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy)
}
// Store in PythonObject attribute
SALOMEDS::AttributePythonObject::_narrow(anAttr)->SetObject(oldScript.ToCString(), 1);
pyAttr->SetObject(oldScript.ToCString(), 1);
// Clean trace of API methods calls
CleanPythonTrace(theStudy->StudyId());
@ -758,28 +777,39 @@ namespace {
*/
//================================================================================
bool fixPythonName(TCollection_AsciiString & aName )
bool fixPythonName(TCollection_AsciiString & aName)
{
const TCollection_AsciiString allowedChars =
"qwertyuioplkjhgfdsazxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM0987654321_";
bool isValidName = true;
int nbUnderscore = 0;
int p=1; // replace not allowed chars by underscore
while (p <= aName.Length() &&
(p = aName.FirstLocationNotInSet(allowedChars, p, aName.Length())))
{
if ( p == 1 || p == aName.Length() || aName.Value(p-1) == '_')
aName.Remove( p, 1 ); // remove double _ from the start and the end
else
aName.SetValue(p, '_'), nbUnderscore++;
isValidName = false;
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;
}
}
if ( aName.IsIntegerValue() ) { // aName must not start with a digit
// 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
if ( aName.Length() > 20 && nbUnderscore > 2 )
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 )
@ -787,173 +817,254 @@ namespace {
}
return isValidName;
}
//================================================================================
/*!
* \brief Return Python module names of available plug-ins.
*/
//================================================================================
std::vector<std::string> getPluginNames()
{
std::vector<std::string> 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;
}
// <meshers-group name="Standard Meshers"
// resources="StdMeshers"
// idl-module="StdMeshers"
// server-lib="StdMeshersEngine"
// gui-lib="StdMeshersGUI">
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;
}
}
//=============================================================================
//================================================================================
/*!
* DumpPython
* \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,
(SALOMEDS::Study_ptr theStudy,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
Resource_DataMapOfAsciiStringAsciiString& theNames,
bool isPublished,
bool isMultiFile,
bool isHistoricalDump,
bool& aValidScript,
const TCollection_AsciiString& theSavedTrace)
bool isPublished,
bool isMultiFile,
bool isHistoricalDump,
bool& aValidScript,
TCollection_AsciiString& theSavedTrace)
{
int aStudyID = theStudy->StudyId();
TCollection_AsciiString helper; // to comfortably concatenate C strings
TCollection_AsciiString aSmeshpy( SMESH_2smeshpy::SmeshpyName() );
TCollection_AsciiString aSMESHGen( SMESH_2smeshpy::GenName() );
TCollection_AsciiString anOldGen( SMESH::TPythonDump::SMESHGenName() );
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;
TCollection_AsciiString aScript;
if( isMultiFile )
aScript += "def RebuildData(theStudy):";
aScript += "\n\t";
aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
std::list< TCollection_AsciiString > lines; // lines of a script
std::list< TCollection_AsciiString >::iterator linesIt;
if ( isPublished )
aScript += aSMESHGen + ".SetCurrentStudy(theStudy)";
else
aScript += aSMESHGen + ".SetCurrentStudy(None)";
lines.push_back( tab + aSMESHGen + " = smeshBuilder.New(theStudy)" );
else
lines.push_back( tab + aSMESHGen + " = smeshBuilder.New(None)" );
lines.push_back( tab + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()" );
lines.push_back( tab + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()" );
// import python files corresponding to plugins
set<string> moduleNameSet;
map<string, GenericHypothesisCreator_i*>::iterator hyp_creator = myHypCreatorMap.begin();
for ( ; hyp_creator != myHypCreatorMap.end(); ++hyp_creator ) {
string moduleName = hyp_creator->second->GetModuleName();
bool newModule = moduleNameSet.insert( moduleName ).second;
if ( newModule )
aScript += helper + "\n\t" + "import " + (char*) moduleName.c_str();
}
// Dump trace of restored study
if (theSavedTrace.Length() > 0) {
// For the convertion of IDL API calls -> smesh.py API, "smesh" standing for SMESH_Gen
// 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 smesh.py API
// Change "smesh" -> "smeshgen" in the trace saved before passage to smeshBuilder.py API
bool isNewVersion =
theSavedTrace.Location( anOldGen + ".", 1, theSavedTrace.Length() );
if ( !isNewVersion ) {
TCollection_AsciiString aSavedTrace( theSavedTrace );
TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
int beg, end = aSavedTrace.Length(), from = 1;
while ( from < end && ( beg = aSavedTrace.Location( aSmeshCall, from, end ))) {
char charBefore = ( beg == 1 ) ? ' ' : aSavedTrace.Value( beg - 1 );
if ( isspace( charBefore ) || charBefore == '=' ) { // "smesh." is not a part of a long word
aSavedTrace.Insert( beg + aSmeshCall.Length() - 1, gen );// "smesh" -> "smeshgen"
end += gen.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();
}
from = beg + aSmeshCall.Length();
}
aScript += helper + "\n" + aSavedTrace;
}
else
// append a saved trace to the script
aScript += helper + "\n" + theSavedTrace;
}
// Dump trace of API methods calls
TCollection_AsciiString aNewLines = GetNewPythonLines(aStudyID);
if (aNewLines.Length() > 0) {
aScript += helper + "\n" + aNewLines;
// 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 smesh.py API.
// 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( aScript, anEntry2AccessorMethod,
SMESH_2smeshpy::ConvertScript( lines, anEntry2AccessorMethod,
theObjectNames, aRemovedObjIDs,
theStudy, isHistoricalDump );
// Replace characters used instead of quote marks to quote notebook variables
{
int pos = 1;
while (( pos = aScript.Location( 1, SMESH::TVar::Quote(), pos, aScript.Length() )))
aScript.SetValue( pos, '"' );
}
// Find entries to be replaced by names
Handle(TColStd_HSequenceOfInteger) aSeq = FindEntries(aScript);
Standard_Integer aLen = aSeq->Length();
if (aLen == 0 && isMultiFile)
return aScript;
// Replace entries by the names
GEOM::GEOM_Gen_ptr geom = GetGeomEngine();
TColStd_SequenceOfAsciiString seqRemoved;
Resource_DataMapOfAsciiStringAsciiString mapRemoved;
Standard_Integer objectCounter = 0, aStart = 1, aScriptLength = aScript.Length();
TCollection_AsciiString anUpdatedScript, anEntry, aName, aBaseName("smeshObj_");
// Collect names of GEOM objects to exclude same names of SMESH objects
GEOM::string_array_var aGeomNames = geom->GetAllDumpNames();
int ign = 0, nbgn = aGeomNames->length();
for (; ign < nbgn; ign++) {
aName = aGeomNames[ign];
theObjectNames.Bind(aName, "1");
}
bool importGeom = false;
for (Standard_Integer i = 1; i <= aLen; i += 2) {
anUpdatedScript += aScript.SubString(aStart, aSeq->Value(i) - 1);
anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
// is a GEOM object?
aName = geom->GetDumpName( anEntry.ToCString() );
if (aName.IsEmpty()) {
// 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;
} else {
// Removed Object
do {
aName = aBaseName + (++objectCounter);
} while (theObjectNames.IsBound(aName));
if ( !aRemovedObjIDs.count( anEntry ))
seqRemoved.Append(aName);
mapRemoved.Bind(anEntry, "1");
theObjectNames.Bind(anEntry, aName);
}
theObjectNames.Bind(aName, anEntry); // to detect same name of diff objects
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");
}
else
{
importGeom = true;
}
anUpdatedScript += aName;
aStart = aSeq->Value(i + 1) + 1;
}
// set initial part of aSript
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[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 += helper + "salome, ";
initPart += aSmeshpy + ", SMESH, SALOMEDS\n";
initPart += "salome, ";
initPart += " SMESH, SALOMEDS\n";
initPart += "from salome.smesh import smeshBuilder\n";
if ( importGeom && isMultiFile )
{
initPart += ("\n## import GEOM dump file ## \n"
@ -961,77 +1072,100 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
"sys.path.insert( 0, os.path.dirname(__file__) )\n"
"exec(\"from \"+re.sub(\"SMESH$\",\"GEOM\",__name__)+\" import *\")\n");
}
anUpdatedScript.Insert ( 1, initPart );
// add final part of aScript
if (aLen && aSeq->Value(aLen) < aScriptLength)
anUpdatedScript += aScript.SubString(aSeq->Value(aLen) + 1, aScriptLength);
// Remove removed objects
if ( seqRemoved.Length() > 0 ) {
anUpdatedScript += "\n\t## some objects were removed";
anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()";
// import python files corresponding to plugins if they are used in anUpdatedScript
{
TCollection_AsciiString importStr;
std::vector<std::string> 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";
}
for (int ir = 1; ir <= seqRemoved.Length(); ir++) {
anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
anUpdatedScript += seqRemoved.Value(ir);
// for object wrapped by class of smesh.py
anEntry = theObjectNames( seqRemoved.Value(ir) );
if ( anEntry2AccessorMethod.IsBound( anEntry ) )
anUpdatedScript += helper + "." + anEntry2AccessorMethod( anEntry );
anUpdatedScript += "))\n\tif SO is not None: aStudyBuilder.RemoveObjectWithChildren(SO)";
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 aGUIName, aSetNameScriptPart;
Resource_DataMapOfAsciiStringAsciiString mapEntries;
for (Standard_Integer i = 1; i <= aLen; i += 2)
TCollection_AsciiString setNamePart;
Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString mapEntriesIt;
for ( mapEntriesIt.Initialize( mapEntries ); mapEntriesIt.More(); mapEntriesIt.Next() )
{
anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
aName = geom->GetDumpName( anEntry.ToCString() );
if (aName.IsEmpty() && // Not a GEOM object
theNames.IsBound(anEntry) &&
!aRemovedObjIDs.count(anEntry) && // a command creating anEntry was erased
!mapEntries.IsBound(anEntry) && // Not yet processed
!mapRemoved.IsBound(anEntry)) // Was not removed
anEntry = mapEntriesIt.Key();
aName = mapEntriesIt.Value(); // python name
if ( theNames.IsBound( anEntry ))
{
aName = theObjectNames.Find(anEntry);
aGUIName = theNames.Find(anEntry);
mapEntries.Bind(anEntry, aName);
aSetNameScriptPart += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
setNamePart += nt + aSMESHGen + ".SetName(" + aName;
if ( anEntry2AccessorMethod.IsBound( anEntry ) )
aSetNameScriptPart += helper + "." + anEntry2AccessorMethod( anEntry );
aSetNameScriptPart += helper + ", '" + aGUIName + "')";
setNamePart += helper + "." + anEntry2AccessorMethod( anEntry );
setNamePart += helper + ", '" + aGUIName + "')";
}
}
if ( !aSetNameScriptPart.IsEmpty() )
if ( !setNamePart.IsEmpty() )
{
anUpdatedScript += "\n\t## set object names";
anUpdatedScript += aSetNameScriptPart;
setNamePart.Insert( 1, nt + "## Set names of Mesh objects" );
}
// -----------------------------------------------------------------
// store visual properties of displayed objects
// -----------------------------------------------------------------
// Store visual properties of displayed objects
TCollection_AsciiString visualPropertiesPart;
if (isPublished)
{
//Output the script that sets up the visual parameters.
char* script = theStudy->GetDefaultScript(ComponentDataType(), "\t");
if (script && strlen(script) > 0) {
anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n";
anUpdatedScript += script;
CORBA::string_free(script);
CORBA::String_var compDataType = ComponentDataType();
CORBA::String_var script = theStudy->GetDefaultScript( compDataType.in(), tab.ToCString() );
if ( script.in() && script[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";
if( !isMultiFile ) // remove unnecessary tabulation
RemoveTabulation( anUpdatedScript );
// 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
@ -1106,7 +1240,7 @@ TCollection_AsciiString SMESH_Gen_i::GetNewPythonLines (int theStudyID)
Handle(TColStd_HSequenceOfAsciiString) aPythonScript = myPythonScripts[theStudyID];
Standard_Integer istr, aLen = aPythonScript->Length();
for (istr = 1; istr <= aLen; istr++) {
aScript += "\n\t";
aScript += "\n";
aScript += aPythonScript->Value(istr);
}
aScript += "\n";

2
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -458,7 +458,7 @@ public:
bool isMultiFile,
bool isHistoricalDump,
bool& aValidScript,
const TCollection_AsciiString& theSavedTrace);
TCollection_AsciiString& theSavedTrace);
TCollection_AsciiString GetNewPythonLines (int theStudyID);

5
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -459,6 +459,11 @@ SMESH::SMESH_IDSource_ptr SMESH_MeshEditor_i::MakeIDSource(const SMESH::long_arr
return anIDSourceVar._retn();
}
bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource )
{
return SMESH::DownCast<_IDSource*>( idSource );
}
//=============================================================================
/*!
*

2
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -55,6 +55,8 @@ public:
*/
SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements,
SMESH::ElementType type);
static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource );
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
CORBA::Boolean RemoveNodes(const SMESH::long_array & IDsOfNodes);
CORBA::Long RemoveOrphanNodes();

11
src/SMESH_I/SMESH_NoteBook.cxx
View File

@ -863,6 +863,17 @@ TCollection_AsciiString SMESH_NoteBook::GetResultScript() const
return aResult;
}
//================================================================================
/*!
* \brief Return lines of the result script
*/
//================================================================================
void SMESH_NoteBook::GetResultLines(std::list< TCollection_AsciiString >& lines) const
{
for(int i=0;i<_commands.size();i++)
lines.push_back( _commands[i]->GetString() );
}
//================================================================================
/*!
* \brief Return value of the variable

1
src/SMESH_I/SMESH_NoteBook.hxx
View File

@ -92,6 +92,7 @@ public:
void AddCommand(const TCollection_AsciiString& theString);
TCollection_AsciiString GetResultScript() const;
void GetResultLines(std::list< TCollection_AsciiString >& lines) const;
private:
void InitObjectMap();

11
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -29,13 +29,15 @@
#include CORBA_SERVER_HEADER(SMESH_Mesh)
#include CORBA_SERVER_HEADER(SALOMEDS)
#include <TCollection_AsciiString.hxx>
#include <sstream>
#include <vector>
#include <set>
#include <list>
class SMESH_Gen_i;
class SMESH_MeshEditor_i;
class TCollection_AsciiString;
class Resource_DataMapOfAsciiStringAsciiString;
// ===========================================================================================
@ -46,8 +48,9 @@ class Resource_DataMapOfAsciiStringAsciiString;
*/
// ===========================================================================================
namespace SMESH_2smeshpy
class SMESH_2smeshpy
{
public:
/*!
* \brief Convert a python script using commands of smeshBuilder.py
* \param theScript - the Input script to convert
@ -59,8 +62,8 @@ namespace SMESH_2smeshpy
* to exclude commands relating to objects removed from study
* \retval TCollection_AsciiString - Convertion result
*/
void
ConvertScript(TCollection_AsciiString& theScript,
static void
ConvertScript(std::list< TCollection_AsciiString >& theScriptLines,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,