ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-18 11:40:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

0021130: EDF 1746 SMESH: Issue with export in STL format

Browse Source 
1) move instantiations of templates from separate files to SMESH_TypeDefs.hxx
   2) move frequently used typedefs and small classes from SMESH_MeshEditor to to SMESH_TypeDefs.hxx
This commit is contained in:
eap 2011-01-27 16:44:48 +00:00
parent f44e34f568
commit 40b9d1ba43
9 changed files with 178 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/SMESH/Makefile.am
View File

@ -42,10 +42,7 @@ salomeinclude_HEADERS = \
SMESH_MeshEditor.hxx \
SMESH_Block.hxx \
SMESH_Pattern.hxx \
SMESH_IndexedDataMapOfShapeIndexedMapOfShape.hxx \
SMESH_DataMapOfElemPtrSequenceOfElemPtr.hxx \
SMESH_SequenceOfElemPtr.hxx \
SMESH_SequenceOfNode.hxx \
SMESH_TypeDefs.hxx \
SMESH_MesherHelper.hxx \
SMESH_Octree.hxx \
SMESH_OctreeNode.hxx \

55
src/SMESH/SMESH_DataMapOfElemPtrSequenceOfElemPtr.hxx
View File

@ -1,55 +0,0 @@
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File: SMESH_DataMapOfElemPtrSequenceOfElemPtr.hxx
// Created: 26.09.05 17:41:10
// Author: Sergey KUUL
//
#ifndef SMESH_DataMapOfElemPtrSequenceOfElemPtr_HeaderFile
#define SMESH_DataMapOfElemPtrSequenceOfElemPtr_HeaderFile
#include "SMESH_SMESH.hxx"
#include <SMESH_SequenceOfElemPtr.hxx>
#include <NCollection_DefineDataMap.hxx>
SMESH_EXPORT
inline Standard_Integer HashCode(SMDS_MeshElementPtr theElem,
const Standard_Integer theUpper)
{
void* anElem = (void*) theElem;
return HashCode(anElem,theUpper);
}
SMESH_EXPORT
inline Standard_Boolean IsEqual(SMDS_MeshElementPtr theOne,
SMDS_MeshElementPtr theTwo)
{
return theOne == theTwo;
}
DEFINE_BASECOLLECTION (SMESH_BaseCollectionSequenceOfElemPtr, SMESH_SequenceOfElemPtr)
DEFINE_DATAMAP (SMESH_DataMapOfElemPtrSequenceOfElemPtr,
SMESH_BaseCollectionSequenceOfElemPtr,
SMDS_MeshElementPtr, SMESH_SequenceOfElemPtr)
#endif

56
src/SMESH/SMESH_IndexedDataMapOfShapeIndexedMapOfShape.hxx
View File

@ -1,56 +0,0 @@
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File: SMESH_IndexedDataMapOfShapeIndexedMapOfShape.hxx
// Created: 20.09.05 09:51:12
// Author: Sergey KUUL
//
#ifndef SMESH_IndexedMapOfShape_HeaderFile
#define SMESH_IndexedMapOfShape_HeaderFile
#include "SMESH_SMESH.hxx"
#include "SMESHDS_DataMapOfShape.hxx"
#include <NCollection_DefineIndexedMap.hxx>
#include <TopoDS_Shape.hxx>
/// Class SMESH_IndexedMapOfShape
DEFINE_BASECOLLECTION (SMESH_BaseCollectionShape, TopoDS_Shape)
DEFINE_INDEXEDMAP (SMESH_IndexedMapOfShape, SMESH_BaseCollectionShape, TopoDS_Shape)
#endif
#ifndef SMESH_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile
#define SMESH_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile
#include <NCollection_DefineIndexedDataMap.hxx>
/// Class SMESH_IndexedDataMapOfShapeIndexedMapOfShape
DEFINE_BASECOLLECTION (SMESH_BaseCollectionIndexedMapOfShape, SMESH_IndexedMapOfShape)
DEFINE_INDEXEDDATAMAP (SMESH_IndexedDataMapOfShapeIndexedMapOfShape,
SMESH_BaseCollectionIndexedMapOfShape, TopoDS_Shape,
SMESH_IndexedMapOfShape)
#endif

26
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -1563,7 +1563,7 @@ void SMESH_MeshEditor::SplitVolumesIntoTetra (const TIDSortedElemSet & theElems,
const int theMethodFlags)
{
// std-like iterator on coordinates of nodes of mesh element
typedef SMDS_StdIterator< TNodeXYZ, SMDS_ElemIteratorPtr > NXyzIterator;
typedef SMDS_StdIterator< SMESH_TNodeXYZ, SMDS_ElemIteratorPtr > NXyzIterator;
NXyzIterator xyzEnd;
SMDS_VolumeTool volTool;
@ -6241,7 +6241,7 @@ struct SMESH_NodeSearcherImpl: public SMESH_NodeSearcher
const SMDS_MeshNode* closestNode = 0;
list<const SMDS_MeshNode*>::iterator nIt = nodes.begin();
for ( ; nIt != nodes.end(); ++nIt ) {
double sqDist = thePnt.SquareDistance( SMESH_MeshEditor::TNodeXYZ( *nIt ) );
double sqDist = thePnt.SquareDistance( SMESH_TNodeXYZ( *nIt ) );
if ( minSqDist > sqDist ) {
closestNode = *nIt;
minSqDist = sqDist;
@ -6461,7 +6461,7 @@ namespace // Utils used in SMESH_ElementSearcherImpl::FindElementsByPoint()
_refCount = 1;
SMDS_ElemIteratorPtr nIt = elem->nodesIterator();
while ( nIt->more() )
Add( SMESH_MeshEditor::TNodeXYZ( cast2Node( nIt->next() )));
Add( SMESH_TNodeXYZ( cast2Node( nIt->next() )));
Enlarge( tolerance );
}
@ -6568,7 +6568,7 @@ double SMESH_ElementSearcherImpl::getTolerance()
SMDS_NodeIteratorPtr nodeIt = _mesh->nodesIterator();
elemSize = 1;
if ( meshInfo.NbNodes() > 2 )
elemSize = SMESH_MeshEditor::TNodeXYZ( nodeIt->next() ).Distance( nodeIt->next() );
elemSize = SMESH_TNodeXYZ( nodeIt->next() ).Distance( nodeIt->next() );
}
else
{
@ -6576,7 +6576,7 @@ double SMESH_ElementSearcherImpl::getTolerance()
_mesh->elementsIterator( SMDSAbs_ElementType( complexType ));
const SMDS_MeshElement* elem = elemIt->next();
SMDS_ElemIteratorPtr nodeIt = elem->nodesIterator();
SMESH_MeshEditor::TNodeXYZ n1( cast2Node( nodeIt->next() ));
SMESH_TNodeXYZ n1( cast2Node( nodeIt->next() ));
elemSize = 0;
while ( nodeIt->more() )
{
@ -6610,8 +6610,8 @@ bool SMESH_ElementSearcherImpl::getIntersParamOnLine(const gp_Lin& lin
int nbNodes = face->IsQuadratic() ? face->NbNodes()/2 : face->NbNodes();
for ( int i = 0; i < nbNodes && nbInts < 2; ++i )
{
GC_MakeSegment edge( SMESH_MeshEditor::TNodeXYZ( face->GetNode( i )),
SMESH_MeshEditor::TNodeXYZ( face->GetNode( (i+1)%nbNodes) ));
GC_MakeSegment edge( SMESH_TNodeXYZ( face->GetNode( i )),
SMESH_TNodeXYZ( face->GetNode( (i+1)%nbNodes) ));
anExtCC.Init( lineCurve, edge);
if ( anExtCC.NbExtrema() > 0 && anExtCC.LowerDistance() <= tol)
{
@ -6671,8 +6671,8 @@ void SMESH_ElementSearcherImpl::findOuterBoundary(const SMDS_MeshElement* outerF
seamLinks.insert( link );
// link direction within the outerFace
gp_Vec n1n2( SMESH_MeshEditor::TNodeXYZ( link.node1()),
SMESH_MeshEditor::TNodeXYZ( link.node2()));
gp_Vec n1n2( SMESH_TNodeXYZ( link.node1()),
SMESH_TNodeXYZ( link.node2()));
int i1 = outerFace->GetNodeIndex( link.node1() );
int i2 = outerFace->GetNodeIndex( link.node2() );
bool rev = ( abs(i2-i1) == 1 ? i1 > i2 : i2 > i1 );
@ -6755,7 +6755,7 @@ FindElementsByPoint(const gp_Pnt& point,
const SMDS_MeshNode* closeNode = _nodeSearcher->FindClosestTo( point );
if ( !closeNode ) return foundElements.size();
if ( point.Distance( SMESH_MeshEditor::TNodeXYZ( closeNode )) > tolerance )
if ( point.Distance( SMESH_TNodeXYZ( closeNode )) > tolerance )
return foundElements.size(); // to far from any node
if ( type == SMDSAbs_Node )
@ -6827,7 +6827,7 @@ TopAbs_State SMESH_ElementSearcherImpl::GetPointState(const gp_Pnt& point)
// get face plane
gp_XYZ fNorm;
if ( !SMESH_Algo::FaceNormal( *face, fNorm, /*normalized=*/false)) continue;
gp_Pln facePlane( SMESH_MeshEditor::TNodeXYZ( (*face)->GetNode(0)), fNorm );
gp_Pln facePlane( SMESH_TNodeXYZ( (*face)->GetNode(0)), fNorm );
// perform intersection
IntAna_IntConicQuad intersection( line, IntAna_Quadric( facePlane ));
@ -7080,7 +7080,7 @@ bool SMESH_MeshEditor::isOut( const SMDS_MeshElement* element, const gp_Pnt& poi
while ( nodeIt->more() )
{
const SMDS_MeshNode* node = cast2Node( nodeIt->next() );
xyz.push_back( TNodeXYZ(node) );
xyz.push_back( SMESH_TNodeXYZ(node) );
nodeList.push_back(node);
}
@ -10494,7 +10494,7 @@ namespace {
gp_XYZ centerXYZ (0, 0, 0);
SMDS_ElemIteratorPtr aNodeItr = theElem->nodesIterator();
while (aNodeItr->more())
centerXYZ += SMESH_MeshEditor::TNodeXYZ(cast2Node( aNodeItr->next()));
centerXYZ += SMESH_TNodeXYZ(cast2Node( aNodeItr->next()));
gp_Pnt aPnt = centerXYZ / theElem->NbNodes();
theClassifier.Perform(aPnt, theTol);

64
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -34,8 +34,7 @@
#include "SMDS_MeshElement.hxx"
#include "SMESH_Controls.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_SequenceOfElemPtr.hxx"
#include "SMESH_SequenceOfNode.hxx"
#include "SMESH_TypeDefs.hxx"
#include <utilities.h>
@ -54,17 +53,6 @@ class gp_Pnt;
class SMESH_MesherHelper;
typedef std::map<const SMDS_MeshElement*,
std::list<const SMDS_MeshElement*> > TElemOfElemListMap;
typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
//!< Set of elements sorted by ID, to be used to assure predictability of edition
typedef std::set< const SMDS_MeshElement*, TIDCompare > TIDSortedElemSet;
typedef std::set< const SMDS_MeshNode*, TIDCompare > TIDSortedNodeSet;
typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
//=======================================================================
/*!
* \brief Searcher for the node closest to point
@ -102,35 +90,6 @@ struct SMESH_ElementSearcher
std::vector< const SMDS_MeshElement* >& foundElems)=0;
};
//=======================================================================
/*!
* \brief A sorted pair of nodes
*/
//=======================================================================
struct SMESH_TLink: public NLink
{
SMESH_TLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 ):NLink( n1, n2 )
{ if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
SMESH_TLink(const NLink& link ):NLink( link )
{ if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
const SMDS_MeshNode* node1() const { return first; }
const SMDS_MeshNode* node2() const { return second; }
};
//=======================================================================
/*!
* \brief SMESH_TLink knowing its orientation
*/
//=======================================================================
struct SMESH_OrientedLink: public SMESH_TLink
{
bool _reversed;
SMESH_OrientedLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 )
: SMESH_TLink( n1, n2 ), _reversed( n1 != node1() ) {}
};
// ============================================================
/*!
* \brief Editor of a mesh
@ -139,27 +98,6 @@ struct SMESH_OrientedLink: public SMESH_TLink
class SMESH_EXPORT SMESH_MeshEditor
{
public:
//------------------------------------------
/*!
* \brief SMDS_MeshNode -> gp_XYZ convertor
*/
//------------------------------------------
struct TNodeXYZ : public gp_XYZ
{
const SMDS_MeshNode* _node;
TNodeXYZ( const SMDS_MeshElement* e):gp_XYZ(0,0,0),_node(0) {
if (e) {
ASSERT( e->GetType() == SMDSAbs_Node );
_node = static_cast<const SMDS_MeshNode*>(e);
SetCoord( _node->X(), _node->Y(), _node->Z() );
}
}
double Distance(const SMDS_MeshNode* n) const { return (TNodeXYZ( n )-*this).Modulus(); }
double SquareDistance(const SMDS_MeshNode* n) const { return (TNodeXYZ( n )-*this).SquareModulus(); }
bool operator==(const TNodeXYZ& other) const { return _node == other._node; }
};
public:
SMESH_MeshEditor( SMESH_Mesh* theMesh );

2
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -725,7 +725,7 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
}
else
{
gp_Pnt nodePnt = SMESH_MeshEditor::TNodeXYZ( n );
gp_Pnt nodePnt = SMESH_TNodeXYZ( n );
if ( !loc.IsIdentity() ) nodePnt.Transform( loc.Transformation().Inverted() );
gp_Pnt curvPnt = curve->Value( u );
double dist = nodePnt.Distance( curvPnt );

41
src/SMESH/SMESH_SequenceOfElemPtr.hxx
View File

@ -1,41 +0,0 @@
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File: SMESH_SequenceOfElemPtr.hxx
// Created: 26.09.05 17:41:10
// Author: Sergey KUUL
//
#ifndef SMESH_SequenceOfElemPtr_HeaderFile
#define SMESH_SequenceOfElemPtr_HeaderFile
#include "SMESH_SMESH.hxx"
#include <NCollection_DefineSequence.hxx>
#include <SMDS_MeshElement.hxx>
typedef const SMDS_MeshElement* SMDS_MeshElementPtr;
DEFINE_BASECOLLECTION (SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
DEFINE_SEQUENCE (SMESH_SequenceOfElemPtr, SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
#endif

41
src/SMESH/SMESH_SequenceOfNode.hxx
View File

@ -1,41 +0,0 @@
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File: SMESH_SequenceOfNode.hxx
// Created: 11.11.05 10:00:04
// Author: Sergey KUUL
//
#ifndef SMESH_SequenceOfNode_HeaderFile
#define SMESH_SequenceOfNode_HeaderFile
#include "SMESH_SMESH.hxx"
#include <NCollection_DefineSequence.hxx>
typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
DEFINE_BASECOLLECTION (SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
DEFINE_SEQUENCE(SMESH_SequenceOfNode,
SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
#endif

162
src/SMESH/SMESH_TypeDefs.hxx Normal file
View File

@ -0,0 +1,162 @@
// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : SMESH_TypeDefs.hxx
// Created : Thu Jan 27 18:38:33 2011
// Author : Edward AGAPOV (eap)
#ifndef __SMESH_TypeDefs_HXX__
#define __SMESH_TypeDefs_HXX__
#include "SMESH_SMESH.hxx"
#include <SMDS_MeshNode.hxx>
#include <gp_XYZ.hxx>
#include <map>
#include <list>
#include <set>
typedef std::map<const SMDS_MeshElement*,
std::list<const SMDS_MeshElement*> > TElemOfElemListMap;
typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
//!< Set of elements sorted by ID, to be used to assure predictability of edition
typedef std::set< const SMDS_MeshElement*, TIDCompare > TIDSortedElemSet;
typedef std::set< const SMDS_MeshNode*, TIDCompare > TIDSortedNodeSet;
typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
//=======================================================================
/*!
* \brief A sorted pair of nodes
*/
//=======================================================================
struct SMESH_TLink: public NLink
{
SMESH_TLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 ):NLink( n1, n2 )
{ if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
SMESH_TLink(const NLink& link ):NLink( link )
{ if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
const SMDS_MeshNode* node1() const { return first; }
const SMDS_MeshNode* node2() const { return second; }
};
//=======================================================================
/*!
* \brief SMESH_TLink knowing its orientation
*/
//=======================================================================
struct SMESH_OrientedLink: public SMESH_TLink
{
bool _reversed;
SMESH_OrientedLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 )
: SMESH_TLink( n1, n2 ), _reversed( n1 != node1() ) {}
};
//------------------------------------------
/*!
* \brief SMDS_MeshNode -> gp_XYZ convertor
*/
//------------------------------------------
struct SMESH_TNodeXYZ : public gp_XYZ
{
const SMDS_MeshNode* _node;
SMESH_TNodeXYZ( const SMDS_MeshElement* e):gp_XYZ(0,0,0),_node(0) {
if (e) {
assert( e->GetType() == SMDSAbs_Node );
_node = static_cast<const SMDS_MeshNode*>(e);
SetCoord( _node->X(), _node->Y(), _node->Z() );
}
}
double Distance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).Modulus(); }
double SquareDistance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).SquareModulus(); }
bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
};
// --------------------------------------------------------------------------------
// class SMESH_SequenceOfElemPtr
#include <NCollection_DefineSequence.hxx>
class SMDS_MeshElement;
typedef const SMDS_MeshElement* SMDS_MeshElementPtr;
DEFINE_BASECOLLECTION (SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
DEFINE_SEQUENCE (SMESH_SequenceOfElemPtr, SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
// --------------------------------------------------------------------------------
// class SMESH_SequenceOfNode
typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
DEFINE_BASECOLLECTION (SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
DEFINE_SEQUENCE(SMESH_SequenceOfNode,
SMESH_BaseCollectionNodePtr, SMDS_MeshNodePtr)
// --------------------------------------------------------------------------------
// #include "SMESHDS_DataMapOfShape.hxx"
// #include <NCollection_DefineIndexedMap.hxx>
// #include <TopoDS_Shape.hxx>
/// Class SMESH_IndexedMapOfShape
// DEFINE_BASECOLLECTION (SMESH_BaseCollectionShape, TopoDS_Shape)
// DEFINE_INDEXEDMAP (SMESH_IndexedMapOfShape, SMESH_BaseCollectionShape, TopoDS_Shape)
/// Class SMESH_IndexedDataMapOfShapeIndexedMapOfShape
// DEFINE_BASECOLLECTION (SMESH_BaseCollectionIndexedMapOfShape, SMESH_IndexedMapOfShape)
// DEFINE_INDEXEDDATAMAP (SMESH_IndexedDataMapOfShapeIndexedMapOfShape,
// SMESH_BaseCollectionIndexedMapOfShape, TopoDS_Shape,
// SMESH_IndexedMapOfShape)
// --------------------------------------------------------------------------------
// class SMESH_DataMapOfElemPtrSequenceOfElemPtr
// SMESH_EXPORT
// inline Standard_Integer HashCode(SMDS_MeshElementPtr theElem,
// const Standard_Integer theUpper)
// {
// void* anElem = (void*) theElem;
// return HashCode(anElem,theUpper);
// }
// SMESH_EXPORT
// inline Standard_Boolean IsEqual(SMDS_MeshElementPtr theOne,
// SMDS_MeshElementPtr theTwo)
// {
// return theOne == theTwo;
// }
// DEFINE_BASECOLLECTION (SMESH_BaseCollectionSequenceOfElemPtr, SMESH_SequenceOfElemPtr)
// DEFINE_DATAMAP (SMESH_DataMapOfElemPtrSequenceOfElemPtr,
// SMESH_BaseCollectionSequenceOfElemPtr,
// SMDS_MeshElementPtr, SMESH_SequenceOfElemPtr)
#endif