#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!
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() );
}
{
Unexpect aCatch(SALOME_SalomeException);
- const int prevNbMeshEnt = NbNodes() + NbElements();
+ const smIdType prevNbMeshEnt = NbNodes() + NbElements();
if ( _preMeshInfo )
_preMeshInfo->ForgetOrLoad();
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 );
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 ))
{
}
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 )
{
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::ExportMED(const char* file,
- CORBA::Boolean auto_groups,
- CORBA::Long version,
- CORBA::Boolean overwrite,
- CORBA::Boolean autoDimension)
+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;
*/
//================================================================================
-void SMESH_Mesh_i::ExportSAUV (const char* file,
- CORBA::Boolean auto_groups)
+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)
{
- 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)
{
- 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)
{
- 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 );
}
//================================================================================
void SMESH_Mesh_i::ExportPartToDAT(::SMESH::SMESH_IDSource_ptr meshPart,
const char* file)
{
- 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)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportPartToUNV( " << meshPart<< ", r'" << file << "' )";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//================================================================================
/*!
const char* file,
::CORBA::Boolean isascii)
{
- 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 );
}
//================================================================================
CORBA::Boolean groupElemsByType)
{
#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
const char* file,
bool withRequiredGroups)
{
- Unexpect aCatch(SALOME_SalomeException);
+ SMESH_TRY;
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
<< meshPart<< ", r'"
<< file << "', "
<< withRequiredGroups << ")";
+
+ SMESH_CATCH( SMESH::throwCorbaException );
}
//=============================================================================
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbNodes()
+SMESH::smIdType SMESH_Mesh_i::NbNodes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbElements()
+SMESH::smIdType SMESH_Mesh_i::NbElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::Nb0DElements()
+SMESH::smIdType SMESH_Mesh_i::Nb0DElements()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBalls()
+SMESH::smIdType SMESH_Mesh_i::NbBalls()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbEdges()
+SMESH::smIdType SMESH_Mesh_i::NbEdges()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
+SMESH::smIdType SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbFaces()
+SMESH::smIdType SMESH_Mesh_i::NbFaces()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbTriangles()
+SMESH::smIdType SMESH_Mesh_i::NbTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()
+SMESH::smIdType SMESH_Mesh_i::NbBiQuadTriangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadTriangles();
}
-CORBA::Long SMESH_Mesh_i::NbQuadrangles()
+SMESH::smIdType SMESH_Mesh_i::NbQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()
+SMESH::smIdType SMESH_Mesh_i::NbBiQuadQuadrangles()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbBiQuadQuadrangles();
}
-CORBA::Long SMESH_Mesh_i::NbPolygons()
+SMESH::smIdType SMESH_Mesh_i::NbPolygons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolygons();
}
-CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
+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)
+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)
+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)
+SMESH::smIdType SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbVolumes()
+SMESH::smIdType SMESH_Mesh_i::NbVolumes()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbVolumes();
}
-CORBA::Long SMESH_Mesh_i::NbTetras()
+SMESH::smIdType SMESH_Mesh_i::NbTetras()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTetras();
}
-CORBA::Long SMESH_Mesh_i::NbHexas()
+SMESH::smIdType SMESH_Mesh_i::NbHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexas();
}
-CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()
+SMESH::smIdType SMESH_Mesh_i::NbTriQuadraticHexas()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbTriQuadraticHexas();
}
-CORBA::Long SMESH_Mesh_i::NbPyramids()
+SMESH::smIdType SMESH_Mesh_i::NbPyramids()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPyramids();
}
-CORBA::Long SMESH_Mesh_i::NbPrisms()
+SMESH::smIdType SMESH_Mesh_i::NbPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()
+SMESH::smIdType SMESH_Mesh_i::NbHexagonalPrisms()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbHexagonalPrisms();
}
-CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
+SMESH::smIdType SMESH_Mesh_i::NbPolyhedrons()
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
return _impl->NbPolyhedrons();
}
-CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
+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)
+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)
+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)
+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)
+SMESH::smIdType SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
{
Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo )
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbSubMesh()
+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()
+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 )
+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()
+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 )
+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 )
+SMESH::EntityType SMESH_Mesh_i::GetElementGeomType( const SMESH::smIdType id )
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-SMESH::GeometryType SMESH_Mesh_i::GetElementShape( const CORBA::Long id )
+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)
+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)
{
- 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::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::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 );
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;
}
// -------------------------------------------------------------------------------------
