ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-11 00:23:06 +05:00
Code Issues Packages Projects Releases Wiki Activity

0022163: SMESH produces study dump with syntax errors

Browse Source 
Merge the patch from V6_main to V6_7_BR
This commit is contained in:
eap 2013-06-20 09:15:42 +00:00
parent 5f1c6e5660
commit 7f5036e20c
4 changed files with 252 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
src/SMESH_I/SMESH_2smeshpy.cxx
View File

@ -26,11 +26,12 @@
// //
#include "SMESH_2smeshpy.hxx" #include "SMESH_2smeshpy.hxx"
#include "utilities.h"
#include "SMESH_PythonDump.hxx" #include "SMESH_PythonDump.hxx"
#include "SMESH_NoteBook.hxx" #include "SMESH_NoteBook.hxx"
#include "SMESH_Filter_i.hxx" #include "SMESH_Filter_i.hxx"
#include <utilities.h>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx> #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
#include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx> #include <Resource_DataMapIteratorOfDataMapOfAsciiStringAsciiString.hxx>
@ -177,6 +178,24 @@ namespace {
void CheckObjectPresence( const Handle(_pyCommand)& cmd, set<_pyID> & presentObjects) void CheckObjectPresence( const Handle(_pyCommand)& cmd, set<_pyID> & presentObjects)
{ {
// either comment or erase a command including NotPublishedObjectName()
if ( cmd->GetString().Location( TPythonDump::NotPublishedObjectName(), 1, cmd->Length() ))
{
bool isResultPublished = false;
for ( int i = 0; i < cmd->GetNbResultValues(); i++ )
{
_pyID objID = cmd->GetResultValue( i+1 );
if ( cmd->IsStudyEntry( objID ))
isResultPublished = (! theGen->IsNotPublished( objID ));
theGen->ObjectCreationRemoved( objID ); // objID.SetName( name ) is not needed
}
if ( isResultPublished )
cmd->Comment();
else
cmd->Clear();
return;
}
// comment a command having not created args
for ( int iArg = cmd->GetNbArgs(); iArg; --iArg ) for ( int iArg = cmd->GetNbArgs(); iArg; --iArg )
{ {
const _pyID& arg = cmd->GetArg( iArg ); const _pyID& arg = cmd->GetArg( iArg );
@ -190,14 +209,23 @@ namespace {
cmd->Comment(); cmd->Comment();
cmd->GetString() += " ### " ; cmd->GetString() += " ### " ;
cmd->GetString() += *id + " has not been yet created"; cmd->GetString() += *id + " has not been yet created";
for ( int i = 0; i < cmd->GetNbResultValues(); i++ ) {
_pyID objID = cmd->GetResultValue( i+1 );
theGen->ObjectCreationRemoved( objID ); // objID.SetName( name ) is not needed
}
return; return;
} }
} }
// comment a command having not created Object
const _pyID& obj = cmd->GetObject(); const _pyID& obj = cmd->GetObject();
if ( !obj.IsEmpty() && cmd->IsStudyEntry( obj ) && !presentObjects.count( obj )) if ( !obj.IsEmpty() && cmd->IsStudyEntry( obj ) && !presentObjects.count( obj ))
{ {
cmd->Comment(); cmd->Comment();
cmd->GetString() += " ### not created object" ; cmd->GetString() += " ### not created object" ;
for ( int i = 0; i < cmd->GetNbResultValues(); i++ ) {
_pyID objID = cmd->GetResultValue( i+1 );
theGen->ObjectCreationRemoved( objID ); // objID.SetName( name ) is not needed
}
} }
const _pyID& result = cmd->GetResultValue(); const _pyID& result = cmd->GetResultValue();
if ( result.IsEmpty() || result.Value( 1 ) == '"' || result.Value( 1 ) == '\'' ) if ( result.IsEmpty() || result.Value( 1 ) == '"' || result.Value( 1 ) == '\'' )
@ -254,6 +282,8 @@ namespace {
// - FT_EqualVolumes = 17 // - FT_EqualVolumes = 17
// v 6.6.0: FT_Undefined == 44, new items: // v 6.6.0: FT_Undefined == 44, new items:
// - FT_BallDiameter = 37 // - FT_BallDiameter = 37
// v 6.7.1: FT_Undefined == 45, new items:
// - FT_EntityType = 36
// //
// It's necessary to continue recording this history and to fill // It's necessary to continue recording this history and to fill
// undef2newItems (see below) accordingly. // undef2newItems (see below) accordingly.
@ -273,6 +303,8 @@ namespace {
undef2newItems[ 43 ].assign( items, items+4 ); } undef2newItems[ 43 ].assign( items, items+4 ); }
{ int items[] = { 37 }; { int items[] = { 37 };
undef2newItems[ 44 ].assign( items, items+1 ); } undef2newItems[ 44 ].assign( items, items+1 ); }
{ int items[] = { 36 };
undef2newItems[ 45 ].assign( items, items+1 ); }
} }
int iType = Type.IntegerValue(); int iType = Type.IntegerValue();
@ -312,13 +344,15 @@ namespace {
//================================================================================ //================================================================================
/*! /*!
* \brief Convert python script using commands of smesh.py * \brief Convert a python script using commands of smesh.py
* \param theScript - Input script * \param theScript - Input script
* \retval TCollection_AsciiString - Convertion result * \param theEntry2AccessorMethod - returns method names to access to
* \param theToKeepAllCommands - to keep all commands or * objects wrapped with python class
* to exclude commands relating to objects removed from study * \param theObjectNames - names of objects
* * \param theRemovedObjIDs - entries of objects whose created commands were removed
* Class SMESH_2smeshpy declared in SMESH_PythonDump.hxx * \param theHistoricalDump - true means to keep all commands, false means
* to exclude commands relating to objects removed from study
* \retval TCollection_AsciiString - Convertion result
*/ */
//================================================================================ //================================================================================
@ -326,10 +360,15 @@ TCollection_AsciiString
SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript, SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScript,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy, SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands) const bool theToKeepAllCommands)
{ {
theGen = new _pyGen( theEntry2AccessorMethod, theObjectNames, theStudy, theToKeepAllCommands ); theGen = new _pyGen( theEntry2AccessorMethod,
theObjectNames,
theRemovedObjIDs,
theStudy,
theToKeepAllCommands );
// split theScript into separate commands // split theScript into separate commands
@ -339,9 +378,9 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScrip
while ( from < end && ( to = theScript.Location( "\n", from, end ))) while ( from < end && ( to = theScript.Location( "\n", from, end )))
{ {
if ( to != from ) if ( to != from )
// cut out and store a command // cut out and store a command
aNoteBook->AddCommand( theScript.SubString( from, to - 1 )); aNoteBook->AddCommand( theScript.SubString( from, to - 1 ));
from = to + 1; from = to + 1;
} }
aNoteBook->ReplaceVariables(); aNoteBook->ReplaceVariables();
@ -410,12 +449,14 @@ SMESH_2smeshpy::ConvertScript(const TCollection_AsciiString& theScrip
_pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, _pyGen::_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy, SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands) const bool theToKeepAllCommands)
: _pyObject( new _pyCommand( "", 0 )), : _pyObject( new _pyCommand( "", 0 )),
myNbCommands( 0 ), myNbCommands( 0 ),
myID2AccessorMethod( theEntry2AccessorMethod ), myID2AccessorMethod( theEntry2AccessorMethod ),
myObjectNames( theObjectNames ), myObjectNames( theObjectNames ),
myRemovedObjIDs( theRemovedObjIDs ),
myNbFilters( 0 ), myNbFilters( 0 ),
myToKeepAllCommands( theToKeepAllCommands ), myToKeepAllCommands( theToKeepAllCommands ),
myStudy( SALOMEDS::Study::_duplicate( theStudy )), myStudy( SALOMEDS::Study::_duplicate( theStudy )),
@ -658,7 +699,7 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
// 1 2 3 4 5 6 7 8 9 10 // 1 2 3 4 5 6 7 8 9 10
// in order to avoid the problem of type mismatch of long and FunctorType // in order to avoid the problem of type mismatch of long and FunctorType
const TCollection_AsciiString const TCollection_AsciiString
SMESH("SMESH."), dfltFunctor = "SMESH.FT_Undefined", dftlTol = "1e-07", dftlPreci = "-1"; SMESH("SMESH."), dfltFunctor("SMESH.FT_Undefined"), dftlTol("1e-07"), dftlPreci("-1");
TCollection_AsciiString TCollection_AsciiString
Type = aCommand->GetArg(1), // long Type = aCommand->GetArg(1), // long
Compare = aCommand->GetArg(2), // long Compare = aCommand->GetArg(2), // long
@ -684,17 +725,34 @@ Handle(_pyCommand) _pyGen::AddCommand( const TCollection_AsciiString& theCommand
aCommand->SetArg( 2, Type ); aCommand->SetArg( 2, Type );
aCommand->SetArg( 3, Compare ); aCommand->SetArg( 3, Compare );
if ( Type == "SMESH.FT_ElemGeomType" && Threshold.IsIntegerValue() ) if ( Threshold.IsIntegerValue() )
{ {
// set SMESH.GeometryType instead of a numerical Threshold
const char* types[SMESH::Geom_BALL+1] = {
"Geom_POINT", "Geom_EDGE", "Geom_TRIANGLE", "Geom_QUADRANGLE", "Geom_POLYGON",
"Geom_TETRA", "Geom_PYRAMID", "Geom_HEXA", "Geom_PENTA", "Geom_HEXAGONAL_PRISM",
"Geom_POLYHEDRA", "Geom_BALL"
};
int iGeom = Threshold.IntegerValue(); int iGeom = Threshold.IntegerValue();
if ( -1 < iGeom && iGeom < SMESH::Geom_POLYHEDRA+1 ) if ( Type == "SMESH.FT_ElemGeomType" )
Threshold = SMESH + types[ iGeom ]; {
// set SMESH.GeometryType instead of a numerical Threshold
const char* types[SMESH::Geom_BALL+1] = {
"Geom_POINT", "Geom_EDGE", "Geom_TRIANGLE", "Geom_QUADRANGLE", "Geom_POLYGON",
"Geom_TETRA", "Geom_PYRAMID", "Geom_HEXA", "Geom_PENTA", "Geom_HEXAGONAL_PRISM",
"Geom_POLYHEDRA", "Geom_BALL" };
if ( -1 < iGeom && iGeom < SMESH::Geom_POLYHEDRA+1 )
Threshold = SMESH + types[ iGeom ];
}
if (Type == "SMESH.FT_EntityType")
{
// set SMESH.EntityType instead of a numerical Threshold
const char* types[SMESH::Entity_Ball+1] = {
"Entity_Node", "Entity_0D", "Entity_Edge", "Entity_Quad_Edge",
"Entity_Triangle", "Entity_Quad_Triangle",
"Entity_Quadrangle", "Entity_Quad_Quadrangle", "Entity_BiQuad_Quadrangle",
"Entity_Polygon", "Entity_Quad_Polygon", "Entity_Tetra", "Entity_Quad_Tetra",
"Entity_Pyramid", "Entity_Quad_Pyramid",
"Entity_Hexa", "Entity_Quad_Hexa", "Entity_TriQuad_Hexa",
"Entity_Penta", "Entity_Quad_Penta", "Entity_Hexagonal_Prism",
"Entity_Polyhedra", "Entity_Quad_Polyhedra", "Entity_Ball" };
if ( -1 < iGeom && iGeom < SMESH::Entity_Quad_Polyhedra+1 )
Threshold = SMESH + types[ iGeom ];
}
} }
if ( ThresholdID.Length() != 2 && ThresholdStr.Length() != 2) // not '' or "" if ( ThresholdID.Length() != 2 && ThresholdStr.Length() != 2) // not '' or ""
aCommand->SetArg( 4, ThresholdID.SubString( 2, ThresholdID.Length()-1 )); // shape entry aCommand->SetArg( 4, ThresholdID.SubString( 2, ThresholdID.Length()-1 )); // shape entry
@ -764,13 +822,21 @@ void _pyGen::Process( const Handle(_pyCommand)& theCommand )
method == "CreateMeshesFromSAUV"|| method == "CreateMeshesFromSAUV"||
method == "CreateMeshesFromGMF" ) method == "CreateMeshesFromGMF" )
{ {
for(int ind = 0;ind<theCommand->GetNbResultValues();ind++) for ( int ind = 0; ind < theCommand->GetNbResultValues(); ind++ )
{ {
_pyID meshID = theCommand->GetResultValue(ind+1); _pyID meshID = theCommand->GetResultValue(ind+1);
if ( !theCommand->IsStudyEntry( meshID ) ) continue; if ( !theCommand->IsStudyEntry( meshID ) ) continue;
Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1)); Handle(_pyMesh) mesh = new _pyMesh( theCommand, theCommand->GetResultValue(ind+1));
myMeshes.insert( make_pair( mesh->GetID(), mesh )); myMeshes.insert( make_pair( mesh->GetID(), mesh ));
} }
if ( method == "CreateMeshesFromGMF" )
{
// CreateMeshesFromGMF( theFileName, theMakeRequiredGroups ) ->
// CreateMeshesFromGMF( theFileName )
_AString file = theCommand->GetArg(1);
theCommand->RemoveArgs();
theCommand->SetArg( 1, file );
}
} }
// CreateHypothesis() // CreateHypothesis()
@ -1337,6 +1403,19 @@ bool _pyGen::IsNotPublished(const _pyID& theObjID) const
return true; // SMESH object not in study return true; // SMESH object not in study
} }
//================================================================================
/*!
* \brief Remove object name from myObjectNames that leads to that SetName() for
* this object is not dumped
* \param [in] theObjID - entry of the object whose creation command was eliminated
*/
//================================================================================
void _pyGen::ObjectCreationRemoved(const _pyID& theObjID)
{
myRemovedObjIDs.insert( theObjID );
}
//================================================================================ //================================================================================
/*! /*!
* \brief Return reader of hypotheses of plugins * \brief Return reader of hypotheses of plugins
@ -1569,7 +1648,7 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED() method == "ExportToMEDX" ) { // ExportToMEDX() --> ExportMED()
theCommand->SetMethod( "ExportMED" ); theCommand->SetMethod( "ExportMED" );
} }
else if ( method == "ExportCGNS" || method == "ExportGMF" ) else if ( method == "ExportCGNS" )
{ // ExportCGNS(part, ...) -> ExportCGNS(..., part) { // ExportCGNS(part, ...) -> ExportCGNS(..., part)
_pyID partID = theCommand->GetArg( 1 ); _pyID partID = theCommand->GetArg( 1 );
int nbArgs = theCommand->GetNbArgs(); int nbArgs = theCommand->GetNbArgs();
@ -1577,6 +1656,14 @@ void _pyMesh::Process( const Handle(_pyCommand)& theCommand )
theCommand->SetArg( i-1, theCommand->GetArg( i )); theCommand->SetArg( i-1, theCommand->GetArg( i ));
theCommand->SetArg( nbArgs, partID ); theCommand->SetArg( nbArgs, partID );
} }
else if ( method == "ExportGMF" )
{ // ExportGMF(part,file,bool) -> ExportCGNS(file, part)
_pyID partID = theCommand->GetArg( 1 );
_AString file = theCommand->GetArg( 2 );
theCommand->RemoveArgs();
theCommand->SetArg( 1, file );
theCommand->SetArg( 2, partID );
}
else if ( theCommand->MethodStartsFrom( "ExportPartTo" )) else if ( theCommand->MethodStartsFrom( "ExportPartTo" ))
{ // ExportPartTo*(part, ...) -> Export*(..., part) { // ExportPartTo*(part, ...) -> Export*(..., part)
// //
@ -2033,6 +2120,13 @@ void _pyMeshEditor::Process( const Handle(_pyCommand)& theCommand)
if (( isPyMeshMethod = ( newMethod.Length() > 0 ))) if (( isPyMeshMethod = ( newMethod.Length() > 0 )))
theCommand->SetMethod( newMethod ); theCommand->SetMethod( newMethod );
} }
// ConvertToBiQuadratic(...) -> ConvertToQuadratic(...,True)
if ( !isPyMeshMethod && (method == "ConvertToBiQuadratic" || method == "ConvertToBiQuadraticObject") )
{
isPyMeshMethod = true;
theCommand->SetMethod( method.SubString( 1, 9) + method.SubString( 12, method.Length()));
theCommand->SetArg( theCommand->GetNbArgs() + 1, "True" );
}
if ( !isPyMeshMethod ) if ( !isPyMeshMethod )
{ {
@ -3138,22 +3232,21 @@ const TCollection_AsciiString & _pyCommand::GetResultValue()
//================================================================================ //================================================================================
/*! /*!
* \brief Return number of python command result value ResultValue = Obj.Meth() * \brief Return number of python command result value ResultValue = Obj.Meth()
* \retval const int
*/ */
//================================================================================ //================================================================================
const int _pyCommand::GetNbResultValues() int _pyCommand::GetNbResultValues()
{ {
int nb = 0;
int begPos = 1; int begPos = 1;
int Nb=0;
int endPos = myString.Location( "=", 1, Length() ); int endPos = myString.Location( "=", 1, Length() );
TCollection_AsciiString str = ""; while ( begPos < endPos )
while ( begPos < endPos) { {
str = GetWord( myString, begPos, true ); _AString str = GetWord( myString, begPos, true );
begPos = begPos+ str.Length(); begPos = begPos+ str.Length();
Nb++; nb++;
} }
return (Nb-1); return (nb-1);
} }
@ -3591,7 +3684,7 @@ void _pyCommand::SetArg( int index, const TCollection_AsciiString& theArg)
void _pyCommand::RemoveArgs() void _pyCommand::RemoveArgs()
{ {
if ( int pos = myString.Location( '(', 1, Length() )) if ( int pos = myString.Location( '(', Max( 1, GetBegPos( METHOD_IND )), Length() ))
myString.Trunc( pos ); myString.Trunc( pos );
myString += ")"; myString += ")";
myArgs.Clear(); myArgs.Clear();

35
src/SMESH_I/SMESH_2smeshpy.hxx
View File

@ -123,7 +123,7 @@ public:
bool IsEmpty() const { return myString.IsEmpty(); } bool IsEmpty() const { return myString.IsEmpty(); }
_AString GetIndentation(); _AString GetIndentation();
const _AString & GetResultValue(); const _AString & GetResultValue();
const int GetNbResultValues(); int GetNbResultValues();
_AString GetResultValue(int res); _AString GetResultValue(int res);
const _AString & GetObject(); const _AString & GetObject();
const _AString & GetMethod(); const _AString & GetMethod();
@ -223,6 +223,7 @@ class _pyGen: public _pyObject
public: public:
_pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, _pyGen(Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy, SALOMEDS::Study_ptr& theStudy,
const bool theToKeepAllCommands); const bool theToKeepAllCommands);
Handle(_pyCommand) AddCommand( const _AString& theCommand ); Handle(_pyCommand) AddCommand( const _AString& theCommand );
@ -236,8 +237,8 @@ public:
_pyID GenerateNewID( const _pyID& theID ); _pyID GenerateNewID( const _pyID& theID );
void AddObject( Handle(_pyObject)& theObj ); void AddObject( Handle(_pyObject)& theObj );
void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj ); void SetProxyObject( const _pyID& theID, Handle(_pyObject)& theObj );
Handle(_pyObject) FindObject( const _pyID& theObjID ) const; Handle(_pyObject) FindObject( const _pyID& theObjID ) const;
Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID ); Handle(_pySubMesh) FindSubMesh( const _pyID& theSubMeshID );
Handle(_pyHypothesis) FindHyp( const _pyID& theHypID ); Handle(_pyHypothesis) FindHyp( const _pyID& theHypID );
Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh, Handle(_pyHypothesis) FindAlgo( const _pyID& theGeom, const _pyID& theMesh,
const Handle(_pyHypothesis)& theHypothesis); const Handle(_pyHypothesis)& theHypothesis);
@ -249,6 +250,7 @@ public:
bool IsGeomObject(const _pyID& theObjID) const; bool IsGeomObject(const _pyID& theObjID) const;
bool IsNotPublished(const _pyID& theObjID) const; bool IsNotPublished(const _pyID& theObjID) const;
void ObjectCreationRemoved(const _pyID& theObjID);
bool IsToKeepAllCommands() const { return myToKeepAllCommands; } bool IsToKeepAllCommands() const { return myToKeepAllCommands; }
void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh ) void AddExportedMesh(const _AString& file, const ExportedMeshData& mesh )
{ myFile2ExportedMesh[ file ] = mesh; } { myFile2ExportedMesh[ file ] = mesh; }
@ -268,21 +270,22 @@ private:
const bool theIsAfter ); const bool theIsAfter );
private: private:
std::map< _pyID, Handle(_pyMesh) > myMeshes; std::map< _pyID, Handle(_pyMesh) > myMeshes;
std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors; std::map< _pyID, Handle(_pyMeshEditor) > myMeshEditors;
std::map< _pyID, Handle(_pyObject) > myObjects; std::map< _pyID, Handle(_pyObject) > myObjects;
std::list< Handle(_pyHypothesis) > myHypos; std::list< Handle(_pyHypothesis) > myHypos;
std::list< Handle(_pyCommand) > myCommands; std::list< Handle(_pyCommand) > myCommands;
int myNbCommands; int myNbCommands;
Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod; Resource_DataMapOfAsciiStringAsciiString& myID2AccessorMethod;
Resource_DataMapOfAsciiStringAsciiString& myObjectNames; Resource_DataMapOfAsciiStringAsciiString& myObjectNames;
Handle(_pyCommand) myLastCommand; std::set< TCollection_AsciiString >& myRemovedObjIDs;
int myNbFilters; Handle(_pyCommand) myLastCommand;
bool myToKeepAllCommands; int myNbFilters;
SALOMEDS::Study_var myStudy; bool myToKeepAllCommands;
int myGeomIDNb, myGeomIDIndex; SALOMEDS::Study_var myStudy;
std::map< _AString, ExportedMeshData > myFile2ExportedMesh; int myGeomIDNb, myGeomIDIndex;
Handle( _pyHypothesisReader ) myHypReader; std::map< _AString, ExportedMeshData > myFile2ExportedMesh;
Handle( _pyHypothesisReader ) myHypReader;
DEFINE_STANDARD_RTTI (_pyGen) DEFINE_STANDARD_RTTI (_pyGen)
}; };

143
src/SMESH_I/SMESH_DumpPython.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -25,15 +25,15 @@
// Module : SMESH // Module : SMESH
#include "SMESH_PythonDump.hxx" #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 <TColStd_HSequenceOfInteger.hxx> #include <TColStd_HSequenceOfInteger.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <SMESH_Comment.hxx>
#ifdef _DEBUG_ #ifdef _DEBUG_
static int MYDEBUG = 0; static int MYDEBUG = 0;
@ -41,15 +41,11 @@ static int MYDEBUG = 0;
static int MYDEBUG = 0; static int MYDEBUG = 0;
#endif #endif
static TCollection_AsciiString NotPublishedObjectName()
{
return "__NOT__Published__Object__";
}
namespace SMESH namespace SMESH
{ {
size_t TPythonDump::myCounter = 0; size_t TPythonDump::myCounter = 0;
const char theNotPublishedObjectName[] = "__NOT__Published__Object__";
TVar::TVar(CORBA::Double value):myVals(1) { myVals[0] = SMESH_Comment(value); } TVar::TVar(CORBA::Double value):myVals(1) { myVals[0] = SMESH_Comment(value); }
TVar::TVar(CORBA::Long value):myVals(1) { myVals[0] = SMESH_Comment(value); } TVar::TVar(CORBA::Long value):myVals(1) { myVals[0] = SMESH_Comment(value); }
@ -72,7 +68,7 @@ namespace SMESH
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
std::string aString = myStream.str(); std::string aString = myStream.str();
TCollection_AsciiString aCollection(Standard_CString(aString.c_str())); TCollection_AsciiString aCollection(Standard_CString(aString.c_str()));
SALOMEDS::Study_ptr aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
if(!aStudy->_is_nil() && !aCollection.IsEmpty()){ if(!aStudy->_is_nil() && !aCollection.IsEmpty()){
aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection); aSMESHGen->AddToPythonScript(aStudy->StudyId(),aCollection);
if(MYDEBUG) MESSAGE(aString); if(MYDEBUG) MESSAGE(aString);
@ -194,6 +190,40 @@ namespace SMESH
} }
return *this; return *this;
} }
TPythonDump&
TPythonDump::
operator<<(const SMESH::EntityType& theArg)
{
myStream<<"SMESH.";
switch(theArg){
case Entity_0D: myStream<<"Entity_0D"; break;
case Entity_Edge: myStream<<"Entity_Edge"; break;
case Entity_Quad_Edge: myStream<<"Entity_Quad_Edge"; break;
case Entity_Triangle: myStream<<"Entity_Triangle"; break;
case Entity_Quad_Triangle: myStream<<"Entity_Quad_Triangle"; break;
case Entity_Quadrangle: myStream<<"Entity_Quadrangle"; break;
case Entity_Quad_Quadrangle: myStream<<"Entity_Quad_Quadrangle"; break;
case Entity_BiQuad_Quadrangle: myStream<<"Entity_BiQuad_Quadrangle"; break;
case Entity_Polygon: myStream<<"Entity_Polygon"; break;
case Entity_Quad_Polygon: myStream<<"Entity_Quad_Polygon"; break;
case Entity_Tetra: myStream<<"Entity_Tetra"; break;
case Entity_Quad_Tetra: myStream<<"Entity_Quad_Tetra"; break;
case Entity_Pyramid: myStream<<"Entity_Pyramid"; break;
case Entity_Quad_Pyramid: myStream<<"Entity_Quad_Pyramid"; break;
case Entity_Hexa: myStream<<"Entity_Hexa"; break;
case Entity_Quad_Hexa: myStream<<"Entity_Quad_Hexa"; break;
case Entity_TriQuad_Hexa: myStream<<"Entity_TriQuad_Hexa"; break;
case Entity_Penta: myStream<<"Entity_Penta"; break;
case Entity_Quad_Penta: myStream<<"Entity_Quad_Penta"; break;
case Entity_Hexagonal_Prism: myStream<<"Entity_Hexagonal_Prism"; break;
case Entity_Polyhedra: myStream<<"Entity_Polyhedra"; break;
case Entity_Quad_Polyhedra: myStream<<"Entity_Quad_Polyhedra"; break;
case Entity_Ball: myStream<<"Entity_Ball"; break;
case Entity_Last: myStream<<"Entity_Last"; break;
default: myStream<<"__UNKNOWN__EntityType: " << theArg;
}
return *this;
}
template<class TArray> template<class TArray>
void DumpArray(const TArray& theArray, TPythonDump & theStream) void DumpArray(const TArray& theArray, TPythonDump & theStream)
@ -238,10 +268,13 @@ namespace SMESH
TPythonDump:: TPythonDump::
operator<<(SALOMEDS::SObject_ptr aSObject) operator<<(SALOMEDS::SObject_ptr aSObject)
{ {
if ( !aSObject->_is_nil() ) if ( !aSObject->_is_nil() ) {
myStream << aSObject->GetID(); CORBA::String_var entry = aSObject->GetID();
else myStream << entry.in();
myStream << NotPublishedObjectName(); }
else {
myStream << theNotPublishedObjectName;
}
return *this; return *this;
} }
@ -249,8 +282,8 @@ namespace SMESH
TPythonDump:: TPythonDump::
operator<<(CORBA::Object_ptr theArg) operator<<(CORBA::Object_ptr theArg)
{ {
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
if(!aSObject->_is_nil()) { if(!aSObject->_is_nil()) {
CORBA::String_var id = aSObject->GetID(); CORBA::String_var id = aSObject->GetID();
@ -259,7 +292,7 @@ namespace SMESH
if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object if ( aSMESHGen->CanPublishInStudy( theArg )) // not published SMESH object
myStream << "smeshObj_" << size_t(theArg); myStream << "smeshObj_" << size_t(theArg);
else else
myStream << NotPublishedObjectName(); myStream << theNotPublishedObjectName;
} }
else else
myStream << "None"; myStream << "None";
@ -270,7 +303,7 @@ namespace SMESH
TPythonDump:: TPythonDump::
operator<<(SMESH::SMESH_Hypothesis_ptr theArg) operator<<(SMESH::SMESH_Hypothesis_ptr theArg)
{ {
SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy(); SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->GetCurrentStudy();
SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
if(aSObject->_is_nil() && !CORBA::is_nil(theArg)) if(aSObject->_is_nil() && !CORBA::is_nil(theArg))
myStream << "hyp_" << theArg->GetId(); myStream << "hyp_" << theArg->GetId();
@ -285,22 +318,26 @@ namespace SMESH
{ {
if ( CORBA::is_nil( theArg ) ) if ( CORBA::is_nil( theArg ) )
return *this << "None"; return *this << "None";
SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen(); SMESH_Gen_i* aSMESHGen = SMESH_Gen_i::GetSMESHGen();
SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy(); SALOMEDS::Study_var aStudy = aSMESHGen->GetCurrentStudy();
SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg); SALOMEDS::SObject_var aSObject = SMESH_Gen_i::ObjectToSObject(aStudy,theArg);
if(!aSObject->_is_nil()) if(!aSObject->_is_nil())
{
return *this << aSObject; return *this << aSObject;
}
if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theArg )) if ( SMESH::Filter_i* filter = SMESH::DownCast<SMESH::Filter_i*>( theArg ))
{
return *this << filter; return *this << filter;
}
SMESH::SMESH_Mesh_var mesh = theArg->GetMesh(); SMESH::SMESH_Mesh_var mesh = theArg->GetMesh();
if ( !theArg->_is_equivalent( mesh )) if ( !theArg->_is_equivalent( mesh ))
{ {
SMESH::long_array_var anElementsId = theArg->GetIDs(); SMESH::long_array_var anElementsId = theArg->GetIDs();
SMESH::array_of_ElementType_var types = theArg->GetTypes(); SMESH::array_of_ElementType_var types = theArg->GetTypes();
SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL; SMESH::ElementType type = types->length() ? types[0] : SMESH::ALL;
return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")"; return *this << mesh << ".GetIDSource(" << anElementsId << ", " << type << ")";
} }
return *this; return *this << theNotPublishedObjectName;
} }
TPythonDump& TPythonDump&
@ -462,6 +499,10 @@ namespace SMESH
DumpArray( theList, *this ); DumpArray( theList, *this );
return *this; return *this;
} }
const char* TPythonDump::NotPublishedObjectName()
{
return theNotPublishedObjectName;
}
TCollection_AsciiString myLongStringStart( "TPythonDump::LongStringStart" ); TCollection_AsciiString myLongStringStart( "TPythonDump::LongStringStart" );
TCollection_AsciiString myLongStringEnd ( "TPythonDump::LongStringEnd" ); TCollection_AsciiString myLongStringEnd ( "TPythonDump::LongStringEnd" );
@ -590,7 +631,8 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
if (CORBA::is_nil(aStudy)) if (CORBA::is_nil(aStudy))
return new Engines::TMPFile(0); return new Engines::TMPFile(0);
SALOMEDS::SObject_var aSO = aStudy->FindComponent(ComponentDataType()); CORBA::String_var compDataType = ComponentDataType();
SALOMEDS::SObject_var aSO = aStudy->FindComponent( compDataType.in() );
if (CORBA::is_nil(aSO)) if (CORBA::is_nil(aSO))
return new Engines::TMPFile(0); return new Engines::TMPFile(0);
@ -618,8 +660,10 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
SALOMEDS::GenericAttribute_var anAttr = SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject"); aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject(); SALOMEDS::AttributePythonObject_var pyAttr =
TCollection_AsciiString aSavedTrace (oldValue); 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 // Add trace of API methods calls and replace study entries by names
TCollection_AsciiString aScript; TCollection_AsciiString aScript;
@ -633,7 +677,7 @@ Engines::TMPFile* SMESH_Gen_i::DumpPython (CORBA::Object_ptr theStudy,
CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer; CORBA::Octet* anOctetBuf = (CORBA::Octet*)aBuffer;
Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1); Engines::TMPFile_var aStreamFile = new Engines::TMPFile(aLen+1, aLen+1, anOctetBuf, 1);
bool hasNotPublishedObjects = aScript.Location( NotPublishedObjectName(), 1, aLen); bool hasNotPublishedObjects = aScript.Location( SMESH::theNotPublishedObjectName, 1, aLen);
isValidScript = isValidScript && !hasNotPublishedObjects; isValidScript = isValidScript && !hasNotPublishedObjects;
return aStreamFile._retn(); return aStreamFile._retn();
@ -675,14 +719,16 @@ void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy)
TCollection_AsciiString aScript = GetNewPythonLines(theStudy->StudyId()); TCollection_AsciiString aScript = GetNewPythonLines(theStudy->StudyId());
// Check contents of PythonObject attribute // Check contents of PythonObject attribute
SALOMEDS::SObject_var aSO = theStudy->FindComponent(ComponentDataType()); CORBA::String_var compDataType = ComponentDataType();
//SALOMEDS::SObject_var aSO = SMESH_Gen_i::ObjectToSObject(theStudy, _this()); SALOMEDS::SObject_var aSO = theStudy->FindComponent( compDataType.in() );
SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder(); SALOMEDS::StudyBuilder_var aStudyBuilder = theStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr = SALOMEDS::GenericAttribute_var anAttr =
aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject"); aStudyBuilder->FindOrCreateAttribute(aSO, "AttributePythonObject");
char* oldValue = SALOMEDS::AttributePythonObject::_narrow(anAttr)->GetObject(); SALOMEDS::AttributePythonObject_var pyAttr =
TCollection_AsciiString oldScript (oldValue); SALOMEDS::AttributePythonObject::_narrow(anAttr);
CORBA::String_var oldValue = pyAttr->GetObject();
TCollection_AsciiString oldScript (oldValue.in());
if (oldScript.Length() > 0) { if (oldScript.Length() > 0) {
oldScript += "\n"; oldScript += "\n";
@ -692,7 +738,7 @@ void SMESH_Gen_i::SavePython (SALOMEDS::Study_ptr theStudy)
} }
// Store in PythonObject attribute // Store in PythonObject attribute
SALOMEDS::AttributePythonObject::_narrow(anAttr)->SetObject(oldScript.ToCString(), 1); pyAttr->SetObject(oldScript.ToCString(), 1);
// Clean trace of API methods calls // Clean trace of API methods calls
CleanPythonTrace(theStudy->StudyId()); CleanPythonTrace(theStudy->StudyId());
@ -776,7 +822,9 @@ namespace {
isValidName = false; isValidName = false;
} }
// shorten names like CartesianParameters3D_400_400_400_1000000_1 // 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()); p = aName.Location( "_", 20, aName.Length());
if ( p > 1 ) if ( p > 1 )
@ -792,14 +840,14 @@ namespace {
*/ */
//============================================================================= //=============================================================================
TCollection_AsciiString SMESH_Gen_i::DumpPython_impl TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
(SALOMEDS::Study_ptr theStudy, (SALOMEDS::Study_ptr theStudy,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
Resource_DataMapOfAsciiStringAsciiString& theNames, Resource_DataMapOfAsciiStringAsciiString& theNames,
bool isPublished, bool isPublished,
bool isMultiFile, bool isMultiFile,
bool isHistoricalDump, bool isHistoricalDump,
bool& aValidScript, bool& aValidScript,
const TCollection_AsciiString& theSavedTrace) const TCollection_AsciiString& theSavedTrace)
{ {
int aStudyID = theStudy->StudyId(); int aStudyID = theStudy->StudyId();
@ -865,9 +913,11 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
// Some objects are wrapped with python classes and // Some objects are wrapped with python classes and
// Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects // Resource_DataMapOfAsciiStringAsciiString holds methods returning wrapped objects
Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod; Resource_DataMapOfAsciiStringAsciiString anEntry2AccessorMethod;
std::set< TCollection_AsciiString > aRemovedObjIDs;
if ( !getenv("NO_2smeshpy_conversion")) if ( !getenv("NO_2smeshpy_conversion"))
aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod, aScript = SMESH_2smeshpy::ConvertScript( aScript, anEntry2AccessorMethod,
theObjectNames, theStudy, isHistoricalDump ); theObjectNames, aRemovedObjIDs,
theStudy, isHistoricalDump );
// Replace characters used instead of quote marks to quote notebook variables // Replace characters used instead of quote marks to quote notebook variables
{ {
@ -967,6 +1017,7 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()"; anUpdatedScript += "\n\taStudyBuilder = theStudy.NewBuilder()";
} }
for (int ir = 1; ir <= seqRemoved.Length(); ir++) { for (int ir = 1; ir <= seqRemoved.Length(); ir++) {
if ( aRemovedObjIDs.count( seqRemoved.Value(ir) )) continue;
anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR("; anUpdatedScript += "\n\tSO = theStudy.FindObjectIOR(theStudy.ConvertObjectToIOR(";
anUpdatedScript += seqRemoved.Value(ir); anUpdatedScript += seqRemoved.Value(ir);
// for object wrapped by class of smesh.py // for object wrapped by class of smesh.py
@ -987,13 +1038,14 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
for (Standard_Integer i = 1; i <= aLen; i += 2) for (Standard_Integer i = 1; i <= aLen; i += 2)
{ {
anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1)); anEntry = aScript.SubString(aSeq->Value(i), aSeq->Value(i + 1));
aName = geom->GetDumpName( anEntry.ToCString() ); aName = geom->GetDumpName( anEntry.ToCString() );
if (aName.IsEmpty() && // Not a GEOM object if (aName.IsEmpty() && // Not a GEOM object
theNames.IsBound(anEntry) && theNames.IsBound(anEntry) &&
!aRemovedObjIDs.count(anEntry) && // a command creating anEntry was erased
!mapEntries.IsBound(anEntry) && // Not yet processed !mapEntries.IsBound(anEntry) && // Not yet processed
!mapRemoved.IsBound(anEntry)) // Was not removed !mapRemoved.IsBound(anEntry)) // Was not removed
{ {
aName = theObjectNames.Find(anEntry); aName = theObjectNames.Find(anEntry);
aGUIName = theNames.Find(anEntry); aGUIName = theNames.Find(anEntry);
mapEntries.Bind(anEntry, aName); mapEntries.Bind(anEntry, aName);
anUpdatedScript += helper + "\n\t" + aSMESHGen + ".SetName(" + aName; anUpdatedScript += helper + "\n\t" + aSMESHGen + ".SetName(" + aName;
@ -1014,7 +1066,8 @@ TCollection_AsciiString SMESH_Gen_i::DumpPython_impl
if (isPublished) if (isPublished)
{ {
//Output the script that sets up the visual parameters. //Output the script that sets up the visual parameters.
char* script = theStudy->GetDefaultScript(ComponentDataType(), "\t"); CORBA::String_var compDataType = ComponentDataType();
char* script = theStudy->GetDefaultScript( compDataType.in(), "\t");
if (script && strlen(script) > 0) { if (script && strlen(script) > 0) {
anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n"; anUpdatedScript += "\n\n\t### Store presentation parameters of displayed objects\n";
anUpdatedScript += script; anUpdatedScript += script;

10
src/SMESH_I/SMESH_PythonDump.hxx
View File

@ -31,6 +31,7 @@
#include <sstream> #include <sstream>
#include <vector> #include <vector>
#include <set>
class SMESH_Gen_i; class SMESH_Gen_i;
class SMESH_MeshEditor_i; class SMESH_MeshEditor_i;
@ -51,8 +52,10 @@ public:
/*! /*!
* \brief Convert a python script using commands of smesh.py * \brief Convert a python script using commands of smesh.py
* \param theScript - Input script * \param theScript - Input script
* \param theEntry2AccessorMethod - The returning method names to access to * \param theEntry2AccessorMethod - returns method names to access to
* objects wrapped with python class * objects wrapped with python class
* \param theObjectNames - names of objects
* \param theRemovedObjIDs - entries of objects whose created commands were removed
* \param theHistoricalDump - true means to keep all commands, false means * \param theHistoricalDump - true means to keep all commands, false means
* to exclude commands relating to objects removed from study * to exclude commands relating to objects removed from study
* \retval TCollection_AsciiString - Convertion result * \retval TCollection_AsciiString - Convertion result
@ -61,6 +64,7 @@ public:
ConvertScript(const TCollection_AsciiString& theScript, ConvertScript(const TCollection_AsciiString& theScript,
Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod, Resource_DataMapOfAsciiStringAsciiString& theEntry2AccessorMethod,
Resource_DataMapOfAsciiStringAsciiString& theObjectNames, Resource_DataMapOfAsciiStringAsciiString& theObjectNames,
std::set< TCollection_AsciiString >& theRemovedObjIDs,
SALOMEDS::Study_ptr& theStudy, SALOMEDS::Study_ptr& theStudy,
const bool theHistoricalDump); const bool theHistoricalDump);
@ -142,6 +146,9 @@ namespace SMESH
TPythonDump& TPythonDump&
operator<<(const SMESH::GeometryType& theArg); operator<<(const SMESH::GeometryType& theArg);
TPythonDump&
operator<<(const SMESH::EntityType& theArg);
TPythonDump& TPythonDump&
operator<<(const SMESH::long_array& theArg); operator<<(const SMESH::long_array& theArg);
@ -210,6 +217,7 @@ namespace SMESH
static const char* SMESHGenName() { return "smeshgen"; } static const char* SMESHGenName() { return "smeshgen"; }
static const char* MeshEditorName() { return "mesh_editor"; } static const char* MeshEditorName() { return "mesh_editor"; }
static const char* NotPublishedObjectName();
/*! /*!
* \brief Return marker of long string literal beginning * \brief Return marker of long string literal beginning