mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2025-01-13 02:00:34 +05:00
22318: [CEA] Problems with study dump in SMESH
Memory usage and performance optimization: do not make a script from lines and than split it back into lines several times.
This commit is contained in:
eap
parent
0e557488d2
commit
7ba6caead5
@ -183,7 +183,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 ))
|
||||
@ -198,7 +199,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 ) )
|
||||
{
|
||||
@ -444,7 +450,7 @@ namespace {
|
||||
//================================================================================
|
||||
/*!
|
||||
* \brief Convert a python script using commands of smeshBuilder.py
|
||||
* \param theScript - Input script
|
||||
* \param theScriptLines - Lines of the input script
|
||||
* \param theEntry2AccessorMethod - returns method names to access to
|
||||
* objects wrapped with python class
|
||||
* \param theObjectNames - names of objects
|
||||
@ -456,30 +462,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
|
||||
@ -490,16 +492,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();
|
||||
@ -535,12 +531,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();
|
||||
@ -643,17 +637,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
|
||||
@ -695,8 +695,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]
|
||||
@ -718,8 +717,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 )
|
||||
@ -981,11 +978,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" )
|
||||
@ -1053,7 +1050,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, ...], ... )
|
||||
@ -1149,10 +1146,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 );
|
||||
@ -1167,23 +1169,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 );
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
@ -1203,9 +1205,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();
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
@ -1500,20 +1508,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;
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
@ -1984,7 +1999,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();
|
||||
}
|
||||
@ -3445,7 +3460,7 @@ bool _pyAlgorithm::Addition2Creation( const Handle(_pyCommand)& theCmd,
|
||||
*/
|
||||
//================================================================================
|
||||
|
||||
int _pyCommand::GetBegPos( int thePartIndex )
|
||||
int _pyCommand::GetBegPos( int thePartIndex ) const
|
||||
{
|
||||
if ( IsEmpty() )
|
||||
return EMPTY;
|
||||
@ -3485,7 +3500,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 ));
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
@ -3525,16 +3540,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();
|
||||
}
|
||||
|
||||
|
||||
@ -3545,32 +3552,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
|
||||
*/
|
||||
//================================================================================
|
||||
|
||||
@ -3753,6 +3766,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
|
||||
@ -3867,11 +3898,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;
|
||||
@ -4038,9 +4068,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 );
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4088,7 +4118,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) {
|
||||
@ -4105,7 +4136,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;
|
||||
}
|
||||
@ -4180,7 +4211,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)
|
||||
*/
|
||||
//================================================================================
|
||||
|
||||
@ -4193,11 +4225,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
|
||||
@ -4205,23 +4238,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();
|
||||
@ -4576,10 +4641,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" )
|
||||
{
|
||||
@ -4909,31 +4976,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;
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
@ -4947,7 +5025,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() );
|
||||
@ -4964,20 +5042,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;
|
||||
}
|
||||
|
||||
//================================================================================
|
||||
|
||||
@ -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)
|
||||
};
|
||||
|
||||
@ -34,9 +34,10 @@
|
||||
|
||||
#include <SALOMEDS_wrap.hxx>
|
||||
|
||||
#include <LDOMParser.hxx>
|
||||
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
|
||||
#include <TColStd_HSequenceOfInteger.hxx>
|
||||
#include <TCollection_AsciiString.hxx>
|
||||
#include <LDOMParser.hxx>
|
||||
|
||||
#ifdef _DEBUG_
|
||||
static int MYDEBUG = 0;
|
||||
@ -44,6 +45,8 @@ static int MYDEBUG = 0;
|
||||
static int MYDEBUG = 0;
|
||||
#endif
|
||||
|
||||
#include "SMESH_TryCatch.hxx"
|
||||
|
||||
namespace SMESH
|
||||
{
|
||||
|
||||
@ -343,8 +346,12 @@ namespace SMESH
|
||||
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;
|
||||
return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
|
||||
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;
|
||||
}
|
||||
@ -613,6 +620,13 @@ namespace SMESH
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void printException( const char* text )
|
||||
{
|
||||
#ifdef _DEBUG_
|
||||
cout << "Exception in SMESH_Gen_i::DumpPython(): " << text << endl;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
@ -655,7 +669,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_wrap Itr = aStudy->NewChildIterator(aSO);
|
||||
for (Itr->InitEx(true); Itr->More(); Itr->Next()) {
|
||||
@ -663,10 +676,10 @@ 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 );
|
||||
}
|
||||
}
|
||||
|
||||
@ -816,23 +829,32 @@ 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;
|
||||
}
|
||||
@ -888,11 +910,22 @@ namespace {
|
||||
}
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
//================================================================================
|
||||
/*!
|
||||
* 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,
|
||||
Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
|
||||
@ -901,81 +934,75 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
|
||||
bool isMultiFile,
|
||||
bool isHistoricalDump,
|
||||
bool& aValidScript,
|
||||
const TCollection_AsciiString& theSavedTrace)
|
||||
TCollection_AsciiString& theSavedTrace)
|
||||
{
|
||||
int aStudyID = theStudy->StudyId();
|
||||
SMESH_TRY;
|
||||
const 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";
|
||||
std::list< TCollection_AsciiString > lines; // lines of a script
|
||||
std::list< TCollection_AsciiString >::iterator linesIt;
|
||||
|
||||
if ( isPublished )
|
||||
aScript += aSMESHGen + " = smeshBuilder.New(theStudy)\n\t";
|
||||
else
|
||||
aScript += aSMESHGen + " = smeshBuilder.New(None)\n\t";
|
||||
aScript += helper + "aFilterManager = " + aSMESHGen + ".CreateFilterManager()\n\t";
|
||||
aScript += helper + "aMeasurements = " + aSMESHGen + ".CreateMeasurements()\n\t";
|
||||
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()" );
|
||||
|
||||
// Dump trace of restored study
|
||||
if (theSavedTrace.Length() > 0) {
|
||||
// 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() );
|
||||
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();
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
// import python files corresponding to plugins if they are used in aScript
|
||||
{
|
||||
TCollection_AsciiString importStr;
|
||||
std::vector<std::string> pluginNames = getPluginNames();
|
||||
for ( size_t i = 0; i < pluginNames.size(); ++i )
|
||||
theSavedTrace.Clear();
|
||||
if ( !isNewVersion )
|
||||
{
|
||||
// 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 = aScript.Location( pluginAccess, iFrom, aScript.Length() )))
|
||||
const TCollection_AsciiString aSmeshCall ( "smesh." ), gen( "gen" );
|
||||
int beg, end, from;
|
||||
for ( ++linesIt; linesIt != lines.end(); ++linesIt )
|
||||
{
|
||||
aScript.Insert( iPos + pluginNames[i].size(), "Builder" );
|
||||
iFrom = iPos + pluginNames[i].size() + 8;
|
||||
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();
|
||||
}
|
||||
}
|
||||
// if any plugin member is used, import the plugin
|
||||
if ( iFrom > 1 )
|
||||
importStr += ( helper + "\n\t" + "from salome." + (char*) pluginNames[i].c_str() +
|
||||
" import " + (char*) pluginNames[i].c_str() +"Builder" );
|
||||
}
|
||||
if ( !importStr.IsEmpty() )
|
||||
aScript.Insert( 1, importStr + "\n\t" );
|
||||
}
|
||||
|
||||
// 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.
|
||||
@ -984,89 +1011,111 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
|
||||
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 += "salome, ";
|
||||
initPart += " SMESH, SALOMEDS\n";
|
||||
initPart += "from salome.smesh import smeshBuilder\n";
|
||||
if ( importGeom && isMultiFile )
|
||||
@ -1076,78 +1125,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 smeshBuilder.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.
|
||||
CORBA::String_var compDataType = ComponentDataType();
|
||||
char* script = theStudy->GetDefaultScript( compDataType.in(), "\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 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
|
||||
@ -1206,6 +1277,11 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
|
||||
aValidScript = true;
|
||||
|
||||
return anUpdatedScript;
|
||||
|
||||
SMESH_CATCH( SMESH::printException );
|
||||
|
||||
aValidScript = false;
|
||||
return "";
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
@ -1222,7 +1298,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";
|
||||
|
||||
@ -478,7 +478,7 @@ public:
|
||||
bool isMultiFile,
|
||||
bool isHistoricalDump,
|
||||
bool& aValidScript,
|
||||
const TCollection_AsciiString& theSavedTrace);
|
||||
TCollection_AsciiString& theSavedTrace);
|
||||
|
||||
TCollection_AsciiString GetNewPythonLines (int theStudyID);
|
||||
|
||||
|
||||
@ -934,6 +934,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
|
||||
@ -965,4 +976,3 @@ bool SMESH_NoteBook::GetReal(const TCollection_AsciiString& theVarName, double&
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
@ -91,6 +91,7 @@ public:
|
||||
|
||||
void AddCommand(const TCollection_AsciiString& theString);
|
||||
TCollection_AsciiString GetResultScript() const;
|
||||
void GetResultLines(std::list< TCollection_AsciiString >& lines) const;
|
||||
|
||||
private:
|
||||
|
||||
|
||||
@ -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,
|
||||
|
||||
Loading…
Reference in New Issue
Block a user