ADD_DEFINITIONS(-DDYNLOAD_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)
SET(SMESH_USE_MESHGEMS_HYPOSET_VAR "true")
ELSE(SMESH_USE_MESHGEMS_HYPOSET)
${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)
SET(SalomeIDLSMESH_IDLSOURCES
#include <vtkCellType.h>
#include <vtkCellLinks.h>
+#include <smIdType.hxx>
#include <map>
_cellIds.resize(_nbDownCells * _maxId);
_vtkCellIds.resize(_maxId);
- int sizeUpCells = 0;
+ smIdType sizeUpCells = 0;
for (int i = 0; i < _maxId; i++)
sizeUpCells += _upCellIdsVector[i].size();
_upCellIds.resize(sizeUpCells, -1);
void SMDS_Down1D::addUpCell(int cellId, int upCellId, unsigned char aType)
{
//ASSERT((cellId >=0) && (cellId < _maxId));
- int nbFaces = _upCellIdsVector[cellId].size();
- for (int i = 0; i < nbFaces; i++)
+ smIdType nbFaces = _upCellIdsVector[cellId].size();
+ for (smIdType i = 0; i < nbFaces; i++)
{
if ((_upCellIdsVector[cellId][i] == upCellId) && (_upCellTypesVector[cellId][i] == aType))
{
{
if ( myChunksWithUnused.empty() )
{
- int id0 = myChunks.size() * theChunkSize + 1;
+ smIdType id0 = myChunks.size() * theChunkSize + 1;
myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
}
SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
smIdType SMDS_ElementFactory::GetMaxID()
{
- int id = 0;
+ smIdType id = 0;
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 ))
{
- int index = usedRanges.back().second-1;
+ smIdType index = usedRanges.back().second-1;
id = myChunks[i].Get1stID() + index;
break;
}
SMDS_MeshElement* SMDS_ElementFactory::NewElement( const smIdType id )
{
- int iChunk = ( id - 1 ) / theChunkSize;
- int index = ( id - 1 ) % theChunkSize;
+ smIdType iChunk = ( id - 1 ) / theChunkSize;
+ smIdType index = ( id - 1 ) % theChunkSize;
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 ));
}
SMDS_MeshElement* e = myChunks[iChunk].Element( index );
{
if ( id > 0 )
{
- int iChunk = ( id - 1 ) / theChunkSize;
- int index = ( id - 1 ) % theChunkSize;
+ smIdType iChunk = ( id - 1 ) / theChunkSize;
+ smIdType index = ( id - 1 ) % theChunkSize;
if ( iChunk < (int) myChunks.size() )
{
const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
/*!
* \brief Return an SMDS ID by a Vtk one
* \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() )
return mySmdsIDs[vtkID] + 1;
{
smIdType newNbCells = NbUsedElements();
smIdType maxCellID = GetMaxID();
- int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
+ smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
theVtkIDsNewToOld.resize( newNbCells );
const SMDS_MeshElement* newElem = FindElement( newVtkID );
if ( !newElem )
newElem = NewElement( newVtkID );
- if ( int shapeID = oldElem->GetShapeID() )
+ if ( smIdType shapeID = oldElem->GetShapeID() )
const_cast< SMDS_MeshElement* >( newElem )->setShapeID( shapeID );
if ( oldID > newNbCells )
Free( oldElem );
const SMDS_MeshElement* newNode = FindElement( newID+1 );
if ( !newNode )
newNode = NewElement( newID+1 );
- int shapeID = oldNode->GetShapeID();
+ smIdType shapeID = oldNode->GetShapeID();
int shapeDim = GetShapeDim( shapeID );
- int iChunk = newID / theChunkSize;
+ smIdType iChunk = newID / theChunkSize;
myChunks[ iChunk ].SetShapeID( newNode, shapeID );
if ( shapeDim == 2 || shapeDim == 1 )
{
- int iChunkOld = oldID / theChunkSize;
+ smIdType iChunkOld = oldID / theChunkSize;
TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
TParam* newPos = myChunks[ iChunk ].GetPositionPtr( newNode, /*allocate=*/true );
if ( oldPos )
*/
//================================================================================
-SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ):
+SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, smIdType id0 ):
myFactory( factory ),
my1stID( id0 )//,
//mySubIDSet( 0 )
size_t i = myFactory->myVtkIDs.size();
myFactory->myVtkIDs.resize( e->GetID() + 100 );
for ( ; i < myFactory->myVtkIDs.size(); ++i )
- myFactory->myVtkIDs[i] = i;
+ myFactory->myVtkIDs[i] = FromIdType<int>(i);
}
myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
{
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);
}
//================================================================================
TChunkVector myChunks; // array of chunks of elements
TChunkPtrSet myChunksWithUnused; // sorted chunks having unused elements
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
friend class SMDS_ElementChunk;
void Free( const SMDS_MeshElement* );
//! Return an SMDS ID by a Vtk one
- int FromVtkToSmds( vtkIdType vtkID );
+ smIdType FromVtkToSmds( vtkIdType vtkID );
//! De-allocate all elements
virtual void Clear();
rNext = mySet.upper_bound( theIndex );
r = rNext - 1;
}
- int rSize = Size( r ); // range size
+ smIdType rSize = Size( r ); // range size
attr_t rValue = r->myValue;
if ( rValue == theValue )
return rValue; // it happens while compacting
{
SMDS_ElementFactory* myFactory; // holder of this chunk
SMDS_MeshElement* myElements; // array of elements
- int my1stID; // ID of myElements[0]
+ smIdType my1stID; // ID of myElements[0]
TBitSet myMarkedSet; // mark some elements
TUsedRangeSet myUsedRanges; // ranges of used/unused elements
TSubIDRangeSet mySubIDRanges; // ranges of elements on the same sub-shape
public:
- SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, int id0 = 0 );
+ SMDS_ElementChunk( SMDS_ElementFactory* factory = 0, smIdType id0 = 0 );
~SMDS_ElementChunk();
//! Return an element by an index [0,ChunkSize()]
static bool IsUsed( const _UsedRange& r ) { return r.myValue; }
//! 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
- int Get1stID() const { return my1stID; }
+ smIdType Get1stID() const { return my1stID; }
//! Return pointer to on-shape-parameters of a node
TParam* GetPositionPtr( const SMDS_MeshElement* node, bool allocate=false );
size_t nbElemsToReturn,
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;
return boost::make_shared< TChuckIterator >( myChunks,
& SMDS_ElementChunk::GetSubIDRangesMinMax,
//purpose :
//=======================================================================
-const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
+const SMDS_MeshElement* SMDS_Mesh::FindElement(smIdType IDelem) const
{
return myCellFactory->FindElement( IDelem );
}
return;
}
-int SMDS_Mesh::FromVtkToSmds( int vtkid ) const
+smIdType SMDS_Mesh::FromVtkToSmds( vtkIdType vtkid ) const
{
return myCellFactory->FromVtkToSmds( vtkid );
}
}
const SMDS_MeshNode *FindNode(smIdType idnode) const;
- const SMDS_MeshNode *FindNodeVtk(int idnode) const;
- const SMDS_MeshElement *FindElementVtk(int IDelem) const;
- virtual const SMDS_MeshElement * FindElement(int IDelem) const;
+ const SMDS_MeshNode *FindNodeVtk(vtkIdType idnode) const;
+ const SMDS_MeshElement *FindElementVtk(vtkIdType IDelem) const;
+ virtual const SMDS_MeshElement * FindElement(smIdType IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
virtual ~SMDS_Mesh();
double getMaxDim();
- int FromVtkToSmds(int vtkid) const;
+ smIdType FromVtkToSmds(vtkIdType vtkid) const;
void dumpGrid(std::string ficdump="dumpGrid");
static int chunkSize;
virtual smIdType GetID() const;
virtual int GetVtkID() const;
- virtual int getshapeId() const { return GetShapeID(); }
+ virtual smIdType getshapeId() const { return GetShapeID(); }
virtual smIdType GetShapeID() const;
// mark this element; to be used in algos
#include <utilities.h>
#include <Utils_SALOME_Exception.hxx>
#include <cassert>
+#include <smIdType.hxx>
#include <boost/make_shared.hpp>
for (int i = 0; i < ncells; i++)
{
int vtkId = cells[i];
- int smdsId = myMesh->FromVtkToSmds( vtkId );
+ smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement( smdsId );
if ( elem->GetType() == type )
{
const SMDS_MeshElement* next()
{
int vtkId = myCellList[ myIter++ ];
- int smdsId = myMesh->FromVtkToSmds( vtkId );
+ smIdType smdsId = myMesh->FromVtkToSmds( vtkId );
const SMDS_MeshElement* elem = myMesh->FindElement(smdsId);
if (!elem)
{
// Use double type for storing coordinates of nodes instead float.
vtkPoints *newPoints = vtkPoints::New();
newPoints->SetDataType( VTK_DOUBLE );
- newPoints->SetNumberOfPoints( newNodeSize );
+ newPoints->SetNumberOfPoints( FromIdType<int>(newNodeSize) );
int i = 0, alreadyCopied = 0;
while ( i < oldNodeSize )
vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
newTypes->Initialize();
- newTypes->SetNumberOfValues(newCellSize);
+ newTypes->SetNumberOfValues(FromIdType<int>(newCellSize));
vtkIdTypeArray *newLocations = vtkIdTypeArray::New();
newLocations->Initialize();
- newLocations->SetNumberOfValues(newCellSize);
+ newLocations->SetNumberOfValues(FromIdType<int>(newCellSize));
std::vector< vtkIdType > pointsCell(1024); // --- points id to fill a new cell
const SMDS_MeshInfo &meshInfo = _mesh->GetMeshInfo();
- int nbLinTetra = meshInfo.NbTetras (ORDER_LINEAR);
- int nbQuadTetra = meshInfo.NbTetras (ORDER_QUADRATIC);
- int nbLinPyra = meshInfo.NbPyramids(ORDER_LINEAR);
- int nbQuadPyra = meshInfo.NbPyramids(ORDER_QUADRATIC);
- int nbLinPrism = meshInfo.NbPrisms (ORDER_LINEAR);
- int nbQuadPrism = meshInfo.NbPrisms (ORDER_QUADRATIC);
- int nbLinHexa = meshInfo.NbHexas (ORDER_LINEAR);
- int nbQuadHexa = meshInfo.NbHexas (ORDER_QUADRATIC);
- int nbHexPrism = meshInfo.NbHexPrisms();
+ int nbLinTetra = FromIdType<int>(meshInfo.NbTetras (ORDER_LINEAR));
+ int nbQuadTetra = FromIdType<int>(meshInfo.NbTetras (ORDER_QUADRATIC));
+ int nbLinPyra = FromIdType<int>(meshInfo.NbPyramids(ORDER_LINEAR));
+ int nbQuadPyra = FromIdType<int>(meshInfo.NbPyramids(ORDER_QUADRATIC));
+ int nbLinPrism = FromIdType<int>(meshInfo.NbPrisms (ORDER_LINEAR));
+ int nbQuadPrism = FromIdType<int>(meshInfo.NbPrisms (ORDER_QUADRATIC));
+ int nbLinHexa = FromIdType<int>(meshInfo.NbHexas (ORDER_LINEAR));
+ int nbQuadHexa = FromIdType<int>(meshInfo.NbHexas (ORDER_QUADRATIC));
+ int nbHexPrism = FromIdType<int>(meshInfo.NbHexPrisms());
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);
{
if (( myOri = ( n1->GetID() < n2->GetID() )))
{
- first = n1->GetID();
- second = n2->GetID();
+ first = FromIdType<int>(n1->GetID());
+ second = FromIdType<int>(n2->GetID());
}
else
{
myOri = -1;
- first = n2->GetID();
- second = n1->GetID();
+ first = FromIdType<int>(n2->GetID());
+ second = FromIdType<int>(n1->GetID());
}
myOri *= ori;
}
int SMDS_VolumeTool::ID() const
{
- return myVolume ? myVolume->GetID() : 0;
+ return myVolume ? FromIdType<int>(myVolume->GetID()) : 0;
}
#define SMDS_VolumeTool_HeaderFile
#include "SMESH_SMDS.hxx"
+#include <smIdType.hxx>
class SMDS_MeshElement;
class SMDS_MeshNode;
const SMDS_MeshNode * nodes[],
const smIdType nbnodes)
{
- if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
+ if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, FromIdType<int>(nbnodes) ))
return false;
std::vector<smIdType> IDs( nbnodes );
AddNode( static_cast< const SMDS_MeshNode* >( elem ));
return;
}
- int oldShapeId = elem->GetShapeID();
+ smIdType oldShapeId = elem->GetShapeID();
if ( oldShapeId > 0 )
{
if (oldShapeId != myIndex)
#include "SMDS_ElementHolder.hxx"
#include "SMDS_Mesh.hxx"
+#include <smIdType.hxx>
#include <vector>
#include <boost/container/flat_set.hpp>
CORBA::Boolean isLogarithmic,
SMESH::SMESH_IDSource_ptr object);
void SetPrecision( CORBA::Long thePrecision );
- CORBA::Long GetPrecision();
+ SMESH::smIdType GetPrecision();
Controls::NumericalFunctorPtr GetNumericalFunctor();
protected:
{
public:
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();
protected:
CORBA::Boolean SaveAs( const char* aFileName );
CORBA::Boolean IsPresent( const char* aFilterName );
- CORBA::Long NbFilters( ElementType );
+ SMESH::smIdType NbFilters( ElementType );
string_array* GetNames( ElementType );
string_array* GetAllNames();
void SetFileName( const char* theFileName );
*/
//================================================================================
-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 )) {
string iorString = GetORB()->object_to_string( theObject );
#include <Utils_CorbaException.hxx>
#include <GEOM_Client.hxx>
+#include <smIdType.hxx>
#include <TCollection_AsciiString.hxx>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
// register object in the internal map and return its id
int addObject( const std::string& theIOR );
// 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
std::string getIORbyId( const int theId );
// get object's IOR by old id
int RegisterObject(CORBA::Object_ptr theObject);
// 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
template<class TInterface>
//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;
for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {
*/
//=============================================================================
-CORBA::Long SMESH_GroupBase_i::Size()
+SMESH::smIdType SMESH_GroupBase_i::Size()
{
if ( myPreMeshInfo )
return GetType() == SMESH::NODE ? myPreMeshInfo->NbNodes() : myPreMeshInfo->NbElements();
*/
//=============================================================================
-CORBA::Long SMESH_Group_i::Add( const SMESH::long_array& theIDs )
+SMESH::smIdType SMESH_Group_i::Add( const SMESH::long_array& theIDs )
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_Group_i::Remove( const SMESH::long_array& theIDs )
+SMESH::smIdType SMESH_Group_i::Remove( const SMESH::long_array& theIDs )
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();
return aNb;
}
-CORBA::Long
+SMESH::smIdType
SMESH_Group_i::
AddByPredicate( SMESH::Predicate_ptr thePredicate )
{
return 0;
}
-CORBA::Long
+SMESH::smIdType
SMESH_Group_i::
RemoveByPredicate( SMESH::Predicate_ptr thePredicate )
{
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 )
myPreMeshInfo->FullLoadFromFile();
*/
//=============================================================================
-CORBA::Long SMESH_GroupBase_i::GetID( CORBA::Long theIndex )
+SMESH::smIdType SMESH_GroupBase_i::GetID( CORBA::Long theIndex )
{
if ( myPreMeshInfo )
myPreMeshInfo->FullLoadFromFile();
*/
//================================================================================
-CORBA::Long SMESH_GroupBase_i::GetNumberOfNodes()
+SMESH::smIdType SMESH_GroupBase_i::GetNumberOfNodes()
{
if ( GetType() == SMESH::NODE )
return Size();
*
*/
//=============================================================================
-CORBA::Long SMESH_GroupBase_i::GetColorNumber()
+SMESH::smIdType SMESH_GroupBase_i::GetColorNumber()
{
SMESHDS_GroupBase* aGroupDS = GetGroupDS();
if (aGroupDS)
void SetName(const char* name);
char* GetName();
SMESH::ElementType GetType();
- CORBA::Long Size();
+ SMESH::smIdType Size();
CORBA::Boolean IsEmpty();
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* GetNodeIDs();
- CORBA::Long GetNumberOfNodes();
+ SMESH::smIdType GetNumberOfNodes();
CORBA::Boolean IsNodeInfoAvailable(); // for gui
virtual SMESH::SMESH_Mesh_ptr GetMesh();
SALOMEDS::Color GetColor();
void SetColorNumber(CORBA::Long color);
- CORBA::Long GetColorNumber();
+ SMESH::smIdType GetColorNumber();
protected:
const int theLocalID );
// CORBA interface implementation
void Clear();
- CORBA::Long Add( const SMESH::long_array& theIDs );
- CORBA::Long Remove( const SMESH::long_array& theIDs );
+ SMESH::smIdType Add( const SMESH::long_array& theIDs );
+ SMESH::smIdType Remove( const SMESH::long_array& theIDs );
- CORBA::Long AddByPredicate( SMESH::Predicate_ptr thePredicate );
- CORBA::Long RemoveByPredicate( SMESH::Predicate_ptr thePredicate );
+ SMESH::smIdType AddByPredicate( 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 );
};
// =========================
*/
//=============================================================================
-CORBA::Long SMESH_Hypothesis_i::GetId()
+SMESH::smIdType SMESH_Hypothesis_i::GetId()
{
return myBaseImpl->GetID();
}
void SetLibName( const char* theLibName );
// Get unique id of hypothesis
- virtual CORBA::Long GetId();
+ virtual SMESH::smIdType GetId();
// Return true if a hypothesis has parameters
virtual CORBA::Boolean HasParameters();
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)
{
if ( _IDSource* tmpIdSource = SMESH::DownCast<SMESH_MeshEditor_i::_IDSource*>( idSource ))
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::RemoveOrphanNodes()
+SMESH::smIdType SMESH_MeshEditor_i::RemoveOrphanNodes()
{
SMESH_TRY;
initData();
*/
//=============================================================================
-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;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
+SMESH::smIdType SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode,
CORBA::Boolean DuplicateElements)
{
SMESH_TRY;
*/
//=============================================================================
-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;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
+SMESH::smIdType SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
+SMESH::smIdType SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
+SMESH::smIdType SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsOfNodes)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
+SMESH::smIdType SMESH_MeshEditor_i::AddQuadPolygonalFace (const SMESH::long_array & IDsOfNodes)
{
SMESH_TRY;
initData();
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
+SMESH::smIdType SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
{
SMESH_TRY;
initData();
* 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)
{
SMESH_TRY;
*/
//=============================================================================
-CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
+SMESH::smIdType SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_array & IdsOfFaces)
{
SMESH_TRY;
initData();
//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,
CORBA::Boolean outsideNormal)
{
*/
//================================================================================
-CORBA::Long SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
+SMESH::smIdType SMESH_MeshEditor_i::FindNodeClosestTo(CORBA::Double x,
CORBA::Double y,
CORBA::Double z)
{
// 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 z,
SMESH::ElementType type,
*/
//================================================================================
-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* meshName,
CORBA::Boolean toCopyAll,
SMESH::SMESH_IDSource_ptr MakeIDSource(const SMESH::long_array& IDsOfElements,
SMESH::ElementType type);
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
CORBA::Boolean RemoveElements(const SMESH::long_array & IDsOfElements);
CORBA::Boolean RemoveNodes (const SMESH::long_array & IDsOfNodes);
- CORBA::Long RemoveOrphanNodes();
+ SMESH::smIdType RemoveOrphanNodes();
/*!
* Methods for creation new elements.
* Returns ID of created element or 0 if element not created
*/
- CORBA::Long AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
- CORBA::Long Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
- CORBA::Long AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
- CORBA::Long AddEdge(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddFace(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddVolume(const SMESH::long_array & IDsOfNodes);
- CORBA::Long AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
+ SMESH::smIdType AddNode(CORBA::Double x, CORBA::Double y, CORBA::Double z);
+ SMESH::smIdType Add0DElement(CORBA::Long IDOfNode, CORBA::Boolean DuplicateElements);
+ SMESH::smIdType AddBall(CORBA::Long IDOfNodem, CORBA::Double diameter);
+ SMESH::smIdType AddEdge(const SMESH::long_array & IDsOfNodes);
+ SMESH::smIdType AddFace(const SMESH::long_array & IDsOfNodes);
+ SMESH::smIdType AddPolygonalFace(const SMESH::long_array & IDsOfNodes);
+ SMESH::smIdType AddQuadPolygonalFace(const SMESH::long_array & IDsOfNodes);
+ SMESH::smIdType AddVolume(const SMESH::long_array & IDsOfNodes);
+ SMESH::smIdType AddPolyhedralVolume(const SMESH::long_array & IDsOfNodes,
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
* pointing either \a outside or \a inside the adjacent volumes.
* \return number of reoriented faces.
*/
- CORBA::Long Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
+ SMESH::smIdType Reorient2DBy3D(const SMESH::ListOfIDSources & faces,
SMESH::SMESH_IDSource_ptr volumes,
CORBA::Boolean outsideNormal);
/*!
* \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 z);
/*!
* and coordinates of the projection point.
* 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 z,
SMESH::ElementType type,
CORBA::Boolean toCopyMissingBondary,
SMESH::SMESH_Group_out group);
- CORBA::Long MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
+ SMESH::smIdType MakeBoundaryElements(SMESH::Bnd_Dimension dimension,
const char* groupName,
const char* meshName,
CORBA::Boolean toCopyAll,
*/
//=============================================================================
-CORBA::Long SMESH_Mesh_i::NbGroups()
+SMESH::smIdType SMESH_Mesh_i::NbGroups()
{
Unexpect aCatch(SALOME_SalomeException);
return _mapGroups.size();
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::GetId()
+SMESH::smIdType SMESH_Mesh_i::GetId()
{
return _id;
}
*/
//================================================================================
-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();
*/
//================================================================================
-CORBA::Long SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes)
+SMESH::smIdType SMESH_Mesh_i::FindElementByNodes(const SMESH::long_array& nodes)
{
if ( _preMeshInfo )
_preMeshInfo->FullLoadFromFile();
//-----------------------------------------------------------------------------
struct IDSourceIterator : public SMDS_ElemIterator
{
- const CORBA::Long* _idPtr;
+ const SMESH::smIdType* _idPtr;
const CORBA::Long* _idEndPtr;
SMESH::long_array_var _idArray;
const SMDS_Mesh* _mesh;
if ( SMESH_MeshEditor_i::IsTemporaryIDSource( theObject ))
{
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 ));
}
else
SMESH::ListOfGroups* GetGroups();
- CORBA::Long NbGroups();
+ SMESH::smIdType NbGroups();
SMESH::SMESH_Group_ptr UnionGroups( SMESH::SMESH_GroupBase_ptr theGroup1,
SMESH::SMESH_GroupBase_ptr theGroup2,
void ClearLog();
- CORBA::Long GetId();
+ SMESH::smIdType GetId();
// --- C++ interface
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();
/*!
* 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.
*/
//=============================================================================
-CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
+SMESH::smIdType SMESH_subMesh_i::GetNumberOfElements()
{
Unexpect aCatch(SALOME_SalomeException);
*/
//=============================================================================
-CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
+SMESH::smIdType SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
{
Unexpect aCatch(SALOME_SalomeException);
*/
//=============================================================================
-CORBA::Long SMESH_subMesh_i::GetId()
+SMESH::smIdType SMESH_subMesh_i::GetId()
{
return _localId;
}
int localId );
~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();
GEOM::GEOM_Object_ptr GetSubShape();
- CORBA::Long GetId();
+ SMESH::smIdType GetId();
// =========================
