-// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include <vtkUnstructuredGridWriter.h>
-// to pass CORBA exception through SMESH_TRY
-#define SMY_OWN_CATCH catch( SALOME::SALOME_Exception& se ) { throw se; }
+// to pass CORBA exception and TooLargeForExport exception through SMESH_TRY
+#define SMY_OWN_CATCH \
+ catch( SALOME::SALOME_Exception& se ) { throw se; } \
+ catch( ::SMESH_Mesh::TooLargeForExport& ex ) \
+ { SALOME::ExceptionStruct se = { \
+ SALOME::COMM, \
+ CORBA::string_dup(SMESH_Comment("Mesh is too large for export in format ") << ex.what()), \
+ CORBA::string_dup(SMESH_Comment("format=") << ex.what() ), 0 }; \
+ throw SALOME::SALOME_Exception( se ); }
#include "SMESH_TryCatch.hxx" // include after OCCT headers!
//=============================================================================
void SMESH_Mesh_i::SetShape( GEOM::GEOM_Object_ptr theShapeObject )
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
try {
//================================================================================
CORBA::Boolean SMESH_Mesh_i::HasShapeToMesh()
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
bool res = false;
//================================================================================
GEOM::GEOM_Object_ptr SMESH_Mesh_i::GetShapeToMesh()
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
GEOM::GEOM_Object_var aShapeObj;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::IsLoaded() throw (SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::IsLoaded()
{
Unexpect aCatch(SALOME_SalomeException);
return !_preMeshInfo;
*/
//================================================================================
-void SMESH_Mesh_i::Load() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Load()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-void SMESH_Mesh_i::Clear() throw (SALOME::SALOME_Exception)
+void SMESH_Mesh_i::Clear()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::ClearSubMesh(CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::DriverMED_ReadStatus
SMESH_Mesh_i::ImportMEDFile( const char* theFileName, const char* theMeshName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
int status;
SMESH::DriverMED_ReadStatus SMESH_Mesh_i::ImportCGNSFile( const char* theFileName,
const int theMeshIndex,
std::string& theMeshName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
int status;
char* SMESH_Mesh_i::GetVersionString(CORBA::Long minor, CORBA::Short nbDigits)
{
- string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor,
- nbDigits);
+ string ver = DriverMED_W_SMESHDS_Mesh::GetVersionString(minor, nbDigits);
return CORBA::string_dup( ver.c_str() );
}
//=============================================================================
int SMESH_Mesh_i::ImportUNVFile( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
SMESH_TRY;
//=============================================================================
int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
- throw ( SALOME::SALOME_Exception )
{
SMESH_TRY;
SMESH::ComputeError* SMESH_Mesh_i::ImportGMFFile( const char* theFileName,
bool theMakeRequiredGroups )
- throw (SALOME::SALOME_Exception)
{
SMESH_ComputeErrorPtr error;
SMESH_Mesh_i::AddHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp,
CORBA::String_out anErrorText)
- throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
+
+ const smIdType prevNbMeshEnt = NbNodes() + NbElements();
+
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
- const int prevNbMeshEnt = _impl->NbNodes() + _impl->GetMeshDS()->NbElements();
-
std::string error;
SMESH_Hypothesis::Hypothesis_Status status = addHypothesis( aSubShape, anHyp, &error );
anErrorText = error.c_str();
SMESH::Hypothesis_Status SMESH_Mesh_i::RemoveHypothesis(GEOM::GEOM_Object_ptr aSubShape,
SMESH::SMESH_Hypothesis_ptr anHyp)
- throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH::ListOfHypothesis *
SMESH_Mesh_i::GetHypothesisList(GEOM::GEOM_Object_ptr aSubShape)
-throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetHypothesisList");
*/
//================================================================================
-SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes() throw (SALOME::SALOME_Exception)
+SMESH::submesh_array* SMESH_Mesh_i::GetSubMeshes()
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetSubMeshes");
SMESH::SMESH_subMesh_ptr SMESH_Mesh_i::GetSubMesh(GEOM::GEOM_Object_ptr aSubShape,
const char* theName )
- throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if (CORBA::is_nil(aSubShape))
//================================================================================
void SMESH_Mesh_i::RemoveSubMesh( SMESH::SMESH_subMesh_ptr theSubMesh )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CreateGroup( SMESH::ElementType theElemType,
const char* theName )
- throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromGEOM (SMESH::ElementType theElemType,
const char* theName,
GEOM::GEOM_Object_ptr theGeomObj)
- throw(SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
SMESH_Mesh_i::CreateGroupFromFilter(SMESH::ElementType theElemType,
const char* theName,
SMESH::Filter_ptr theFilter )
- throw (SALOME::SALOME_Exception)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//================================================================================
void SMESH_Mesh_i::RemoveGroup( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
{
if ( theGroup->_is_nil() )
return;
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".RemoveGroup( " << aGroupSO << " )";
// Remove group's SObject
- SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::getStudyServant()->NewBuilder();
+ SALOMEDS::StudyBuilder_var builder = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->NewBuilder();
builder->RemoveObjectWithChildren( aGroupSO );
}
aGroup->Modified(/*removed=*/true); // notify dependent Filter with FT_BelongToMeshGroup criterion
//=============================================================================
void SMESH_Mesh_i::RemoveGroupWithContents( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
if ( _preMeshInfo )
THROW_SALOME_CORBA_EXCEPTION( "RemoveGroupWithContents(): group does not belong to this mesh",
SALOME::BAD_PARAM);
- vector<int> nodeIds; // to remove nodes becoming free
+ vector<smIdType> nodeIds; // to remove nodes becoming free
bool isNodal = ( theGroup->GetType() == SMESH::NODE );
if ( !isNodal && !theGroup->IsEmpty() )
{
- CORBA::Long elemID = theGroup->GetID( 1 );
+ SMESH::smIdType elemID = theGroup->GetID( 1 );
int nbElemNodes = GetElemNbNodes( elemID );
if ( nbElemNodes > 0 )
nodeIds.reserve( theGroup->Size() * nbElemNodes );
if ( n->NbInverseElements() == 0 )
_impl->GetMeshDS()->RemoveFreeNode( n, /*sm=*/0 );
+ _impl->GetMeshDS()->Modified();
+ _impl->SetIsModified( true );
+
// Update Python script (theGroup must be alive for this)
pyDump << SMESH::SMESH_Mesh_var(_this())
<< ".RemoveGroupWithContents( " << theGroup << " )";
*/
//================================================================================
-SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups() throw(SALOME::SALOME_Exception)
+SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
{
Unexpect aCatch(SALOME_SalomeException);
if (MYDEBUG) MESSAGE("GetGroups");
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbGroups() throw (SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::NbGroups()
{
Unexpect aCatch(SALOME_SalomeException);
return _mapGroups.size();
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::UnionListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::IntersectGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr
SMESH_Mesh_i::IntersectListOfGroups(const SMESH::ListOfGroups& theGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMESH::SMESH_Group_ptr SMESH_Mesh_i::CutGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMESH_Mesh_i::CutListOfGroups(const SMESH::ListOfGroups& theMainGroups,
const SMESH::ListOfGroups& theToolGroups,
const char* theName )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
namespace // functions making checks according to SMESH::NB_COMMON_NODES_ENUM
{
- bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isAllNodesCommon(int nbChecked, int nbCommon, int nbNodes, int /*nbCorners*/,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked );
return nbCommon == nbNodes;
}
- bool isMainNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
+ bool isMainNodesCommon(int nbChecked, int nbCommon, int /*nbNodes*/, int nbCorners,
bool & toStopChecking )
{
toStopChecking = ( nbCommon < nbChecked || nbChecked >= nbCorners );
return nbCommon == nbCorners;
}
- bool isAtLeastOneNodeCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isAtLeastOneNodeCommon(int /*nbChecked*/, int nbCommon, int /*nbNodes*/, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon > 0;
}
- bool isMajorityOfNodesCommon(int nbChecked, int nbCommon, int nbNodes, int nbCorners,
- bool & toStopChecking )
+ bool isMajorityOfNodesCommon(int /*nbChecked*/, int nbCommon, int nbNodes, int /*nbCorners*/,
+ bool & /*toStopChecking*/ )
{
return nbCommon >= (nbNodes+1) / 2;
}
const char* theName,
SMESH::NB_COMMON_NODES_ENUM theNbCommonNodes,
CORBA::Boolean theUnderlyingOnly)
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aResGrp;
SMDS_ElemIteratorPtr nIt = elOfType->nodesIterator();
for ( nbChecked = 1; nIt->more() && !toStopChecking; ++nbChecked )
{
- const int nID = nIt->next()->GetID();
+ const smIdType nID = nIt->next()->GetID();
if ( nID < isNodeInGroupsSize && isNodeInGroups[ nID ] &&
isToInclude( nbChecked, ++nbCommon, nbNodes, nbCorners, toStopChecking ))
{
SMESH_Mesh_i::FaceGroupsSeparatedByEdges( CORBA::Double theSharpAngle,
CORBA::Boolean theCreateEdges,
CORBA::Boolean theUseExistingEdges )
- throw (SALOME::SALOME_Exception)
{
if ( theSharpAngle < 0 || theSharpAngle > 180 )
THROW_SALOME_CORBA_EXCEPTION("Invalid sharp angle, it must be between 0 and 180 degrees",
//================================================================================
void SMESH_Mesh_i::ReplaceShape(GEOM::GEOM_Object_ptr theNewGeom)
- throw (SALOME::SALOME_Exception)
{
// check if geometry changed
bool geomChanged = true;
GEOM::GEOM_Object_var oldGeom = GetShapeToMesh();
if ( !theNewGeom->_is_nil() && !oldGeom->_is_nil() )
- geomChanged = ( //oldGeom->_is_equivalent( theNewGeom ) ||
- oldGeom->GetTick() < theNewGeom->GetTick() );
+ geomChanged = ( oldGeom->GetTick() != theNewGeom->GetTick() );
TopoDS_Shape S = _impl->GetShapeToMesh();
GEOM_Client* geomClient = _gen_i->GetShapeReader();
}
typedef struct {
- int shapeID, fromID, toID; // indices of elements of a sub-mesh
+ int shapeID; smIdType fromID, toID; // indices of elements of a sub-mesh
} TRange;
std::vector< TRange > elemRanges, nodeRanges; // elements of sub-meshes
std::vector< SMDS_PositionPtr > positions; // node positions
while ( elemIt->more() )
{
const SMDS_MeshElement* e = elemIt->next();
- const int elemID = e->GetID();
+ const smIdType elemID = e->GetID();
const int shapeID = e->GetShapeID();
TRange & lastRange = ranges.back();
if ( lastRange.shapeID != shapeID ||
if ( !theIsBreakLink )
if ( mainGO->GetType() == GEOM_GROUP || !geomChanged ) // is group or not modified
{
- int nb = NbNodes() + NbElements();
+ smIdType nb = NbNodes() + NbElements();
CheckGeomGroupModif();
if ( nb != NbNodes() + NbElements() ) // something removed due to hypotheses change
_gen_i->UpdateIcons( me );
if ( !_impl->HasShapeToMesh() ) return;
- CORBA::Long nbEntities = NbNodes() + NbElements();
+ SMESH::smIdType nbEntities = NbNodes() + NbElements();
// Check if group contents changed
// Update icons
- CORBA::Long newNbEntities = NbNodes() + NbElements();
+ SMESH::smIdType newNbEntities = NbNodes() + NbElements();
list< SALOMEDS::SObject_wrap > soToUpdateIcons;
if ( newNbEntities != nbEntities )
{
//=============================================================================
SMESH::SMESH_Group_ptr SMESH_Mesh_i::ConvertToStandalone( SMESH::SMESH_GroupBase_ptr theGroup )
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_Group_var aGroup;
SALOMEDS::StudyBuilder_var builder;
SALOMEDS::SObject_wrap aGroupSO;
- SALOMEDS::Study_var aStudy = SMESH_Gen_i::getStudyServant();
+ SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant();
if ( !aStudy->_is_nil() ) {
builder = aStudy->NewBuilder();
aGroupSO = _gen_i->ObjectToSObject( theGroup );
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( subMesh );
if(MYDEBUG) { MESSAGE( "Add submesh to map with id = "<< nextId); }
- else { nextId = 0; } // avoid "unused variable" warning
+ else { (void)nextId; } // avoid "unused variable" warning
// to track changes of GEOM groups
if ( subMeshId > 0 )
//================================================================================
SMESH::log_array * SMESH_Mesh_i::GetLog(CORBA::Boolean clearAfterGet)
- throw(SALOME::SALOME_Exception)
{
SMESH::log_array_var aLog;
while(its != logDS.end()){
SMESHDS_Command *com = *its;
int comType = com->GetType();
- int lgcom = com->GetNumber();
- const list < int >&intList = com->GetIndexes();
+ smIdType lgcom = com->GetNumber();
+ const list < smIdType >&intList = com->GetIndexes();
int inum = intList.size();
- list < int >::const_iterator ii = intList.begin();
+ list < smIdType >::const_iterator ii = intList.begin();
const list < double >&coordList = com->GetCoords();
int rnum = coordList.size();
list < double >::const_iterator ir = coordList.begin();
*/
//================================================================================
-void SMESH_Mesh_i::ClearLog() throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ClearLog()
{
SMESH_TRY;
_impl->ClearLog();
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::GetId()throw(SALOME::SALOME_Exception)
+CORBA::Long SMESH_Mesh_i::GetId()
{
return _id;
}
{
SMESH_Mesh_i* _mesh;
TCallUp_i(SMESH_Mesh_i* mesh):_mesh(mesh) {}
- virtual void RemoveGroup (const int theGroupID) { _mesh->removeGroup( theGroupID ); }
- virtual void HypothesisModified( int hypID,
- bool updIcons) { _mesh->onHypothesisModified( hypID,
- updIcons ); }
- virtual void Load () { _mesh->Load(); }
- virtual bool IsLoaded() { return _mesh->IsLoaded(); }
+ void RemoveGroup (const int theGroupID) override { _mesh->removeGroup( theGroupID ); }
+ void HypothesisModified( int hypID,
+ bool updIcons) override { _mesh->onHypothesisModified( hypID,
+ updIcons ); }
+ void Load () override { _mesh->Load(); }
+ bool IsLoaded() override { return _mesh->IsLoaded(); }
+ TopoDS_Shape GetShapeByEntry(const std::string& entry) override
+ {
+ GEOM::GEOM_Object_var go = SMESH_Gen_i::GetGeomObjectByEntry( entry );
+ return SMESH_Gen_i::GeomObjectToShape( go );
+ }
};
}
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditor()
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
//=============================================================================
SMESH::SMESH_MeshEditor_ptr SMESH_Mesh_i::GetMeshEditPreviewer()
- throw (SALOME::SALOME_Exception)
{
SMESH::SMESH_MeshEditor_var aMeshEdVar;
*/
//================================================================================
-CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::HasModificationsToDiscard()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->HasModificationsToDiscard();
*/
//=============================================================================
-void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor) throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::SetAutoColor(CORBA::Boolean theAutoColor)
{
Unexpect aCatch(SALOME_SalomeException);
_impl->SetAutoColor(theAutoColor);
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::GetAutoColor() throw(SALOME::SALOME_Exception)
+CORBA::Boolean SMESH_Mesh_i::GetAutoColor()
{
Unexpect aCatch(SALOME_SalomeException);
return _impl->GetAutoColor();
}
}
+/*!
+ Return a MeshName
+ */
+std::string SMESH_Mesh_i::generateMeshName()
+{
+ string aMeshName = "Mesh";
+ SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant();
+ if ( !aStudy->_is_nil() )
+ {
+ SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( _this() );
+ if ( !aMeshSO->_is_nil() )
+ {
+ CORBA::String_var name = aMeshSO->GetName();
+ aMeshName = name;
+ }
+ }
+ return aMeshName;
+}
+
//================================================================================
/*!
* \brief Prepare a file for export and pass names of mesh groups from study to mesh DS
{
// Perform Export
PrepareForWriting(file, overwrite);
- string aMeshName = "Mesh";
- SALOMEDS::Study_var aStudy = SMESH_Gen_i::getStudyServant();
+ string aMeshName(this->generateMeshName());
+ SALOMEDS::Study_var aStudy = SMESH_Gen_i::GetSMESHGen()->getStudyServant();
if ( !aStudy->_is_nil() ) {
SALOMEDS::SObject_wrap aMeshSO = _gen_i->ObjectToSObject( _this() );
if ( !aMeshSO->_is_nil() ) {
- CORBA::String_var name = aMeshSO->GetName();
- aMeshName = name;
// asv : 27.10.04 : fix of 6903: check for StudyLocked before adding attributes
if ( !aStudy->GetProperties()->IsLocked() )
{
*/
//================================================================================
-void SMESH_Mesh_i::ExportMED(const char* file,
- CORBA::Boolean auto_groups,
- CORBA::Long version,
- CORBA::Boolean overwrite,
- CORBA::Boolean autoDimension)
- throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ExportMED(const char* file,
+ CORBA::Boolean auto_groups,
+ CORBA::Long version,
+ CORBA::Boolean overwrite,
+ CORBA::Boolean autoDimension)
{
//MESSAGE("MED minor version: "<< minor);
SMESH_TRY;
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportMED( r'"
<< file << "', "
<< "auto_groups=" <<auto_groups << ", "
- << "minor=" << version << ", "
+ << "version=" << version << ", "
<< "overwrite=" << overwrite << ", "
<< "meshPart=None, "
<< "autoDimension=" << autoDimension << " )";
SMESH_CATCH( SMESH::throwCorbaException );
}
+CORBA::LongLong SMESH_Mesh_i::ExportMEDCoupling(CORBA::Boolean auto_groups, CORBA::Boolean autoDimension)
+{
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> data;
+ SMESH_TRY;
+ // TODO : Fix me ! 2 next lines are required
+ if( !this->_gen_i->isSSLMode() )
+ SMESH::throwCorbaException("SMESH_Mesh_i::ExportMEDCoupling : only for embedded mode !");
+ if ( _preMeshInfo )
+ _preMeshInfo->FullLoadFromFile();
+
+ string aMeshName = this->generateMeshName();
+ data = _impl->ExportMEDCoupling( aMeshName.c_str(), auto_groups, 0, autoDimension );
+ SMESH_CATCH( SMESH::throwCorbaException );
+ MEDCoupling::DataArrayByte *ret(data.retn());
+ return reinterpret_cast<CORBA::LongLong>(ret);
+}
+
//================================================================================
/*!
* \brief Export a mesh to a SAUV file
*/
//================================================================================
-void SMESH_Mesh_i::ExportSAUV (const char* file,
- CORBA::Boolean auto_groups)
- throw(SALOME::SALOME_Exception)
+void SMESH_Mesh_i::ExportSAUV( const char* file, CORBA::Boolean auto_groups )
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var( _this())
<< ".ExportSAUV( r'" << file << "', " << auto_groups << " )";
_impl->ExportSAUV(file, aMeshName.c_str(), auto_groups);
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
void SMESH_Mesh_i::ExportDAT (const char *file)
- throw(SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- // Update Python script
// check names of groups
checkGroupNames();
+ // Update Python script
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportDAT( r'" << file << "' )";
// Perform Export
PrepareForWriting(file);
_impl->ExportDAT(file);
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
//================================================================================
void SMESH_Mesh_i::ExportUNV (const char *file)
- throw(SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- // Update Python script
// check names of groups
checkGroupNames();
+ // Update Python script
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportUNV( r'" << file << "' )";
// Perform Export
PrepareForWriting(file);
_impl->ExportUNV(file);
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
//================================================================================
void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
- throw(SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- // Update Python script
// check names of groups
checkGroupNames();
+ // Update Python script
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportSTL( r'" << file << "', " << isascii << " )";
// Perform Export
PrepareForWriting( file );
_impl->ExportSTL( file, isascii, name.in() );
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
-//================================================================================
-/*!
- * \brief Export a part of mesh to a med file
- */
-//================================================================================
+class MEDFileSpeCls
+{
+public:
+ MEDFileSpeCls(const char *file, CORBA::Boolean overwrite, CORBA::Long version):_file(file),_overwrite(overwrite),_version(version) { }
+ std::string prepareMeshNameAndGroups(SMESH_Mesh_i& self) { return self.prepareMeshNameAndGroups(_file.c_str(),_overwrite); }
+ void exportTo(SMESH_Mesh *mesh, const std::string& aMeshName, CORBA::Boolean auto_groups,
+ SMESH_MeshPartDS* partDS,
+ CORBA::Boolean autoDimension, bool have0dField,
+ CORBA::Double ZTolerance)
+ {
+ mesh->ExportMED( _file.c_str(), aMeshName.c_str(), auto_groups, _version,
+ partDS, autoDimension,have0dField,ZTolerance);
-void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
- const char* file,
- CORBA::Boolean auto_groups,
- CORBA::Long version,
- CORBA::Boolean overwrite,
- CORBA::Boolean autoDimension,
- const GEOM::ListOfFields& fields,
- const char* geomAssocFields,
- CORBA::Double ZTolerance)
- throw (SALOME::SALOME_Exception)
+ }
+
+ void exportField(SMESH_Mesh_i& self, const std::string& aMeshName, bool have0dField, SMESHDS_Mesh *meshDS, const GEOM::ListOfFields& fields, const char*geomAssocFields)
+ {
+ DriverMED_W_Field fieldWriter;
+ fieldWriter.SetFile( _file.c_str() );
+ fieldWriter.SetMeshName( aMeshName );
+ fieldWriter.AddODOnVertices( have0dField );
+ self.exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields );
+ }
+
+ void prepareForWriting(SMESH_Mesh_i& self) { self.PrepareForWriting(_file.c_str(), _overwrite); }
+private:
+ std::string _file;
+ CORBA::Boolean _overwrite;
+ CORBA::Long _version;
+};
+
+
+template<class SPECLS>
+void SMESH_Mesh_i::ExportPartToMEDCommon(SPECLS& speCls,
+ SMESH::SMESH_IDSource_ptr meshPart,
+ CORBA::Boolean auto_groups,
+ CORBA::Boolean autoDimension,
+ const GEOM::ListOfFields& fields,
+ const char* geomAssocFields,
+ CORBA::Double ZTolerance)
{
- MESSAGE("MED version: "<< version);
SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
if ( CORBA::is_nil( meshPart ) ||
SMESH::DownCast< SMESH_Mesh_i* >( meshPart ))
{
- aMeshName = prepareMeshNameAndGroups(file, overwrite);
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version,
- 0, autoDimension, /*addODOnVertices=*/have0dField,
- ZTolerance);
+ aMeshName = speCls.prepareMeshNameAndGroups(*this);
+ speCls.exportTo(_impl, aMeshName, auto_groups, nullptr, autoDimension, have0dField, ZTolerance);
meshDS = _impl->GetMeshDS();
}
else
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- PrepareForWriting(file, overwrite);
+ speCls.prepareForWriting(*this);
SALOMEDS::SObject_wrap SO = _gen_i->ObjectToSObject( meshPart );
if ( !SO->_is_nil() ) {
}
SMESH_MeshPartDS* partDS = new SMESH_MeshPartDS( meshPart );
- _impl->ExportMED( file, aMeshName.c_str(), auto_groups, version,
- partDS, autoDimension, /*addODOnVertices=*/have0dField, ZTolerance);
+ speCls.exportTo(_impl, aMeshName, auto_groups, partDS, autoDimension, have0dField, ZTolerance);
meshDS = tmpDSDeleter._obj = partDS;
}
if ( _impl->HasShapeToMesh() )
{
- DriverMED_W_Field fieldWriter;
- fieldWriter.SetFile( file );
- fieldWriter.SetMeshName( aMeshName );
- fieldWriter.AddODOnVertices( have0dField );
-
- exportMEDFields( fieldWriter, meshDS, fields, geomAssocFields );
+ speCls.exportField(*this,aMeshName,have0dField,meshDS,fields,geomAssocFields);
}
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+//================================================================================
+/*!
+ * \brief Export a part of mesh to a med file
+ */
+//================================================================================
+
+void SMESH_Mesh_i::ExportPartToMED(SMESH::SMESH_IDSource_ptr meshPart,
+ const char* file,
+ CORBA::Boolean auto_groups,
+ CORBA::Long version,
+ CORBA::Boolean overwrite,
+ CORBA::Boolean autoDimension,
+ const GEOM::ListOfFields& fields,
+ const char* geomAssocFields,
+ CORBA::Double ZTolerance)
+{
+ MESSAGE("MED version: "<< version);
+ MEDFileSpeCls spe(file,overwrite,version);
+ this->ExportPartToMEDCommon<MEDFileSpeCls>(spe,meshPart,auto_groups,autoDimension,fields,geomAssocFields,ZTolerance);
// dump
+ SMESH_TRY;
GEOM::ListOfGBO_var goList = new GEOM::ListOfGBO;
goList->length( fields.length() );
for ( size_t i = 0; i < fields.length(); ++i )
<< ( geomAssocFields ? geomAssocFields : "" ) << "',"
<< TVar( ZTolerance )
<< " )";
-
SMESH_CATCH( SMESH::throwCorbaException );
}
+class MEDFileMemSpeCls
+{
+public:
+ std::string prepareMeshNameAndGroups(SMESH_Mesh_i& self) { return self.generateMeshName(); }
+ void exportTo(SMESH_Mesh *mesh, const std::string& aMeshName, CORBA::Boolean auto_groups,
+ SMESH_MeshPartDS* partDS,
+ CORBA::Boolean autoDimension, bool have0dField,
+ CORBA::Double ZTolerance)
+ {
+ _res = mesh->ExportMEDCoupling(aMeshName.c_str(),auto_groups,partDS,autoDimension,have0dField,ZTolerance);
+ }
+ void prepareForWriting(SMESH_Mesh_i& self) { /* nothing here */ }
+ void exportField(SMESH_Mesh_i& self, const std::string& aMeshName, bool have0dField, SMESHDS_Mesh *meshDS, const GEOM::ListOfFields& fields, const char*geomAssocFields)
+ {
+ THROW_IK_EXCEPTION("exportField Not implemented yet for full memory !");
+ }
+public:
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> getData() { return _res; }
+private:
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> _res;
+};
+
+CORBA::LongLong SMESH_Mesh_i::ExportPartToMEDCoupling(SMESH::SMESH_IDSource_ptr meshPart,
+ CORBA::Boolean auto_groups,
+ CORBA::Boolean autoDimension,
+ const GEOM::ListOfFields& fields,
+ const char* geomAssocFields,
+ CORBA::Double ZTolerance)
+{
+ MEDFileMemSpeCls spe;
+ this->ExportPartToMEDCommon<MEDFileMemSpeCls>(spe,meshPart,auto_groups,autoDimension,fields,geomAssocFields,ZTolerance);
+ MEDCoupling::MCAuto<MEDCoupling::DataArrayByte> res( spe.getData() );
+ MEDCoupling::DataArrayByte *ret(res.retn());
+ return reinterpret_cast<CORBA::LongLong>(ret);
+}
+
//================================================================================
/*!
* Write GEOM fields to MED file
void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
- throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportPartToDAT( " << meshPart << ", r'" << file << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
/*!
void SMESH_Mesh_i::ExportPartToUNV(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
- throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
/*!
void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
::CORBA::Boolean isascii)
- throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( "
<< meshPart<< ", r'" << file << "', " << isascii << ")";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
const char* file,
CORBA::Boolean overwrite,
CORBA::Boolean groupElemsByType)
- throw (SALOME::SALOME_Exception)
{
#ifdef WITH_CGNS
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportCGNS( "
<< meshPart<< ", r'" << file << "', " << overwrite << ")";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
#else
THROW_SALOME_CORBA_EXCEPTION("CGNS library is unavailable", SALOME::INTERNAL_ERROR);
#endif
void SMESH_Mesh_i::ExportGMF(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file,
bool withRequiredGroups)
- throw (SALOME::SALOME_Exception)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
<< meshPart<< ", r'"
<< file << "', "
<< withRequiredGroups << ")";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbNodes()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbNodes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbElements()throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::Nb0DElements()throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::Nb0DElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBalls() throw (SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbBalls()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbEdges()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbEdges()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbFaces()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbFaces()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbTriangles()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbBiQuadTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadTriangles();
}
-CORBA::Long SMESH_Mesh_i::NbQuadrangles()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbBiQuadQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbPolygons() throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPolygons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolygons();
}
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order) throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolygons((SMDSAbs_ElementOrder)order);
}
-CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbFaces( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTriangles( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbVolumes()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbVolumes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbVolumes();
}
-CORBA::Long SMESH_Mesh_i::NbTetras()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbTetras()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTetras();
}
-CORBA::Long SMESH_Mesh_i::NbHexas()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexas();
}
-CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbTriQuadraticHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTriQuadraticHexas();
}
-CORBA::Long SMESH_Mesh_i::NbPyramids()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPyramids()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPyramids();
}
-CORBA::Long SMESH_Mesh_i::NbPrisms()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbHexagonalPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexagonalPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbPolyhedrons()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPolyhedrons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolyhedrons();
}
-CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbVolumes( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTetras( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexas( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPyramids( (SMDSAbs_ElementOrder) order);
}
-CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
- throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbSubMesh()throw(SALOME::SALOME_Exception)
+SMESH::smIdType SMESH_Mesh_i::NbSubMesh()
{
Unexpect aCatch(SALOME_SalomeException);
return _mapSubMesh_i.size();
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetIDs()
+SMESH::smIdType_array* SMESH_Mesh_i::GetIDs()
{
return GetElementsId();
}
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetElementsId()
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_Mesh_i::GetElementsId()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
if ( aSMESHDS_Mesh == NULL )
return aResult._retn();
- long nbElements = NbElements();
+ smIdType nbElements = NbElements();
aResult->length( nbElements );
SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator();
- for ( int i = 0, n = nbElements; i < n && anIt->more(); i++ )
+ for ( smIdType i = 0, n = nbElements; i < n && anIt->more(); i++ )
aResult[i] = anIt->next()->GetID();
return aResult._retn();
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_Mesh_i::GetElementsByType( SMESH::ElementType theElemType )
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESHDS_Mesh* aSMESHDS_Mesh = _impl->GetMeshDS();
if ( aSMESHDS_Mesh == NULL )
return aResult._retn();
- long nbElements = NbElements();
+ smIdType nbElements = NbElements();
// No sense in returning ids of elements along with ids of nodes:
// when theElemType == SMESH::ALL, return node ids only if
aResult->length( nbElements );
- int i = 0;
+ smIdType i = 0;
SMDS_ElemIteratorPtr anIt = aSMESHDS_Mesh->elementsIterator( (SMDSAbs_ElementType)theElemType );
while ( i < nbElements && anIt->more() )
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetNodesId()
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_Mesh_i::GetNodesId()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
if ( aMeshDS == NULL )
return aResult._retn();
- long nbNodes = NbNodes();
+ smIdType nbNodes = NbNodes();
aResult->length( nbNodes );
SMDS_NodeIteratorPtr anIt = aMeshDS->nodesIterator();
- for ( int i = 0, n = nbNodes; i < n && anIt->more(); i++ )
+ for ( smIdType i = 0, n = nbNodes; i < n && anIt->more(); i++ )
aResult[i] = anIt->next()->GetID();
return aResult._retn();
*/
//=============================================================================
-SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
- throw (SALOME::SALOME_Exception)
+SMESH::ElementType SMESH_Mesh_i::GetElementType( const SMESH::smIdType id, const bool iselem )
{
SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
*/
//=============================================================================
-SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const CORBA::Long id )
- throw (SALOME::SALOME_Exception)
+SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const SMESH::smIdType id )
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
- throw (SALOME::SALOME_Exception)
+SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const SMESH::smIdType id )
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
+SMESH::smIdType_array* SMESH_Mesh_i::GetSubMeshElementsId(const CORBA::Long ShapeID)
{
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESH_TRY;
if ( _preMeshInfo )
aResult->length(SDSM->NbElements());
SMDS_ElemIteratorPtr eIt = SDSM->GetElements();
- int i = 0;
+ smIdType i = 0;
while ( eIt->more() ) {
aResult[i++] = eIt->next()->GetID();
}
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
+SMESH::smIdType_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
CORBA::Boolean all)
- throw (SALOME::SALOME_Exception)
{
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESH_TRY;
if ( _preMeshInfo )
SMESHDS_SubMesh* SDSM = SM->GetSubMeshDS();
if(!SDSM) return aResult._retn();
- set<int> theElems;
+ set<smIdType> theElems;
if( !all || (SDSM->NbElements()==0) ) { // internal nodes or vertex submesh
SMDS_NodeIteratorPtr nIt = SDSM->GetNodes();
while ( nIt->more() ) {
}
aResult->length(theElems.size());
- set<int>::iterator itElem;
- int i = 0;
+ set<smIdType>::iterator itElem;
+ smIdType i = 0;
for ( itElem = theElems.begin(); itElem != theElems.end(); itElem++ )
aResult[i++] = *itElem;
//=============================================================================
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
- throw (SALOME::SALOME_Exception)
{
SMESH::ElementType type = SMESH::ALL;
*/
//=============================================================================
-SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const CORBA::Long id)
+SMESH::double_array* SMESH_Mesh_i::GetNodeXYZ(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetNodeInverseElements(const CORBA::Long id,
- SMESH::ElementType elemType)
+SMESH::smIdType_array* SMESH_Mesh_i::GetNodeInverseElements(const SMESH::smIdType id,
+ SMESH::ElementType elemType)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS();
if ( aMeshDS == NULL )
return aResult._retn();
SMDSAbs_ElementType type = SMDSAbs_ElementType( elemType );
SMDS_ElemIteratorPtr eIt = aNode->GetInverseElementIterator( type );
aResult->length( aNode->NbInverseElements( type ));
- for( int i = 0; eIt->more(); ++i )
+ for( smIdType i = 0; eIt->more(); ++i )
{
const SMDS_MeshElement* elem = eIt->next();
aResult[ i ] = elem->GetID();
*/
//=============================================================================
-SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID)
+SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(SMESH::smIdType NodeID)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(CORBA::Long ElemID)
+SMESH::ElementPosition SMESH_Mesh_i::GetElementPosition(SMESH::smIdType ElemID)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id)
+CORBA::Long SMESH_Mesh_i::GetShapeID(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const CORBA::Long id)
+CORBA::Long SMESH_Mesh_i::GetShapeIDForElem(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::GetElemNbNodes(const CORBA::Long id)
+CORBA::Short SMESH_Mesh_i::GetElemNbNodes(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::GetElemNode(const CORBA::Long id, const CORBA::Long index)
+SMESH::smIdType SMESH_Mesh_i::GetElemNode(const SMESH::smIdType id, const CORBA::Short index)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetElemNodes(const CORBA::Long id)
+SMESH::smIdType_array* SMESH_Mesh_i::GetElemNodes(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
{
if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(id) )
{
aResult->length( elem->NbNodes() );
- for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
+ for ( SMESH::smIdType i = 0; i < aResult->length(); ++i )
if ( const SMDS_MeshNode* n = elem->GetNode( i ))
aResult[ i ] = n->GetID();
}
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const CORBA::Long ide, const CORBA::Long idn)
+CORBA::Boolean SMESH_Mesh_i::IsMediumNode(const SMESH::smIdType ide, const SMESH::smIdType idn)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const CORBA::Long idn,
+CORBA::Boolean SMESH_Mesh_i::IsMediumNodeOfAnyElem(const SMESH::smIdType idn,
SMESH::ElementType theElemType)
{
if ( _preMeshInfo )
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::ElemNbEdges(const CORBA::Long id)
+CORBA::Long SMESH_Mesh_i::ElemNbEdges(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::ElemNbFaces(const CORBA::Long id)
+CORBA::Long SMESH_Mesh_i::ElemNbFaces(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//================================================================================
-SMESH::long_array* SMESH_Mesh_i::GetElemFaceNodes(CORBA::Long elemId,
- CORBA::Short faceIndex)
+SMESH::smIdType_array* SMESH_Mesh_i::GetElemFaceNodes(SMESH::smIdType elemId,
+ CORBA::Short faceIndex)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var aResult = new SMESH::long_array();
+ SMESH::smIdType_array_var aResult = new SMESH::smIdType_array();
if ( SMESHDS_Mesh* aMeshDS = _impl->GetMeshDS() )
{
if ( const SMDS_MeshElement* elem = aMeshDS->FindElement(elemId) )
{
aResult->length( vtool.NbFaceNodes( faceIndex ));
const SMDS_MeshNode** nn = vtool.GetFaceNodes( faceIndex );
- for ( CORBA::ULong i = 0; i < aResult->length(); ++i )
+ for ( SMESH::smIdType i = 0; i < aResult->length(); ++i )
aResult[ i ] = nn[ i ]->GetID();
}
}
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes)
+SMESH::smIdType SMESH_Mesh_i::FindElementByNodes(const SMESH::smIdType_array& nodes)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//================================================================================
-SMESH::long_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::long_array& nodes,
- SMESH::ElementType elemType)
+SMESH::smIdType_array* SMESH_Mesh_i::GetElementsByNodes(const SMESH::smIdType_array& nodes,
+ SMESH::ElementType elemType)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
- SMESH::long_array_var result = new SMESH::long_array();
+ SMESH::smIdType_array_var result = new SMESH::smIdType_array();
if ( SMESHDS_Mesh* mesh = _impl->GetMeshDS() )
{
vector< const SMDS_MeshNode * > nn( nodes.length() );
- for ( CORBA::ULong i = 0; i < nodes.length(); ++i )
+ for ( SMESH::smIdType i = 0; i < nodes.length(); ++i )
nn[i] = mesh->FindNode( nodes[i] );
std::vector<const SMDS_MeshElement *> elems;
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::IsPoly(const CORBA::Long id)
+CORBA::Boolean SMESH_Mesh_i::IsPoly(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const CORBA::Long id)
+CORBA::Boolean SMESH_Mesh_i::IsQuadratic(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Double SMESH_Mesh_i::GetBallDiameter(CORBA::Long id)
+CORBA::Double SMESH_Mesh_i::GetBallDiameter(SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::double_array* SMESH_Mesh_i::BaryCenter(const CORBA::Long id)
+SMESH::double_array* SMESH_Mesh_i::BaryCenter(const SMESH::smIdType id)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
SMESH::ListOfGroups*
SMESH_Mesh_i::MakeGroupsOfBadInputElements( int theSubShapeID,
const char* theGroupName )
- throw ( SALOME::SALOME_Exception )
{
Unexpect aCatch(SALOME_SalomeException);
// register CORBA object for persistence
int nextId = _gen_i->RegisterObject( groupVar );
if(MYDEBUG) { MESSAGE( "Add group 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
// publishing the groups in the study
GEOM::GEOM_Object_var shapeVar = _gen_i->ShapeToGeomObject( shape );
SMESH_Gen_i *gen = SMESH_Gen_i::GetSMESHGen();
if(gen) {
CORBA::String_var aParameters = GetParameters();
- SALOMEDS::ListOfListOfStrings_var aSections = SMESH_Gen_i::getStudyServant()->ParseVariables(aParameters);
+ SALOMEDS::ListOfListOfStrings_var aSections = SMESH_Gen_i::GetSMESHGen()->getStudyServant()->ParseVariables(aParameters);
if ( aSections->length() > 0 ) {
SALOMEDS::ListOfStrings aVars = aSections[ aSections->length() - 1 ];
aResult->length( aVars.length() );
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetMeshInfo()
+SMESH::smIdType_array* SMESH_Mesh_i::GetMeshInfo()
{
if ( _preMeshInfo )
return _preMeshInfo->GetMeshInfo();
- SMESH::long_array_var aRes = new SMESH::long_array();
+ SMESH::smIdType_array_var aRes = new SMESH::smIdType_array();
aRes->length(SMESH::Entity_Last);
for (int i = SMESH::Entity_Node; i < SMESH::Entity_Last; i++)
aRes[i] = 0;
*/
//=============================================================================
-SMESH::long_array* SMESH_Mesh_i::GetNbElementsByType()
+SMESH::smIdType_array* SMESH_Mesh_i::GetNbElementsByType()
{
- SMESH::long_array_var aRes = new SMESH::long_array();
+ SMESH::smIdType_array_var aRes = new SMESH::smIdType_array();
aRes->length(SMESH::NB_ELEMENT_TYPES);
- for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ for (smIdType i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
aRes[ i ] = 0;
const SMDS_MeshInfo* meshInfo = 0;
meshInfo = & meshDS->GetMeshInfo();
if (meshInfo)
- for (int i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
+ for (smIdType i = 0; i < SMESH::NB_ELEMENT_TYPES; i++)
aRes[i] = meshInfo->NbElements((SMDSAbs_ElementType)i);
return aRes._retn();
//=============================================================================
void SMESH_Mesh_i::CollectMeshInfo(const SMDS_ElemIteratorPtr theItr,
- SMESH::long_array& theInfo)
+ SMESH::smIdType_array& theInfo)
{
if (!theItr) return;
while (theItr->more())
//-----------------------------------------------------------------------------
struct IDSourceIterator : public SMDS_ElemIterator
{
- const CORBA::Long* _idPtr;
- const CORBA::Long* _idEndPtr;
- SMESH::long_array_var _idArray;
- const SMDS_Mesh* _mesh;
- const SMDSAbs_ElementType _type;
- const SMDS_MeshElement* _elem;
-
- IDSourceIterator( const SMDS_Mesh* mesh,
- const CORBA::Long* ids,
- const int nbIds,
- SMDSAbs_ElementType type):
+ const SMESH::smIdType* _idPtr;
+ const SMESH::smIdType* _idEndPtr;
+ SMESH::smIdType_array_var _idArray;
+ const SMDS_Mesh* _mesh;
+ const SMDSAbs_ElementType _type;
+ const SMDS_MeshElement* _elem;
+
+ IDSourceIterator( const SMDS_Mesh* mesh,
+ const SMESH::smIdType* ids,
+ const smIdType nbIds,
+ SMDSAbs_ElementType type):
_idPtr( ids ), _idEndPtr( ids + nbIds ), _mesh( mesh ), _type( type ), _elem( 0 )
{
if ( _idPtr && nbIds && _mesh )
next();
}
- IDSourceIterator( const SMDS_Mesh* mesh,
- SMESH::long_array* idArray,
- SMDSAbs_ElementType type):
+ IDSourceIterator( const SMDS_Mesh* mesh,
+ SMESH::smIdType_array* idArray,
+ SMDSAbs_ElementType type):
_idPtr( 0 ), _idEndPtr( 0 ), _idArray( idArray), _mesh( mesh ), _type( type ), _elem( 0 )
{
if ( idArray && _mesh )
SMDSAbs_ElementType iterType = isNodes ? SMDSAbs_Node : elemType;
if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject ))
{
- int nbIds;
- if ( CORBA::Long* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds ))
+ SMESH::smIdType nbIds;
+ if ( SMESH::smIdType* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds ))
elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, iterType ));
}
else
{
- SMESH::long_array_var ids = theObject->GetIDs();
+ SMESH::smIdType_array_var ids = theObject->GetIDs();
elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids._retn(), iterType ));
}
typeOK = ( isNodes == ( elemType == SMDSAbs_Node )) || ( elemType == SMDSAbs_All );
TopTools_MapIteratorOfMapOfShape anItr( theToCheck );
for (; !isShared && anItr.More(); anItr.Next() )
{
- const TopoDS_Shape aSubSh = anItr.Key();
+ const TopoDS_Shape& aSubSh = anItr.Key();
// check for case when concurrent dimensions are same
isShared = theToFind.Contains( aSubSh );
// check for sub-shape with concurrent dimension
}
//-----------------------------------------------------------------------------
-void unionLists(TListOfInt& theListOfId,
+bool unionLists(TListOfInt& theListOfId,
TListOfListOfInt& theListOfListOfId,
const int theIndx )
{
+ bool changed = false;
+ if ( theListOfId.empty() )
+ return changed;
TListOfListOfInt::iterator it = theListOfListOfId.begin();
for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
{
TListOfInt::iterator it2 = otherListOfId.begin();
for ( ; it2 != otherListOfId.end(); it2++ ) {
if ( find( theListOfId.begin(), theListOfId.end(), (*it2) ) == theListOfId.end() )
+ {
theListOfId.push_back(*it2);
+ changed = true;
+ }
}
// clear source list
otherListOfId.clear();
}
+ return changed;
}
//-----------------------------------------------------------------------------
TListOfListOfInt allConurrent = findConcurrentSubMeshes();
anOrder.splice( anOrder.end(), allConurrent );
- int listIndx = 0;
- TListOfListOfInt::iterator listIt = anOrder.begin();
- for(; listIt != anOrder.end(); listIt++, listIndx++ )
- unionLists( *listIt, anOrder, listIndx + 1 );
+ bool changed;
+ do {
+ changed = false;
+ TListOfListOfInt::iterator listIt = anOrder.begin();
+ for ( int listIndx = 1; listIt != anOrder.end(); listIt++, listIndx++ )
+ if ( unionLists( *listIt, anOrder, listIndx ))
+ changed = true;
+ }
+ while ( changed );
// convert submesh ids into interface instances
// and dump command into python
else
{
TMeshInfo tmpInfo;
- SMESH::long_array_var anIDs = meshPart->GetIDs();
+ SMESH::smIdType_array_var anIDs = meshPart->GetIDs();
SMESH::array_of_ElementType_var types = meshPart->GetTypes();
if ( types->length() == 1 && types[0] == SMESH::NODE ) // group of nodes
{
MaxElementID() != NbElements() );
}
// -------------------------------------------------------------------------------------
-int SMESH_MeshPartDS::MaxNodeID() const
+smIdType SMESH_MeshPartDS::MaxNodeID() const
{
if ( _meshDS ) return _meshDS->MaxNodeID();
return NbNodes() == 0 ? 0 : (*_elements[ SMDSAbs_Node ].rbegin())->GetID();
}
// -------------------------------------------------------------------------------------
-int SMESH_MeshPartDS::MinNodeID() const
+smIdType SMESH_MeshPartDS::MinNodeID() const
{
if ( _meshDS ) return _meshDS->MinNodeID();
return NbNodes() == 0 ? 0 : (*_elements[ SMDSAbs_Node ].begin())->GetID();
}
// -------------------------------------------------------------------------------------
-int SMESH_MeshPartDS::MaxElementID() const
+smIdType SMESH_MeshPartDS::MaxElementID() const
{
if ( _meshDS ) return _meshDS->MaxElementID();
- int maxID = 0;
+ smIdType maxID = 0;
for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType )
if ( !_elements[ iType ].empty() )
- maxID = Max( maxID, (*_elements[ iType ].rbegin())->GetID() );
+ maxID = std::max( maxID, (*_elements[ iType ].rbegin())->GetID() );
return maxID;
}
// -------------------------------------------------------------------------------------
-int SMESH_MeshPartDS::MinElementID() const
+smIdType SMESH_MeshPartDS::MinElementID() const
{
if ( _meshDS ) return _meshDS->MinElementID();
- int minID = 0;
+ smIdType minID = 0;
for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType )
if ( !_elements[ iType ].empty() )
- minID = Min( minID, (*_elements[ iType ].begin())->GetID() );
+ minID = std::min( minID, (*_elements[ iType ].begin())->GetID() );
return minID;
}
// -------------------------------------------------------------------------------------
