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

fix after review. Add SMESH::smIdType. Some error in SMESH_I

Browse Source
This commit is contained in:
Viktor UZLOV 2021-02-04 12:39:13 +03:00
parent 1d40781fa6
commit 237847e7bb
29 changed files with 202 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -80,6 +80,12 @@ IF(SALOME_SMESH_DYNLOAD_LOCAL)
ADD_DEFINITIONS(-DDYNLOAD_LOCAL) ADD_DEFINITIONS(-DDYNLOAD_LOCAL)
ENDIF(SALOME_SMESH_DYNLOAD_LOCAL) ENDIF(SALOME_SMESH_DYNLOAD_LOCAL)
IF(SALOME_USE_64BIT_IDS)
SET(SMESH_ID_TYPE "long long")
ELSE()
SET(SMESH_ID_TYPE "long")
ENDIF()
IF(SMESH_USE_MESHGEMS_HYPOSET) IF(SMESH_USE_MESHGEMS_HYPOSET)
SET(SMESH_USE_MESHGEMS_HYPOSET_VAR "true") SET(SMESH_USE_MESHGEMS_HYPOSET_VAR "true")
ELSE(SMESH_USE_MESHGEMS_HYPOSET) ELSE(SMESH_USE_MESHGEMS_HYPOSET)

6
idl/CMakeLists.txt
View File

@ -26,12 +26,6 @@ INCLUDE_DIRECTORIES(
${PROJECT_BINARY_DIR}/idl ${PROJECT_BINARY_DIR}/idl
) )
IF(SALOME_USE_64_BITS_IDS)
SET(SMESH_ID_TYPE "long long")
ELSE()
SET(SMESH_ID_TYPE "long")
ENDIF()
SALOME_CONFIGURE_FILE(SMESH_smIdType.idl.in SMESH_smIdType.idl) SALOME_CONFIGURE_FILE(SMESH_smIdType.idl.in SMESH_smIdType.idl)
SET(SalomeIDLSMESH_IDLSOURCES SET(SalomeIDLSMESH_IDLSOURCES

7
src/SMDS/SMDS_Downward.cxx
View File

@ -27,6 +27,7 @@
#include <vtkCellType.h> #include <vtkCellType.h>
#include <vtkCellLinks.h> #include <vtkCellLinks.h>
#include <smIdType.hxx>
#include <map> #include <map>
@ -232,7 +233,7 @@ void SMDS_Down1D::compactStorage()
_cellIds.resize(_nbDownCells * _maxId); _cellIds.resize(_nbDownCells * _maxId);
_vtkCellIds.resize(_maxId); _vtkCellIds.resize(_maxId);
int sizeUpCells = 0; smIdType sizeUpCells = 0;
for (int i = 0; i < _maxId; i++) for (int i = 0; i < _maxId; i++)
sizeUpCells += _upCellIdsVector[i].size(); sizeUpCells += _upCellIdsVector[i].size();
_upCellIds.resize(sizeUpCells, -1); _upCellIds.resize(sizeUpCells, -1);
@ -258,8 +259,8 @@ void SMDS_Down1D::compactStorage()
void SMDS_Down1D::addUpCell(int cellId, int upCellId, unsigned char aType) void SMDS_Down1D::addUpCell(int cellId, int upCellId, unsigned char aType)
{ {
//ASSERT((cellId >=0) && (cellId < _maxId)); //ASSERT((cellId >=0) && (cellId < _maxId));
int nbFaces = _upCellIdsVector[cellId].size(); smIdType nbFaces = _upCellIdsVector[cellId].size();
for (int i = 0; i < nbFaces; i++) for (smIdType i = 0; i < nbFaces; i++)
{ {
if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType)) if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType))
{ {

38
src/SMDS/SMDS_ElementFactory.cxx
View File

@ -112,7 +112,7 @@ smIdType SMDS_ElementFactory::GetFreeID()
{ {
if ( myChunksWithUnused.empty() ) if ( myChunksWithUnused.empty() )
{ {
int id0 = myChunks.size() * theChunkSize + 1; smIdType id0 = myChunks.size() * theChunkSize + 1;
myChunks.push_back( new SMDS_ElementChunk( this, id0 )); myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
} }
SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin()); SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
@ -128,12 +128,12 @@ smIdType SMDS_ElementFactory::GetFreeID()
smIdType SMDS_ElementFactory::GetMaxID() smIdType SMDS_ElementFactory::GetMaxID()
{ {
int id = 0; smIdType id = 0;
TIndexRanges usedRanges; TIndexRanges usedRanges;
for ( int i = myChunks.size() - 1; i >= 0; --i ) for ( smIdType i = myChunks.size() - 1; i >= 0; --i )
if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges )) if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
{ {
int index = usedRanges.back().second-1; smIdType index = usedRanges.back().second-1;
id = myChunks[i].Get1stID() + index; id = myChunks[i].Get1stID() + index;
break; break;
} }
@ -171,11 +171,11 @@ smIdType SMDS_ElementFactory::GetMinID()
SMDS_MeshElement* SMDS_ElementFactory::NewElement( const smIdType id ) SMDS_MeshElement* SMDS_ElementFactory::NewElement( const smIdType id )
{ {
int iChunk = ( id - 1 ) / theChunkSize; smIdType iChunk = ( id - 1 ) / theChunkSize;
int index = ( id - 1 ) % theChunkSize; smIdType index = ( id - 1 ) % theChunkSize;
while ((int) myChunks.size() <= iChunk ) while ((int) myChunks.size() <= iChunk )
{ {
int id0 = myChunks.size() * theChunkSize + 1; smIdType id0 = myChunks.size() * theChunkSize + 1;
myChunks.push_back( new SMDS_ElementChunk( this, id0 )); myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
} }
SMDS_MeshElement* e = myChunks[iChunk].Element( index ); SMDS_MeshElement* e = myChunks[iChunk].Element( index );
@ -204,8 +204,8 @@ const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const smIdType id ) co
{ {
if ( id > 0 ) if ( id > 0 )
{ {
int iChunk = ( id - 1 ) / theChunkSize; smIdType iChunk = ( id - 1 ) / theChunkSize;
int index = ( id - 1 ) % theChunkSize; smIdType index = ( id - 1 ) % theChunkSize;
if ( iChunk < (int) myChunks.size() ) if ( iChunk < (int) myChunks.size() )
{ {
const SMDS_MeshElement* e = myChunks[iChunk].Element( index ); const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
@ -219,11 +219,11 @@ const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const smIdType id ) co
/*! /*!
* \brief Return an SMDS ID by a Vtk one * \brief Return an SMDS ID by a Vtk one
* \param [inout] vtkID - Vtk ID * \param [inout] vtkID - Vtk ID
* \return int - SMDS ID * \return smIdType - SMDS ID
*/ */
//================================================================================ //================================================================================
int SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID ) smIdType SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
{ {
if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() ) if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() )
return mySmdsIDs[vtkID] + 1; return mySmdsIDs[vtkID] + 1;
@ -285,7 +285,7 @@ void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
{ {
smIdType newNbCells = NbUsedElements(); smIdType newNbCells = NbUsedElements();
smIdType maxCellID = GetMaxID(); smIdType maxCellID = GetMaxID();
int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize ); smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
theVtkIDsNewToOld.resize( newNbCells ); theVtkIDsNewToOld.resize( newNbCells );
@ -314,7 +314,7 @@ void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
const SMDS_MeshElement* newElem = FindElement( newVtkID ); const SMDS_MeshElement* newElem = FindElement( newVtkID );
if ( !newElem ) if ( !newElem )
newElem = NewElement( newVtkID ); newElem = NewElement( newVtkID );
if ( int shapeID = oldElem->GetShapeID() ) if ( smIdType shapeID = oldElem->GetShapeID() )
const_cast< SMDS_MeshElement* >( newElem )->setShapeID( shapeID ); const_cast< SMDS_MeshElement* >( newElem )->setShapeID( shapeID );
if ( oldID > newNbCells ) if ( oldID > newNbCells )
Free( oldElem ); Free( oldElem );
@ -408,13 +408,13 @@ void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
const SMDS_MeshElement* newNode = FindElement( newID+1 ); const SMDS_MeshElement* newNode = FindElement( newID+1 );
if ( !newNode ) if ( !newNode )
newNode = NewElement( newID+1 ); newNode = NewElement( newID+1 );
int shapeID = oldNode->GetShapeID(); smIdType shapeID = oldNode->GetShapeID();
int shapeDim = GetShapeDim( shapeID ); int shapeDim = GetShapeDim( shapeID );
int iChunk = newID / theChunkSize; smIdType iChunk = newID / theChunkSize;
myChunks[ iChunk ].SetShapeID( newNode, shapeID ); myChunks[ iChunk ].SetShapeID( newNode, shapeID );
if ( shapeDim == 2 || shapeDim == 1 ) if ( shapeDim == 2 || shapeDim == 1 )
{ {
int iChunkOld = oldID / theChunkSize; smIdType iChunkOld = oldID / theChunkSize;
TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode ); TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
TParam* newPos = myChunks[ iChunk ].GetPositionPtr( newNode, /*allocate=*/true ); TParam* newPos = myChunks[ iChunk ].GetPositionPtr( newNode, /*allocate=*/true );
if ( oldPos ) if ( oldPos )
@ -514,7 +514,7 @@ void SMDS_NodeFactory::SetShapeDim( int shapeID, int dim )
*/ */
//================================================================================ //================================================================================
SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ): SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, smIdType id0 ):
myFactory( factory ), myFactory( factory ),
my1stID( id0 )//, my1stID( id0 )//,
//mySubIDSet( 0 ) //mySubIDSet( 0 )
@ -623,7 +623,7 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
size_t i = myFactory->myVtkIDs.size(); size_t i = myFactory->myVtkIDs.size();
myFactory->myVtkIDs.resize( e->GetID() + 100 ); myFactory->myVtkIDs.resize( e->GetID() + 100 );
for ( ; i < myFactory->myVtkIDs.size(); ++i ) for ( ; i < myFactory->myVtkIDs.size(); ++i )
myFactory->myVtkIDs[i] = i; myFactory->myVtkIDs[i] = FromIdType<int>(i);
} }
myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID; myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
@ -647,7 +647,7 @@ void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtk
int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
{ {
size_t dfltVtkID = e->GetID() - 1; size_t dfltVtkID = e->GetID() - 1;
return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID; return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? FromIdType<int>(myFactory->myVtkIDs[ dfltVtkID ]) : FromIdType<int>(dfltVtkID);
} }
//================================================================================ //================================================================================

16
src/SMDS/SMDS_ElementFactory.hxx
View File

@ -69,7 +69,7 @@ protected:
TChunkVector myChunks; // array of chunks of elements TChunkVector myChunks; // array of chunks of elements
TChunkPtrSet myChunksWithUnused; // sorted chunks having unused elements TChunkPtrSet myChunksWithUnused; // sorted chunks having unused elements
std::vector< vtkIdType > myVtkIDs; // myVtkIDs[ smdsID-1 ] == vtkID std::vector< vtkIdType > myVtkIDs; // myVtkIDs[ smdsID-1 ] == vtkID
std::vector< int > mySmdsIDs; // mySmdsIDs[ vtkID ] == smdsID - 1 std::vector< smIdType > mySmdsIDs; // mySmdsIDs[ vtkID ] == smdsID - 1
int myNbUsedElements; // counter of elements int myNbUsedElements; // counter of elements
friend class SMDS_ElementChunk; friend class SMDS_ElementChunk;
@ -121,7 +121,7 @@ public:
void Free( const SMDS_MeshElement* ); void Free( const SMDS_MeshElement* );
//! Return an SMDS ID by a Vtk one //! Return an SMDS ID by a Vtk one
int FromVtkToSmds( vtkIdType vtkID ); smIdType FromVtkToSmds( vtkIdType vtkID );
//! De-allocate all elements //! De-allocate all elements
virtual void Clear(); virtual void Clear();
@ -279,7 +279,7 @@ struct _RangeSet
rNext = mySet.upper_bound( theIndex ); rNext = mySet.upper_bound( theIndex );
r = rNext - 1; r = rNext - 1;
} }
int rSize = Size( r ); // range size smIdType rSize = Size( r ); // range size
attr_t rValue = r->myValue; attr_t rValue = r->myValue;
if ( rValue == theValue ) if ( rValue == theValue )
return rValue; // it happens while compacting return rValue; // it happens while compacting
@ -372,7 +372,7 @@ class SMDS_ElementChunk
{ {
SMDS_ElementFactory* myFactory; // holder of this chunk SMDS_ElementFactory* myFactory; // holder of this chunk
SMDS_MeshElement* myElements; // array of elements SMDS_MeshElement* myElements; // array of elements
int my1stID; // ID of myElements[0] smIdType my1stID; // ID of myElements[0]
TBitSet myMarkedSet; // mark some elements TBitSet myMarkedSet; // mark some elements
TUsedRangeSet myUsedRanges; // ranges of used/unused elements TUsedRangeSet myUsedRanges; // ranges of used/unused elements
TSubIDRangeSet mySubIDRanges; // ranges of elements on the same sub-shape TSubIDRangeSet mySubIDRanges; // ranges of elements on the same sub-shape
@ -383,7 +383,7 @@ class SMDS_ElementChunk
public: public:
SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, int id0 = 0 ); SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, smIdType id0 = 0 );
~SMDS_ElementChunk(); ~SMDS_ElementChunk();
//! Return an element by an index [0,ChunkSize()] //! Return an element by an index [0,ChunkSize()]
@ -405,10 +405,10 @@ public:
static bool IsUsed( const _UsedRange& r ) { return r.myValue; } static bool IsUsed( const _UsedRange& r ) { return r.myValue; }
//! Return index of an element in the chunk //! Return index of an element in the chunk
int Index( const SMDS_MeshElement* e ) const { return e - myElements; } smIdType Index( const SMDS_MeshElement* e ) const { return e - myElements; }
//! Return ID of the 1st element in the chunk //! Return ID of the 1st element in the chunk
int Get1stID() const { return my1stID; } smIdType Get1stID() const { return my1stID; }
//! Return pointer to on-shape-parameters of a node //! Return pointer to on-shape-parameters of a node
TParam* GetPositionPtr( const SMDS_MeshElement* node, bool allocate=false ); TParam* GetPositionPtr( const SMDS_MeshElement* node, bool allocate=false );
@ -565,7 +565,7 @@ SMDS_ElementFactory::GetShapeIterator( int shapeID,
size_t nbElemsToReturn, size_t nbElemsToReturn,
const SMDS_MeshElement* sm1stElem ) const SMDS_MeshElement* sm1stElem )
{ {
int iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0; smIdType iChunk = sm1stElem ? (( sm1stElem->GetID() - 1 ) / ChunkSize()) : 0;
typedef _ChunkIterator< ElemIterator, TSubIDRangeSet > TChuckIterator; typedef _ChunkIterator< ElemIterator, TSubIDRangeSet > TChuckIterator;
return boost::make_shared< TChuckIterator >( myChunks, return boost::make_shared< TChuckIterator >( myChunks,
& SMDS_ElementChunk::GetSubIDRangesMinMax, & SMDS_ElementChunk::GetSubIDRangesMinMax,

4
src/SMDS/SMDS_Mesh.cxx
View File

@ -1359,7 +1359,7 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
//purpose : //purpose :
//======================================================================= //=======================================================================
const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const const SMDS_MeshElement* SMDS_Mesh::FindElement(smIdType IDelem) const
{ {
return myCellFactory->FindElement( IDelem ); return myCellFactory->FindElement( IDelem );
} }
@ -3007,7 +3007,7 @@ void SMDS_Mesh::CompactMesh()
return; return;
} }
int SMDS_Mesh::FromVtkToSmds( int vtkid ) const smIdType SMDS_Mesh::FromVtkToSmds( vtkIdType vtkid ) const
{ {
return myCellFactory->FromVtkToSmds( vtkid ); return myCellFactory->FromVtkToSmds( vtkid );
} }

8
src/SMDS/SMDS_Mesh.hxx
View File

@ -633,9 +633,9 @@ public:
} }
const SMDS_MeshNode *FindNode(smIdType idnode) const; const SMDS_MeshNode *FindNode(smIdType idnode) const;
const SMDS_MeshNode *FindNodeVtk(int idnode) const; const SMDS_MeshNode *FindNodeVtk(vtkIdType idnode) const;
const SMDS_MeshElement *FindElementVtk(int IDelem) const; const SMDS_MeshElement *FindElementVtk(vtkIdType IDelem) const;
virtual const SMDS_MeshElement * FindElement(int IDelem) const; virtual const SMDS_MeshElement * FindElement(smIdType IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n); static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n); static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1, static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
@ -701,7 +701,7 @@ public:
virtual ~SMDS_Mesh(); virtual ~SMDS_Mesh();
double getMaxDim(); double getMaxDim();
int FromVtkToSmds(int vtkid) const; smIdType FromVtkToSmds(vtkIdType vtkid) const;
void dumpGrid(std::string ficdump="dumpGrid"); void dumpGrid(std::string ficdump="dumpGrid");
static int chunkSize; static int chunkSize;

2
src/SMDS/SMDS_MeshElement.hxx
View File

@ -130,7 +130,7 @@ public:
virtual smIdType GetID() const; virtual smIdType GetID() const;
virtual int GetVtkID() const; virtual int GetVtkID() const;
virtual int getshapeId() const { return GetShapeID(); } virtual smIdType getshapeId() const { return GetShapeID(); }
virtual smIdType GetShapeID() const; virtual smIdType GetShapeID() const;
// mark this element; to be used in algos // mark this element; to be used in algos

5
src/SMDS/SMDS_MeshNode.cxx
View File

@ -36,6 +36,7 @@
#include <utilities.h> #include <utilities.h>
#include <Utils_SALOME_Exception.hxx> #include <Utils_SALOME_Exception.hxx>
#include <cassert> #include <cassert>
#include <smIdType.hxx>
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
@ -123,7 +124,7 @@ namespace
for (int i = 0; i < ncells; i++) for (int i = 0; i < ncells; i++)
{ {
int vtkId = cells[i]; int vtkId = cells[i];
int smdsId = myMesh->FromVtkToSmds( vtkId ); smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement( smdsId ); const SMDS_MeshElement* elem = myMesh->FindElement( smdsId );
if ( elem->GetType() == type ) if ( elem->GetType() == type )
{ {
@ -142,7 +143,7 @@ namespace
const SMDS_MeshElement* next() const SMDS_MeshElement* next()
{ {
int vtkId = myCellList[ myIter++ ]; int vtkId = myCellList[ myIter++ ];
int smdsId = myMesh->FromVtkToSmds( vtkId ); smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement(smdsId); const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
if (!elem) if (!elem)
{ {

24
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -191,7 +191,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<smIdType>& idNodesOldToNew,
// Use double type for storing coordinates of nodes instead float. // Use double type for storing coordinates of nodes instead float.
vtkPoints *newPoints = vtkPoints::New(); vtkPoints *newPoints = vtkPoints::New();
newPoints->SetDataType( VTK_DOUBLE ); newPoints->SetDataType( VTK_DOUBLE );
newPoints->SetNumberOfPoints( newNodeSize ); newPoints->SetNumberOfPoints( FromIdType<int>(newNodeSize) );
int i = 0, alreadyCopied = 0; int i = 0, alreadyCopied = 0;
while ( i < oldNodeSize ) while ( i < oldNodeSize )
@ -257,11 +257,11 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<smIdType>& idNodesOldToNew,
vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New(); vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
newTypes->Initialize(); newTypes->Initialize();
newTypes->SetNumberOfValues(newCellSize); newTypes->SetNumberOfValues(FromIdType<int>(newCellSize));
vtkIdTypeArray *newLocations = vtkIdTypeArray::New(); vtkIdTypeArray *newLocations = vtkIdTypeArray::New();
newLocations->Initialize(); newLocations->Initialize();
newLocations->SetNumberOfValues(newCellSize); newLocations->SetNumberOfValues(FromIdType<int>(newCellSize));
std::vector< vtkIdType > pointsCell(1024); // --- points id to fill a new cell std::vector< vtkIdType > pointsCell(1024); // --- points id to fill a new cell
@ -446,15 +446,15 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/)
const SMDS_MeshInfo &meshInfo = _mesh->GetMeshInfo(); const SMDS_MeshInfo &meshInfo = _mesh->GetMeshInfo();
int nbLinTetra = meshInfo.NbTetras (ORDER_LINEAR); int nbLinTetra = FromIdType<int>(meshInfo.NbTetras (ORDER_LINEAR));
int nbQuadTetra = meshInfo.NbTetras (ORDER_QUADRATIC); int nbQuadTetra = FromIdType<int>(meshInfo.NbTetras (ORDER_QUADRATIC));
int nbLinPyra = meshInfo.NbPyramids(ORDER_LINEAR); int nbLinPyra = FromIdType<int>(meshInfo.NbPyramids(ORDER_LINEAR));
int nbQuadPyra = meshInfo.NbPyramids(ORDER_QUADRATIC); int nbQuadPyra = FromIdType<int>(meshInfo.NbPyramids(ORDER_QUADRATIC));
int nbLinPrism = meshInfo.NbPrisms (ORDER_LINEAR); int nbLinPrism = FromIdType<int>(meshInfo.NbPrisms (ORDER_LINEAR));
int nbQuadPrism = meshInfo.NbPrisms (ORDER_QUADRATIC); int nbQuadPrism = FromIdType<int>(meshInfo.NbPrisms (ORDER_QUADRATIC));
int nbLinHexa = meshInfo.NbHexas (ORDER_LINEAR); int nbLinHexa = FromIdType<int>(meshInfo.NbHexas (ORDER_LINEAR));
int nbQuadHexa = meshInfo.NbHexas (ORDER_QUADRATIC); int nbQuadHexa = FromIdType<int>(meshInfo.NbHexas (ORDER_QUADRATIC));
int nbHexPrism = meshInfo.NbHexPrisms(); int nbHexPrism = FromIdType<int>(meshInfo.NbHexPrisms());
int nbLineGuess = int((4.0 / 3.0) * nbLinTetra + 2 * nbLinPrism + 2.5 * nbLinPyra + 3 * nbLinHexa); int nbLineGuess = int((4.0 / 3.0) * nbLinTetra + 2 * nbLinPrism + 2.5 * nbLinPyra + 3 * nbLinHexa);
int nbQuadEdgeGuess = int((4.0 / 3.0) * nbQuadTetra + 2 * nbQuadPrism + 2.5 * nbQuadPyra + 3 * nbQuadHexa); int nbQuadEdgeGuess = int((4.0 / 3.0) * nbQuadTetra + 2 * nbQuadPrism + 2.5 * nbQuadPyra + 3 * nbQuadHexa);

10
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -978,14 +978,14 @@ namespace
{ {
if (( myOri = ( n1->GetID() < n2->GetID() ))) if (( myOri = ( n1->GetID() < n2->GetID() )))
{ {
first = n1->GetID(); first = FromIdType<int>(n1->GetID());
second = n2->GetID(); second = FromIdType<int>(n2->GetID());
} }
else else
{ {
myOri = -1; myOri = -1;
first = n2->GetID(); first = FromIdType<int>(n2->GetID());
second = n1->GetID(); second = FromIdType<int>(n1->GetID());
} }
myOri *= ori; myOri *= ori;
} }
@ -2212,5 +2212,5 @@ const SMDS_MeshVolume* SMDS_VolumeTool::Element() const
int SMDS_VolumeTool::ID() const int SMDS_VolumeTool::ID() const
{ {
return myVolume ? myVolume->GetID() : 0; return myVolume ? FromIdType<int>(myVolume->GetID()) : 0;
} }

1
src/SMDS/SMDS_VolumeTool.hxx
View File

@ -30,6 +30,7 @@
#define SMDS_VolumeTool_HeaderFile #define SMDS_VolumeTool_HeaderFile
#include "SMESH_SMDS.hxx" #include "SMESH_SMDS.hxx"
#include <smIdType.hxx>
class SMDS_MeshElement; class SMDS_MeshElement;
class SMDS_MeshNode; class SMDS_MeshNode;

2
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -220,7 +220,7 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
const SMDS_MeshNode * nodes[], const SMDS_MeshNode * nodes[],
const smIdType nbnodes) const smIdType nbnodes)
{ {
if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes )) if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, FromIdType<int>(nbnodes) ))
return false; return false;
std::vector<smIdType> IDs( nbnodes ); std::vector<smIdType> IDs( nbnodes );

2
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -106,7 +106,7 @@ void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * elem)
AddNode( static_cast< const SMDS_MeshNode* >( elem )); AddNode( static_cast< const SMDS_MeshNode* >( elem ));
return; return;
} }
int oldShapeId = elem->GetShapeID(); smIdType oldShapeId = elem->GetShapeID();
if ( oldShapeId > 0 ) if ( oldShapeId > 0 )
{ {
if (oldShapeId != myIndex) if (oldShapeId != myIndex)

1
src/SMESHDS/SMESHDS_SubMesh.hxx
View File

@ -31,6 +31,7 @@
#include "SMDS_ElementHolder.hxx" #include "SMDS_ElementHolder.hxx"
#include "SMDS_Mesh.hxx" #include "SMDS_Mesh.hxx"
#include <smIdType.hxx>
#include <vector> #include <vector>
#include <boost/container/flat_set.hpp> #include <boost/container/flat_set.hpp>

6
src/SMESH_I/SMESH_Filter_i.hxx
View File

@ -106,7 +106,7 @@ namespace SMESH
CORBA::Boolean isLogarithmic, CORBA::Boolean isLogarithmic,
SMESH::SMESH_IDSource_ptr object); SMESH::SMESH_IDSource_ptr object);
void SetPrecision( CORBA::Long thePrecision ); void SetPrecision( CORBA::Long thePrecision );
CORBA::Long GetPrecision(); SMESH::smIdType GetPrecision();
Controls::NumericalFunctorPtr GetNumericalFunctor(); Controls::NumericalFunctorPtr GetNumericalFunctor();
protected: protected:
@ -365,7 +365,7 @@ namespace SMESH
{ {
public: public:
CORBA::Boolean IsSatisfy( CORBA::Long theElementId ); CORBA::Boolean IsSatisfy( CORBA::Long theElementId );
CORBA::Long NbSatisfying( SMESH::SMESH_IDSource_ptr obj ); SMESH::smIdType NbSatisfying( SMESH::SMESH_IDSource_ptr obj );
Controls::PredicatePtr GetPredicate(); Controls::PredicatePtr GetPredicate();
protected: protected:
@ -1081,7 +1081,7 @@ namespace SMESH
CORBA::Boolean SaveAs( const char* aFileName ); CORBA::Boolean SaveAs( const char* aFileName );
CORBA::Boolean IsPresent( const char* aFilterName ); CORBA::Boolean IsPresent( const char* aFilterName );
CORBA::Long NbFilters( ElementType ); SMESH::smIdType NbFilters( ElementType );
string_array* GetNames( ElementType ); string_array* GetNames( ElementType );
string_array* GetAllNames(); string_array* GetAllNames();
void SetFileName( const char* theFileName ); void SetFileName( const char* theFileName );

2
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -6248,7 +6248,7 @@ int SMESH_Gen_i::RegisterObject(CORBA::Object_ptr theObject)
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Gen_i::GetObjectId(CORBA::Object_ptr theObject) SMESH::smIdType SMESH_Gen_i::GetObjectId(CORBA::Object_ptr theObject)
{ {
if ( myStudyContext && !CORBA::is_nil( theObject )) { if ( myStudyContext && !CORBA::is_nil( theObject )) {
string iorString = GetORB()->object_to_string( theObject ); string iorString = GetORB()->object_to_string( theObject );

5
src/SMESH_I/SMESH_Gen_i.hxx
View File

@ -45,6 +45,7 @@
#include <Utils_CorbaException.hxx> #include <Utils_CorbaException.hxx>
#include <GEOM_Client.hxx> #include <GEOM_Client.hxx>
#include <smIdType.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx> #include <Resource_DataMapOfAsciiStringAsciiString.hxx>
@ -70,7 +71,7 @@ public:
// register object in the internal map and return its id // register object in the internal map and return its id
int addObject( const std::string& theIOR ); int addObject( const std::string& theIOR );
// find the object id in the internal map by the IOR // find the object id in the internal map by the IOR
int findId( const std::string& theIOR ); smIdType findId( const std::string& theIOR );
// get object's IOR by id // get object's IOR by id
std::string getIORbyId( const int theId ); std::string getIORbyId( const int theId );
// get object's IOR by old id // get object's IOR by old id
@ -536,7 +537,7 @@ public:
int RegisterObject(CORBA::Object_ptr theObject); int RegisterObject(CORBA::Object_ptr theObject);
// Return id of registered object // Return id of registered object
CORBA::Long GetObjectId(CORBA::Object_ptr theObject); SMESH::smIdType GetObjectId(CORBA::Object_ptr theObject);
// Return an object that previously had an oldID // Return an object that previously had an oldID
template<class TInterface> template<class TInterface>

2
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -1537,7 +1537,7 @@ int StudyContext::addObject( const std::string& theIOR )
//purpose : find the object id in the internal map by the IOR //purpose : find the object id in the internal map by the IOR
//======================================================================= //=======================================================================
int StudyContext::findId( const std::string& theIOR ) smIdType StudyContext::findId( const std::string& theIOR )
{ {
TInt2StringMap::iterator imap; TInt2StringMap::iterator imap;
for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) { for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {

18
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -209,7 +209,7 @@ SMESH::ElementType SMESH_GroupBase_i::GetType()
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_GroupBase_i::Size() SMESH::smIdType SMESH_GroupBase_i::Size()
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
return GetType() == SMESH::NODE ? myPreMeshInfo->NbNodes() : myPreMeshInfo->NbElements(); return GetType() == SMESH::NODE ? myPreMeshInfo->NbNodes() : myPreMeshInfo->NbElements();
@ -298,7 +298,7 @@ CORBA::Boolean SMESH_GroupBase_i::Contains( CORBA::Long theID )
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_Group_i::Add( const SMESH::long_array& theIDs ) SMESH::smIdType SMESH_Group_i::Add( const SMESH::long_array& theIDs )
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile(); myPreMeshInfo->FullLoadFromFile();
@ -329,7 +329,7 @@ CORBA::Long SMESH_Group_i::Add( const SMESH::long_array& theIDs )
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_Group_i::Remove( const SMESH::long_array& theIDs ) SMESH::smIdType SMESH_Group_i::Remove( const SMESH::long_array& theIDs )
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile(); myPreMeshInfo->FullLoadFromFile();
@ -386,7 +386,7 @@ ChangeByPredicate( SMESH::Predicate_i* thePredicate,
return aNb; return aNb;
} }
CORBA::Long SMESH::smIdType
SMESH_Group_i:: SMESH_Group_i::
AddByPredicate( SMESH::Predicate_ptr thePredicate ) AddByPredicate( SMESH::Predicate_ptr thePredicate )
{ {
@ -401,7 +401,7 @@ AddByPredicate( SMESH::Predicate_ptr thePredicate )
return 0; return 0;
} }
CORBA::Long SMESH::smIdType
SMESH_Group_i:: SMESH_Group_i::
RemoveByPredicate( SMESH::Predicate_ptr thePredicate ) RemoveByPredicate( SMESH::Predicate_ptr thePredicate )
{ {
@ -416,7 +416,7 @@ RemoveByPredicate( SMESH::Predicate_ptr thePredicate )
return 0; return 0;
} }
CORBA::Long SMESH_Group_i::AddFrom( SMESH::SMESH_IDSource_ptr theSource ) SMESH::smIdType SMESH_Group_i::AddFrom( SMESH::SMESH_IDSource_ptr theSource )
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile(); myPreMeshInfo->FullLoadFromFile();
@ -445,7 +445,7 @@ CORBA::Long SMESH_Group_i::AddFrom( SMESH::SMESH_IDSource_ptr theSource )
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_GroupBase_i::GetID( CORBA::Long theIndex ) SMESH::smIdType SMESH_GroupBase_i::GetID( CORBA::Long theIndex )
{ {
if ( myPreMeshInfo ) if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile(); myPreMeshInfo->FullLoadFromFile();
@ -509,7 +509,7 @@ namespace
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_GroupBase_i::GetNumberOfNodes() SMESH::smIdType SMESH_GroupBase_i::GetNumberOfNodes()
{ {
if ( GetType() == SMESH::NODE ) if ( GetType() == SMESH::NODE )
return Size(); return Size();
@ -651,7 +651,7 @@ void SMESH_GroupBase_i::SetColor(const SALOMEDS::Color& color)
* *
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_GroupBase_i::GetColorNumber() SMESH::smIdType SMESH_GroupBase_i::GetColorNumber()
{ {
SMESHDS_GroupBase* aGroupDS = GetGroupDS(); SMESHDS_GroupBase* aGroupDS = GetGroupDS();
if (aGroupDS) if (aGroupDS)

18
src/SMESH_I/SMESH_Group_i.hxx
View File

@ -61,13 +61,13 @@ class SMESH_I_EXPORT SMESH_GroupBase_i:
void SetName(const char* name); void SetName(const char* name);
char* GetName(); char* GetName();
SMESH::ElementType GetType(); SMESH::ElementType GetType();
CORBA::Long Size(); SMESH::smIdType Size();
CORBA::Boolean IsEmpty(); CORBA::Boolean IsEmpty();
CORBA::Boolean Contains(CORBA::Long elem_id); CORBA::Boolean Contains(CORBA::Long elem_id);
CORBA::Long GetID(CORBA::Long elem_index); SMESH::smIdType GetID(CORBA::Long elem_index);
SMESH::long_array* GetListOfID(); SMESH::long_array* GetListOfID();
SMESH::long_array* GetNodeIDs(); SMESH::long_array* GetNodeIDs();
CORBA::Long GetNumberOfNodes(); SMESH::smIdType GetNumberOfNodes();
CORBA::Boolean IsNodeInfoAvailable(); // for gui CORBA::Boolean IsNodeInfoAvailable(); // for gui
virtual SMESH::SMESH_Mesh_ptr GetMesh(); virtual SMESH::SMESH_Mesh_ptr GetMesh();
@ -118,7 +118,7 @@ class SMESH_I_EXPORT SMESH_GroupBase_i:
SALOMEDS::Color GetColor(); SALOMEDS::Color GetColor();
void SetColorNumber(CORBA::Long color); void SetColorNumber(CORBA::Long color);
CORBA::Long GetColorNumber(); SMESH::smIdType GetColorNumber();
protected: protected:
@ -150,13 +150,13 @@ class SMESH_I_EXPORT SMESH_Group_i:
const int theLocalID ); const int theLocalID );
// CORBA interface implementation // CORBA interface implementation
void Clear(); void Clear();
CORBA::Long Add( const SMESH::long_array& theIDs ); SMESH::smIdType Add( const SMESH::long_array& theIDs );
CORBA::Long Remove( const SMESH::long_array& theIDs ); SMESH::smIdType Remove( const SMESH::long_array& theIDs );
CORBA::Long AddByPredicate( SMESH::Predicate_ptr thePredicate ); SMESH::smIdType AddByPredicate( SMESH::Predicate_ptr thePredicate );
CORBA::Long RemoveByPredicate( SMESH::Predicate_ptr thePredicate ); SMESH::smIdType RemoveByPredicate( SMESH::Predicate_ptr thePredicate );
CORBA::Long AddFrom( SMESH::SMESH_IDSource_ptr theSource ); SMESH::smIdType AddFrom( SMESH::SMESH_IDSource_ptr theSource );
}; };
// ========================= // =========================

2
src/SMESH_I/SMESH_Hypothesis_i.cxx
View File

@ -114,7 +114,7 @@ void SMESH_Hypothesis_i::SetLibName(const char* theLibName)
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_Hypothesis_i::GetId() SMESH::smIdType SMESH_Hypothesis_i::GetId()
{ {
return myBaseImpl->GetID(); return myBaseImpl->GetID();
} }

2
src/SMESH_I/SMESH_Hypothesis_i.hxx
View File

@ -69,7 +69,7 @@ public:
void SetLibName( const char* theLibName ); void SetLibName( const char* theLibName );
// Get unique id of hypothesis // Get unique id of hypothesis
virtual CORBA::Long GetId(); virtual SMESH::smIdType GetId();
// Return true if a hypothesis has parameters // Return true if a hypothesis has parameters
virtual CORBA::Boolean HasParameters(); virtual CORBA::Boolean HasParameters();

32
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -755,7 +755,7 @@ bool SMESH_MeshEditor_i::IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSourc
return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ); return SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource );
} }
CORBA::Long* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource, SMESH::smIdType* SMESH_MeshEditor_i::GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource,
int& nbIds) int& nbIds)
{ {
if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource )) if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
@ -838,7 +838,7 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNo
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes() SMESH::smIdType SMESH_MeshEditor_i::RemoveOrphanNodes()
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -871,7 +871,7 @@ CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z) SMESH::smIdType SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::Double z)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -895,7 +895,7 @@ CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,CORBA::Double y, CORBA::
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode, SMESH::smIdType SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
CORBA::Boolean DuplicateElements) CORBA::Boolean DuplicateElements)
{ {
SMESH_TRY; SMESH_TRY;
@ -925,7 +925,7 @@ CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter) SMESH::smIdType SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diameter)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -954,7 +954,7 @@ CORBA::Long SMESH_MeshEditor_i::AddBall(CORBA::Long IDOfNode, CORBA::Double diam
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes) SMESH::smIdType SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -997,7 +997,7 @@ CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes) SMESH::smIdType SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1045,7 +1045,7 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes) SMESH::smIdType SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1080,7 +1080,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsO
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes) SMESH::smIdType SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1115,7 +1115,7 @@ CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array &
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes) SMESH::smIdType SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1174,7 +1174,7 @@ CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
* AddPolyhedralVolume * AddPolyhedralVolume
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes, SMESH::smIdType SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities) const SMESH::long_array & Quantities)
{ {
SMESH_TRY; SMESH_TRY;
@ -1213,7 +1213,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces) SMESH::smIdType SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
{ {
SMESH_TRY; SMESH_TRY;
initData(); initData();
@ -1718,7 +1718,7 @@ CORBA::Long SMESH_MeshEditor_i::Reorient2D(SMESH::SMESH_IDSource_ptr the2Dgroup,
//purpose : Reorient faces basing on orientation of adjacent volumes. //purpose : Reorient faces basing on orientation of adjacent volumes.
//======================================================================= //=======================================================================
CORBA::Long SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups, SMESH::smIdType SMESH_MeshEditor_i::Reorient2DBy3D(const SMESH::ListOfIDSources& faceGroups,
SMESH::SMESH_IDSource_ptr volumeGroup, SMESH::SMESH_IDSource_ptr volumeGroup,
CORBA::Boolean outsideNormal) CORBA::Boolean outsideNormal)
{ {
@ -4456,7 +4456,7 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x, SMESH::smIdType SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z) CORBA::Double z)
{ {
@ -4663,7 +4663,7 @@ SMESH_MeshEditor_i::FindAmongElementsByPoint(SMESH::SMESH_IDSource_ptr elementID
// In the case if nothing found, return -1 and [] // In the case if nothing found, return -1 and []
//======================================================================= //=======================================================================
CORBA::Long SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x, SMESH::smIdType SMESH_MeshEditor_i::ProjectPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type, SMESH::ElementType type,
@ -7088,7 +7088,7 @@ SMESH_MeshEditor_i::MakeBoundaryMesh(SMESH::SMESH_IDSource_ptr idSource,
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim, SMESH::smIdType SMESH_MeshEditor_i::MakeBoundaryElements(SMESH::Bnd_Dimension dim,
const char* groupName, const char* groupName,
const char* meshName, const char* meshName,
CORBA::Boolean toCopyAll, CORBA::Boolean toCopyAll,

32
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -93,7 +93,7 @@ public:
SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements, SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements,
SMESH::ElementType type); SMESH::ElementType type);
static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource ); static bool IsTemporaryIDSource( SMESH::SMESH_IDSource_ptr& idSource );
static CORBA::Long* GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource, int& nbIds ); static SMESH::smIdType* GetTemporaryIDs( SMESH::SMESH_IDSource_ptr& idSource, int& nbIds );
/*! /*!
* \brief Generates the unique group name * \brief Generates the unique group name
@ -102,23 +102,23 @@ public:
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements); CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes); CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes);
CORBA::Long RemoveOrphanNodes(); SMESH::smIdType RemoveOrphanNodes();
/*! /*!
* Methods for creation new elements. * Methods for creation new elements.
* Returns ID of created element or 0 if element not created * Returns ID of created element or 0 if element not created
*/ */
CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z); SMESH::smIdType AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements); SMESH::smIdType Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter); SMESH::smIdType AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes); SMESH::smIdType AddEdge(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes); SMESH::smIdType AddFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes); SMESH::smIdType AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes); SMESH::smIdType AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes); SMESH::smIdType AddVolume(const SMESH::long_array & IDsOfNodes);
CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes, SMESH::smIdType AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
const SMESH::long_array & Quantities); const SMESH::long_array & Quantities);
CORBA::Long AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces); SMESH::smIdType AddPolyhedralVolumeByFaces(const SMESH::long_array & IdsOfFaces);
/*! /*!
* \brief Create 0D elements on all nodes of the given object except those * \brief Create 0D elements on all nodes of the given object except those
@ -200,7 +200,7 @@ public:
* pointing either \a outside or \a inside the adjacent volumes. * pointing either \a outside or \a inside the adjacent volumes.
* \return number of reoriented faces. * \return number of reoriented faces.
*/ */
CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces, SMESH::smIdType Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
SMESH::SMESH_IDSource_ptr volumes, SMESH::SMESH_IDSource_ptr volumes,
CORBA::Boolean outsideNormal); CORBA::Boolean outsideNormal);
@ -450,7 +450,7 @@ public:
/*! /*!
* \brief Return ID of node closest to a given point * \brief Return ID of node closest to a given point
*/ */
CORBA::Long FindNodeClosestTo(CORBA::Double x, SMESH::smIdType FindNodeClosestTo(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z); CORBA::Double z);
/*! /*!
@ -478,7 +478,7 @@ public:
* and coordinates of the projection point. * and coordinates of the projection point.
* In the case if nothing found, return -1 and [] * In the case if nothing found, return -1 and []
*/ */
CORBA::Long ProjectPoint(CORBA::Double x, SMESH::smIdType ProjectPoint(CORBA::Double x,
CORBA::Double y, CORBA::Double y,
CORBA::Double z, CORBA::Double z,
SMESH::ElementType type, SMESH::ElementType type,
@ -794,7 +794,7 @@ public:
CORBA::Boolean toCopyMissingBondary, CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group); SMESH::SMESH_Group_out group);
CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension, SMESH::smIdType MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName, const char* groupName,
const char* meshName, const char* meshName,
CORBA::Boolean toCopyAll, CORBA::Boolean toCopyAll,

70
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -1250,7 +1250,7 @@ SMESH::ListOfGroups * SMESH_Mesh_i::GetGroups()
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_Mesh_i::NbGroups() SMESH::smIdType SMESH_Mesh_i::NbGroups()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
return _mapGroups.size(); return _mapGroups.size();
@ -3391,7 +3391,7 @@ void SMESH_Mesh_i::ClearLog()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::GetId() SMESH::smIdType SMESH_Mesh_i::GetId()
{ {
return _id; return _id;
} }
@ -4396,7 +4396,7 @@ CORBA::Double SMESH_Mesh_i::GetComputeProgress()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbNodes() SMESH::smIdType SMESH_Mesh_i::NbNodes()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4411,7 +4411,7 @@ CORBA::Long SMESH_Mesh_i::NbNodes()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbElements() SMESH::smIdType SMESH_Mesh_i::NbElements()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4426,7 +4426,7 @@ CORBA::Long SMESH_Mesh_i::NbElements()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::Nb0DElements() SMESH::smIdType SMESH_Mesh_i::Nb0DElements()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4441,7 +4441,7 @@ CORBA::Long SMESH_Mesh_i::Nb0DElements()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbBalls() SMESH::smIdType SMESH_Mesh_i::NbBalls()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4456,7 +4456,7 @@ CORBA::Long SMESH_Mesh_i::NbBalls()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbEdges() SMESH::smIdType SMESH_Mesh_i::NbEdges()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4471,7 +4471,7 @@ CORBA::Long SMESH_Mesh_i::NbEdges()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order) SMESH::smIdType SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4486,7 +4486,7 @@ CORBA::Long SMESH_Mesh_i::NbEdgesOfOrder(SMESH::ElementOrder order)
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbFaces() SMESH::smIdType SMESH_Mesh_i::NbFaces()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4501,7 +4501,7 @@ CORBA::Long SMESH_Mesh_i::NbFaces()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbTriangles() SMESH::smIdType SMESH_Mesh_i::NbTriangles()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4516,7 +4516,7 @@ CORBA::Long SMESH_Mesh_i::NbTriangles()
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles() SMESH::smIdType SMESH_Mesh_i::NbBiQuadTriangles()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4525,7 +4525,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadTriangles()
return _impl->NbBiQuadTriangles(); return _impl->NbBiQuadTriangles();
} }
CORBA::Long SMESH_Mesh_i::NbQuadrangles() SMESH::smIdType SMESH_Mesh_i::NbQuadrangles()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4534,7 +4534,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadrangles()
return _impl->NbQuadrangles(); return _impl->NbQuadrangles();
} }
CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles() SMESH::smIdType SMESH_Mesh_i::NbBiQuadQuadrangles()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4543,7 +4543,7 @@ CORBA::Long SMESH_Mesh_i::NbBiQuadQuadrangles()
return _impl->NbBiQuadQuadrangles(); return _impl->NbBiQuadQuadrangles();
} }
CORBA::Long SMESH_Mesh_i::NbPolygons() SMESH::smIdType SMESH_Mesh_i::NbPolygons()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4552,7 +4552,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygons()
return _impl->NbPolygons(); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4561,7 +4561,7 @@ CORBA::Long SMESH_Mesh_i::NbPolygonsOfOrder(SMESH::ElementOrder order)
return _impl->NbPolygons((SMDSAbs_ElementOrder)order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4570,7 +4570,7 @@ CORBA::Long SMESH_Mesh_i::NbFacesOfOrder(SMESH::ElementOrder order)
return _impl->NbFaces( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4579,7 +4579,7 @@ CORBA::Long SMESH_Mesh_i::NbTrianglesOfOrder(SMESH::ElementOrder order)
return _impl->NbTriangles( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4590,7 +4590,7 @@ CORBA::Long SMESH_Mesh_i::NbQuadranglesOfOrder(SMESH::ElementOrder order)
//============================================================================= //=============================================================================
CORBA::Long SMESH_Mesh_i::NbVolumes() SMESH::smIdType SMESH_Mesh_i::NbVolumes()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4599,7 +4599,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumes()
return _impl->NbVolumes(); return _impl->NbVolumes();
} }
CORBA::Long SMESH_Mesh_i::NbTetras() SMESH::smIdType SMESH_Mesh_i::NbTetras()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4608,7 +4608,7 @@ CORBA::Long SMESH_Mesh_i::NbTetras()
return _impl->NbTetras(); return _impl->NbTetras();
} }
CORBA::Long SMESH_Mesh_i::NbHexas() SMESH::smIdType SMESH_Mesh_i::NbHexas()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4617,7 +4617,7 @@ CORBA::Long SMESH_Mesh_i::NbHexas()
return _impl->NbHexas(); return _impl->NbHexas();
} }
CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas() SMESH::smIdType SMESH_Mesh_i::NbTriQuadraticHexas()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4626,7 +4626,7 @@ CORBA::Long SMESH_Mesh_i::NbTriQuadraticHexas()
return _impl->NbTriQuadraticHexas(); return _impl->NbTriQuadraticHexas();
} }
CORBA::Long SMESH_Mesh_i::NbPyramids() SMESH::smIdType SMESH_Mesh_i::NbPyramids()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4635,7 +4635,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramids()
return _impl->NbPyramids(); return _impl->NbPyramids();
} }
CORBA::Long SMESH_Mesh_i::NbPrisms() SMESH::smIdType SMESH_Mesh_i::NbPrisms()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4644,7 +4644,7 @@ CORBA::Long SMESH_Mesh_i::NbPrisms()
return _impl->NbPrisms(); return _impl->NbPrisms();
} }
CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms() SMESH::smIdType SMESH_Mesh_i::NbHexagonalPrisms()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4653,7 +4653,7 @@ CORBA::Long SMESH_Mesh_i::NbHexagonalPrisms()
return _impl->NbHexagonalPrisms(); return _impl->NbHexagonalPrisms();
} }
CORBA::Long SMESH_Mesh_i::NbPolyhedrons() SMESH::smIdType SMESH_Mesh_i::NbPolyhedrons()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4662,7 +4662,7 @@ CORBA::Long SMESH_Mesh_i::NbPolyhedrons()
return _impl->NbPolyhedrons(); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4671,7 +4671,7 @@ CORBA::Long SMESH_Mesh_i::NbVolumesOfOrder(SMESH::ElementOrder order)
return _impl->NbVolumes( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4680,7 +4680,7 @@ CORBA::Long SMESH_Mesh_i::NbTetrasOfOrder(SMESH::ElementOrder order)
return _impl->NbTetras( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4689,7 +4689,7 @@ CORBA::Long SMESH_Mesh_i::NbHexasOfOrder(SMESH::ElementOrder order)
return _impl->NbHexas( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4698,7 +4698,7 @@ CORBA::Long SMESH_Mesh_i::NbPyramidsOfOrder(SMESH::ElementOrder order)
return _impl->NbPyramids( (SMDSAbs_ElementOrder) order); 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); Unexpect aCatch(SALOME_SalomeException);
if ( _preMeshInfo ) if ( _preMeshInfo )
@ -4713,7 +4713,7 @@ CORBA::Long SMESH_Mesh_i::NbPrismsOfOrder(SMESH::ElementOrder order)
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_Mesh_i::NbSubMesh() SMESH::smIdType SMESH_Mesh_i::NbSubMesh()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
return _mapSubMesh_i.size(); return _mapSubMesh_i.size();
@ -5479,7 +5479,7 @@ SMESH::double_array* SMESH_Mesh_i::GetFaceNormal(CORBA::Long elemId,
*/ */
//================================================================================ //================================================================================
CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes) SMESH::smIdType SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes)
{ {
if ( _preMeshInfo ) if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile(); _preMeshInfo->FullLoadFromFile();
@ -6155,7 +6155,7 @@ namespace /* Iterators used in SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_v
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
struct IDSourceIterator : public SMDS_ElemIterator struct IDSourceIterator : public SMDS_ElemIterator
{ {
const CORBA::Long* _idPtr; const SMESH::smIdType* _idPtr;
const CORBA::Long* _idEndPtr; const CORBA::Long* _idEndPtr;
SMESH::long_array_var _idArray; SMESH::long_array_var _idArray;
const SMDS_Mesh* _mesh; const SMDS_Mesh* _mesh;
@ -6325,7 +6325,7 @@ SMDS_ElemIteratorPtr SMESH_Mesh_i::GetElements(SMESH::SMESH_IDSource_ptr theObje
if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject )) if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject ))
{ {
int nbIds; int nbIds;
if ( CORBA::Long* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds )) if ( SMESH::smIdType* ids = SMESH_MeshEditor_i::GetTemporaryIDs( theObject, nbIds ))
elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, iterType )); elemIt = SMDS_ElemIteratorPtr( new IDSourceIterator( meshDS, ids, nbIds, iterType ));
} }
else else

66
src/SMESH_I/SMESH_Mesh_i.hxx
View File

@ -112,7 +112,7 @@ public:
SMESH::ListOfGroups* GetGroups(); SMESH::ListOfGroups* GetGroups();
CORBA::Long NbGroups(); SMESH::smIdType NbGroups();
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1, SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2, SMESH::SMESH_GroupBase_ptr theGroup2,
@ -158,7 +158,7 @@ public:
void ClearLog(); void ClearLog();
CORBA::Long GetId(); SMESH::smIdType GetId();
// --- C++ interface // --- C++ interface
@ -244,65 +244,65 @@ public:
CORBA::Double GetComputeProgress(); CORBA::Double GetComputeProgress();
CORBA::Long NbNodes(); SMESH::smIdType NbNodes();
CORBA::Long NbElements(); SMESH::smIdType NbElements();
CORBA::Long Nb0DElements(); SMESH::smIdType Nb0DElements();
CORBA::Long NbBalls(); SMESH::smIdType NbBalls();
CORBA::Long NbEdges(); SMESH::smIdType NbEdges();
CORBA::Long NbEdgesOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbEdgesOfOrder(SMESH::ElementOrder order);
CORBA::Long NbFaces(); SMESH::smIdType NbFaces();
CORBA::Long NbFacesOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbFacesOfOrder(SMESH::ElementOrder order);
CORBA::Long NbTriangles(); SMESH::smIdType NbTriangles();
CORBA::Long NbTrianglesOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbTrianglesOfOrder(SMESH::ElementOrder order);
CORBA::Long NbBiQuadTriangles(); SMESH::smIdType NbBiQuadTriangles();
CORBA::Long NbQuadrangles(); SMESH::smIdType NbQuadrangles();
CORBA::Long NbQuadranglesOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbQuadranglesOfOrder(SMESH::ElementOrder order);
CORBA::Long NbBiQuadQuadrangles(); SMESH::smIdType NbBiQuadQuadrangles();
CORBA::Long NbPolygons(); SMESH::smIdType NbPolygons();
CORBA::Long NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY); SMESH::smIdType NbPolygonsOfOrder(SMESH::ElementOrder order = SMESH::ORDER_ANY);
CORBA::Long NbVolumes(); SMESH::smIdType NbVolumes();
CORBA::Long NbVolumesOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbVolumesOfOrder(SMESH::ElementOrder order);
CORBA::Long NbTetras(); SMESH::smIdType NbTetras();
CORBA::Long NbTetrasOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbTetrasOfOrder(SMESH::ElementOrder order);
CORBA::Long NbHexas(); SMESH::smIdType NbHexas();
CORBA::Long NbHexasOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbHexasOfOrder(SMESH::ElementOrder order);
CORBA::Long NbTriQuadraticHexas(); SMESH::smIdType NbTriQuadraticHexas();
CORBA::Long NbPyramids(); SMESH::smIdType NbPyramids();
CORBA::Long NbPyramidsOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbPyramidsOfOrder(SMESH::ElementOrder order);
CORBA::Long NbPrisms(); SMESH::smIdType NbPrisms();
CORBA::Long NbPrismsOfOrder(SMESH::ElementOrder order); SMESH::smIdType NbPrismsOfOrder(SMESH::ElementOrder order);
CORBA::Long NbHexagonalPrisms(); SMESH::smIdType NbHexagonalPrisms();
CORBA::Long NbPolyhedrons(); SMESH::smIdType NbPolyhedrons();
CORBA::Long NbSubMesh(); SMESH::smIdType NbSubMesh();
SMESH::long_array* GetElementsId(); SMESH::long_array* GetElementsId();
@ -504,7 +504,7 @@ public:
/*! /*!
* Returns an element based on all given nodes. * Returns an element based on all given nodes.
*/ */
CORBA::Long FindElementByNodes(const SMESH::long_array& nodes); SMESH::smIdType FindElementByNodes(const SMESH::long_array& nodes);
/*! /*!
* Return elements including all given nodes. * Return elements including all given nodes.

6
src/SMESH_I/SMESH_subMesh_i.cxx
View File

@ -140,7 +140,7 @@ bool getSubMeshes(::SMESH_subMesh* theSubMesh,
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfElements() SMESH::smIdType SMESH_subMesh_i::GetNumberOfElements()
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -170,7 +170,7 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all) SMESH::smIdType SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
{ {
Unexpect aCatch(SALOME_SalomeException); Unexpect aCatch(SALOME_SalomeException);
@ -372,7 +372,7 @@ SMESH::SMESH_Mesh_ptr SMESH_subMesh_i::GetFather()
*/ */
//============================================================================= //=============================================================================
CORBA::Long SMESH_subMesh_i::GetId() SMESH::smIdType SMESH_subMesh_i::GetId()
{ {
return _localId; return _localId;
} }

6
src/SMESH_I/SMESH_subMesh_i.hxx
View File

@ -53,9 +53,9 @@ public:
int localId ); int localId );
~SMESH_subMesh_i(); ~SMESH_subMesh_i();
CORBA::Long GetNumberOfElements(); SMESH::smIdType GetNumberOfElements();
CORBA::Long GetNumberOfNodes( CORBA::Boolean all ); SMESH::smIdType GetNumberOfNodes( CORBA::Boolean all );
SMESH::long_array* GetElementsId(); SMESH::long_array* GetElementsId();
@ -69,7 +69,7 @@ public:
GEOM::GEOM_Object_ptr GetSubShape(); GEOM::GEOM_Object_ptr GetSubShape();
CORBA::Long GetId(); SMESH::smIdType GetId();
// ========================= // =========================