#include <TopoDS_Wire.hxx>
#include <gp_Pnt.hxx>
-
#ifdef WIN32
#include <windows.h>
#include <process.h>
#include <cstdlib>
#include <memory>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/serialization/list.hpp>
+#include <boost/serialization/string.hpp>
+
using namespace std;
using SMESH::TPythonDump;
using SMESH::TVar;
GEOM::GEOM_Gen_var SMESH_Gen_i::myGeomGen;
CORBA::ORB_var SMESH_Gen_i::myOrb;
PortableServer::POA_var SMESH_Gen_i::myPoa;
-SALOME_NamingService* SMESH_Gen_i::myNS = NULL;
-SALOME_LifeCycleCORBA* SMESH_Gen_i::myLCC = NULL;
-SMESH_Gen_i* SMESH_Gen_i::mySMESHGen = NULL;
+SALOME_NamingService_Abstract* SMESH_Gen_i::myNS = nullptr;
+SALOME_LifeCycleCORBA* SMESH_Gen_i::myLCC = nullptr;
+SMESH_Gen_i* SMESH_Gen_i::mySMESHGen = nullptr;
const int nbElemPerDiagonal = 10;
*/
//=============================================================================
-SALOME_NamingService* SMESH_Gen_i::GetNS()
+SALOME_NamingService_Abstract* SMESH_Gen_i::GetNS()
{
if ( myNS == NULL ) {
myNS = SINGLETON_<SALOME_NamingService>::Instance();
*/
//=============================================================================
-GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( bool isShaper )
-{
- Engines::EngineComponent_ptr temp =
- GetLCC()->FindOrLoad_Component( isShaper ? "FactoryServer" : "FactoryServer",
- isShaper ? "SHAPERSTUDY" : "GEOM" );
- myGeomGen = GEOM::GEOM_Gen::_narrow( temp );
-
- return myGeomGen;
-}
-
-//=============================================================================
-/*!
- * GetGeomEngine [ static ]
- *
- * Get GEOM::GEOM_Gen reference
- */
-//=============================================================================
-
GEOM::GEOM_Gen_var SMESH_Gen_i::GetGeomEngine( GEOM::GEOM_Object_ptr go )
{
- GEOM::GEOM_Gen_ptr gen;
+ GEOM::GEOM_Gen_ptr gen = GEOM::GEOM_Gen::_nil();
if ( !CORBA::is_nil( go ))
gen = go->GetGen();
return gen;
PortableServer::POA_ptr poa,
PortableServer::ObjectId* contId,
const char* instanceName,
- const char* interfaceName )
- : Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
+ const char* interfaceName,
+ bool checkNS)
+ : Engines_Component_i( orb, poa, contId, instanceName, interfaceName, false, checkNS )
{
myOrb = CORBA::ORB::_duplicate(orb);
// find out mode (embedded or standalone) here else
// meshes created before calling SMESH_Client::GetSMESHGen(), which calls
// SMESH_Gen_i::SetEmbeddedMode(), have wrong IsEmbeddedMode flag
- if ( SALOME_NamingService* ns = GetNS() )
+ if(checkNS)
{
- CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" );
- SALOME::Session_var session = SALOME::Session::_narrow( obj ) ;
- if ( !session->_is_nil() )
+ if ( SALOME_NamingService_Abstract* ns = GetNS() )
{
- CORBA::String_var str_host = session->getHostname();
- CORBA::Long s_pid = session->getPID();
- string my_host = Kernel_Utils::GetHostname();
+ CORBA::Object_var obj = ns->Resolve( "/Kernel/Session" );
+ SALOME::Session_var session = SALOME::Session::_narrow( obj ) ;
+ if ( !session->_is_nil() )
+ {
+ CORBA::String_var str_host = session->getHostname();
+ CORBA::Long s_pid = session->getPID();
+ string my_host = Kernel_Utils::GetHostname();
#ifdef WIN32
- long my_pid = (long)_getpid();
+ long my_pid = (long)_getpid();
#else
- long my_pid = (long) getpid();
+ long my_pid = (long) getpid();
#endif
- SetEmbeddedMode( s_pid == my_pid && my_host == str_host.in() );
+ SetEmbeddedMode( s_pid == my_pid && my_host == str_host.in() );
+ }
}
}
}
GenericHypothesisCreator_i* SMESH_Gen_i::getHypothesisCreator(const char* theHypName,
const char* theLibName,
std::string& thePlatformLibName)
- throw (SALOME::SALOME_Exception)
{
std::string aPlatformLibName;
/* It's Need to translate lib name for WIN32 or X platform */
hypothesis_i = myHypothesis_i->_this();
int nextId = RegisterObject( hypothesis_i );
if(MYDEBUG) { MESSAGE( "Add hypo to map with id = "<< nextId ); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
}
return hypothesis_i._retn();
}
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::createMesh" );
SMESH::SMESH_Mesh_var mesh = SMESH::SMESH_Mesh::_narrow( meshServant->_this() );
int nextId = RegisterObject( mesh );
if(MYDEBUG) { MESSAGE( "Add mesh to map with id = "<< nextId); }
- else { nextId = 0; } // avoid "unused variable" warning in release mode
+ else { (void)nextId; } // avoid "unused variable" warning in release mode
return mesh._retn();
}
catch (SALOME_Exception& S_ex) {
SMESH::SMESH_Hypothesis_ptr SMESH_Gen_i::CreateHypothesis( const char* theHypName,
const char* theLibName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
// Create hypothesis/algorithm
SALOMEDS::SObject_wrap aSO = PublishHypothesis( hyp );
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateHypothesis('"
+ TPythonDump(this) << aSO << " = " << this << ".CreateHypothesis('"
<< theHypName << "', '" << theLibName << "')";
}
}
const char* theLibName,
CORBA::Double theAverageLength,
CORBA::Boolean theQuadDominated)
- throw ( SALOME::SALOME_Exception )
{
SMESH::HypInitParams initParams = { ::SMESH_Hypothesis::BY_AVERAGE_LENGTH,
theAverageLength, theQuadDominated };
initParams );
SALOMEDS::SObject_wrap so = PublishHypothesis( hyp );
- TPythonDump() << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
+ TPythonDump(this) << hyp << " = " << this << ".CreateHypothesisByAverageLength( '"
<< theHypType << "', '"
<< theLibName << "', "
<< theAverageLength << ", "
SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theGeom,
const SMESH::HypInitParams& theParams)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
//=============================================================================
void SMESH_Gen_i::SetBoundaryBoxSegmentation( CORBA::Long theNbSegments )
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetBoundaryBoxSegmentation( int( theNbSegments ));
//=============================================================================
void SMESH_Gen_i::SetDefaultNbSegments(CORBA::Long theNbSegments)
- throw ( SALOME::SALOME_Exception )
{
if ( theNbSegments > 0 )
myGen.SetDefaultNbSegments( int(theNbSegments) );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMesh( GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMesh(" << theShapeObject << ")";
}
}
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateEmptyMesh()
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::CreateMesh" );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateEmptyMesh()";
+ TPythonDump(this) << aSO << " = " << this << ".CreateEmptyMesh()";
}
}
*/
//================================================================================
- void checkFileReadable( const char* theFileName ) throw ( SALOME::SALOME_Exception )
+ void checkFileReadable( const char* theFileName )
{
SMESH_File f ( theFileName );
if ( !f )
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMeshesFromUNV(r'" << theFileName << "')";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMeshesFromUNV(r'" << theFileName << "')";
}
}
{ // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
// Python Dump
- TPythonDump aPythonDump;
+ TPythonDump aPythonDump(this);
aPythonDump << "([";
if (theStatus == SMESH::DRS_OK) {
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromSAUV( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
//=============================================================================
SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
+ TPythonDump(this) << aSO << " = " << this << ".CreateMeshesFromSTL(r'" << theFileName << "')";
}
}
SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromCGNS( const char* theFileName,
SMESH::DriverMED_ReadStatus& theStatus)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
{ // open a new scope to make aPythonDump die before PythonDump in SMESH_Mesh::GetGroups()
// Python Dump
- TPythonDump aPythonDump;
+ TPythonDump aPythonDump(this);
aPythonDump << "([";
if (theStatus == SMESH::DRS_OK)
SMESH_Gen_i::CreateMeshesFromGMF( const char* theFileName,
CORBA::Boolean theMakeRequiredGroups,
SMESH::ComputeError_out theError)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
checkFileReadable( theFileName );
aStudyBuilder->CommitCommand();
if ( !aSO->_is_nil() ) {
// Update Python script
- TPythonDump() << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
+ TPythonDump(this) << "("<< aSO << ", error) = " << this << ".CreateMeshesFromGMF(r'"
<< theFileName << "', "
<< theMakeRequiredGroups << " )";
}
CORBA::Boolean SMESH_Gen_i::IsReadyToCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::IsReadyToCompute" );
SMESH::compute_error_array* SMESH_Gen_i::GetComputeErrors( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetComputeErrors()" );
SMESH::MeshPreviewStruct*
SMESH_Gen_i::GetBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetBadInputElements()" );
SMESH_Gen_i::MakeGroupsOfBadInputElements( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Short theSubShapeID,
const char* theGroupName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if ( SMESH_Mesh_i* meshServant = SMESH::DownCast<SMESH_Mesh_i*>( theMesh ))
{
groups = meshServant->MakeGroupsOfBadInputElements( theSubShapeID, theGroupName );
- TPythonDump() << groups << " = " << this
+ TPythonDump(this) << groups << " = " << this
<< ".MakeGroupsOfBadInputElements( "
<< theMesh << ", " << theSubShapeID << ", '" << theGroupName << "' )";
}
SMESH::algo_error_array* SMESH_Gen_i::GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetAlgoState()" );
SMESH::long_array*
SMESH_Gen_i::GetSubShapesId( GEOM::GEOM_Object_ptr theMainShapeObject,
const SMESH::object_array& theListOfSubShapeObject )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::GetSubShapesId" );
CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
- throw ( SALOME::SALOME_Exception )
{
//MEMOSTAT;
Unexpect aCatch(SALOME_SalomeException);
SALOME::BAD_PARAM );
// Update Python script
- TPythonDump() << "isDone = " << this << ".Compute( "
+ TPythonDump(this) << "isDone = " << this << ".Compute( "
<< theMesh << ", " << theShapeObject << ")";
try {
return ok;
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Compute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
GEOM::GEOM_Object_ptr theShapeObject,
SMESH::Dimension theDimension,
SMESH::long_array& theShapesId)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Precompute" );
}
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Precompute(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
SMESH::long_array* SMESH_Gen_i::Evaluate(SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject)
// SMESH::long_array& theNbElems)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if(MYDEBUG) MESSAGE( "SMESH_Gen_i::Evaluate" );
nbels[i] = 0;
// Update Python script
- TPythonDump() << "theNbElems = " << this << ".Evaluate( "
+ TPythonDump(this) << "theNbElems = " << this << ".Evaluate( "
<< theMesh << ", " << theShapeObject << ")";
try {
return nbels._retn();
}
}
- catch ( std::bad_alloc ) {
+ catch ( std::bad_alloc& ) {
INFOS( "Evaluate(): lack of memory" );
}
catch ( SALOME_Exception& S_ex ) {
SMESH_Gen_i::GetGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID,
const char* theGeomName)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_ptr
SMESH_Gen_i::FindGeometryByMeshElement( SMESH::SMESH_Mesh_ptr theMesh,
CORBA::Long theElementID)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
if ( CORBA::is_nil( theMesh ) )
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Boolean theMergeNodesAndElements,
CORBA::Double theMergeTolerance,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
return ConcatenateCommon(theMeshesArray,
theUniteIdenticalGroups,
CORBA::Double theMergeTolerance,
CORBA::Boolean theCommonGroups,
SMESH::SMESH_Mesh_ptr theMeshToAppendTo)
- throw ( SALOME::SALOME_Exception )
{
- std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump );
+ std::unique_ptr< TPythonDump > pPythonDump( new TPythonDump(this) );
TPythonDump& pythonDump = *pPythonDump; // prevent dump of called methods
// create mesh if theMeshToAppendTo not provided
const char* meshName,
CORBA::Boolean toCopyGroups,
CORBA::Boolean toKeepIDs)
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
- TPythonDump* pyDump = new TPythonDump; // prevent dump from CreateMesh()
+ TPythonDump* pyDump = new TPythonDump(this); // prevent dump from CreateMesh()
std::unique_ptr<TPythonDump> pyDumpDeleter( pyDump );
// 1. Get source mesh
SMESH::submesh_array_out theNewSubmeshes,
SMESH::ListOfHypothesis_out theNewHypotheses,
SMESH::string_array_out theInvalidEntries)
-throw ( SALOME::SALOME_Exception )
{
if ( CORBA::is_nil( theSourceMesh ) ||
CORBA::is_nil( theNewGeometry ))
bool ok = true;
SMESH_TRY;
- TPythonDump pyDump; // prevent dump from CreateMesh()
+ TPythonDump pyDump(this); // prevent dump from CreateMesh()
theNewMesh = CreateMesh( theNewGeometry );
theNewGroups = new SMESH::ListOfGroups();
SMESH::SMESH_Mesh_var myMesh = SMESH::SMESH_Mesh::_narrow( anObject ) ;
if ( !myMesh->_is_nil() ) {
myMesh->Load(); // load from study file if not yet done
- TPythonDump pd; // not to dump GetGroups()
+ TPythonDump pd(this); // not to dump GetGroups()
SMESH::ListOfGroups_var groups = myMesh->GetGroups();
for ( CORBA::ULong i = 0; i < groups->length(); ++i )
{
// store submesh order if any
const TListOfListOfInt& theOrderIds = myLocMesh.GetMeshOrder();
- if ( theOrderIds.size() ) {
+ const bool isNewOrederVersion = true; // old version saves ids, new one, entries
+ if ( !theOrderIds.empty() && !isNewOrederVersion ) { // keep old version for reference
char order_list[ 30 ];
strcpy( order_list, "Mesh Order" );
// count number of submesh ids
//
delete[] smIDs;
}
+ if ( !theOrderIds.empty() && isNewOrederVersion )
+ {
+ // convert ids to entries
+ std::list< std::list< std::string > > orderEntryLists;
+ for ( const TListOfInt& idList : theOrderIds )
+ {
+ orderEntryLists.emplace_back();
+ std::list< std::string > & entryList = orderEntryLists.back();
+ for ( const int& id : idList )
+ {
+ const TopoDS_Shape& shape = mySMESHDSMesh->IndexToShape( id );
+ GEOM::GEOM_Object_var go = ShapeToGeomObject( shape );
+ SALOMEDS::SObject_var so = ObjectToSObject( go );
+ if ( !so->_is_nil() )
+ {
+ CORBA::String_var entry = so->GetID();
+ entryList.emplace_back( entry.in() );
+ }
+ }
+ }
+ // convert orderEntryLists to string
+ std::ostringstream ostream;
+ boost::archive::text_oarchive( ostream ) << orderEntryLists;
+ std::string orderEntryString = ostream.str();
+
+ // write HDF group
+ aSize[ 0 ] = orderEntryString.size() + 1;
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup, HDF_STRING, aSize, 1 );
+ aDataset->CreateOnDisk();
+ aDataset->WriteOnDisk((char*) orderEntryString.data() );
+ aDataset->CloseOnDisk();
+ }
// groups root sub-branch
SALOMEDS::SObject_wrap myGroupsBranch;
return false;
}
- TPythonDump pd; // prevent dump during loading
+ TPythonDump pd(this); // prevent dump during loading
// For PAL13473 ("Repetitive mesh") implementation.
// New dependencies between SMESH objects are established:
}
// read Sub-Mesh ORDER if any
- if ( aTopGroup->ExistInternalObject( "Mesh Order" )) {
+ if ( aTopGroup->ExistInternalObject( "Mesh Order" )) { // old version keeps ids
aDataset = new HDFdataset( "Mesh Order", aTopGroup );
aDataset->OpenOnDisk();
size = aDataset->GetSize();
myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
delete [] smIDs;
}
+ if ( aTopGroup->ExistInternalObject( "MeshOrder_new" )) // new version keeps entries
+ {
+ aDataset = new HDFdataset( "MeshOrder_new", aTopGroup );
+ aDataset->OpenOnDisk();
+ size = aDataset->GetSize();
+ std::string dataString; dataString.resize( size );
+ aDataset->ReadFromDisk((char*) dataString.data() );
+ aDataset->CloseOnDisk();
+
+ std::istringstream istream( dataString.data() );
+ boost::archive::text_iarchive archive( istream );
+ std::list< std::list< std::string > > orderEntryLists;
+ try {
+ archive >> orderEntryLists;
+ }
+ catch (...) {}
+
+ TListOfListOfInt anOrderIds;
+ for ( const std::list< std::string >& entryList : orderEntryLists )
+ {
+ anOrderIds.emplace_back();
+ for ( const std::string & entry : entryList )
+ {
+ GEOM::GEOM_Object_var go = GetGeomObjectByEntry( entry );
+ TopoDS_Shape shape = GeomObjectToShape( go );
+ if ( SMESH_subMesh* sm = myNewMeshImpl->GetImpl().GetSubMesh( shape ))
+ anOrderIds.back().emplace_back( sm->GetId() );
+ }
+ }
+ myNewMeshImpl->GetImpl().SetMeshOrder( anOrderIds );
+ }
} // loop on meshes
// update hyps needing full mesh data restored (issue 20918)
}
}
}
- pd << ""; // prevent optimizing pd out
// creation of tree nodes for all data objects in the study
// to support tree representation customization and drag-n-drop:
SMESH_TRY;
std::string aPlatformLibName;
- typedef GenericHypothesisCreator_i* (*GetHypothesisCreator)(const char*);
GenericHypothesisCreator_i* aCreator =
getHypothesisCreator(theAlgoType, theLibName, aPlatformLibName);
if (aCreator)
}
return res;
}
-
-//=============================================================================
-/*!
- * SMESHEngine_factory
- *
- * C factory, accessible with dlsym, after dlopen
- */
-//=============================================================================
-
-extern "C"
-{ SMESH_I_EXPORT
- PortableServer::ObjectId* SMESHEngine_factory( CORBA::ORB_ptr orb,
- PortableServer::POA_ptr poa,
- PortableServer::ObjectId* contId,
- const char* instanceName,
- const char* interfaceName )
- {
- if(MYDEBUG) MESSAGE( "PortableServer::ObjectId* SMESHEngine_factory()" );
- if(MYDEBUG) SCRUTE(interfaceName);
- SMESH_Gen_i* aSMESHGen = new SMESH_Gen_i(orb, poa, contId, instanceName, interfaceName);
- return aSMESHGen->getId() ;
- }
-}
