Salome HOME
New DS implementation
authorjrt <jrt>
Wed, 3 Sep 2003 17:30:36 +0000 (17:30 +0000)
committerjrt <jrt>
Wed, 3 Sep 2003 17:30:36 +0000 (17:30 +0000)
12 files changed:
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMDS/SMDS_MeshEdge.cxx
src/SMDS/SMDS_MeshEdge.hxx
src/SMDS/SMDS_MeshElement.cxx
src/SMDS/SMDS_MeshElement.hxx
src/SMDS/SMDS_MeshFace.cxx
src/SMDS/SMDS_MeshFace.hxx
src/SMDS/SMDS_MeshNode.cxx
src/SMDS/SMDS_MeshNode.hxx
src/SMDS/SMDS_MeshVolume.cxx
src/SMDS/SMDS_MeshVolume.hxx

index 9ba9560..a672828 100644 (file)
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : SMDS_Mesh.cxx
-//  Author : Jean-Michel BOULCOURT
-//  Module : SMESH
-
-using namespace std;
-#include "SMDS_Mesh.ixx"
-#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx"
-#include "SMDS_ListOfMeshElement.hxx"
-#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
-#include "SMDS_MeshNode.hxx"
-#include "SMDS_MeshEdge.hxx"
-#include "SMDS_MeshFace.hxx"
-#include "SMDS_MeshTriangle.hxx"
-#include "SMDS_MeshQuadrangle.hxx"
-#include "SMDS_MeshVolume.hxx"
-#include "SMDS_MeshTetrahedron.hxx"
-#include "SMDS_MeshPyramid.hxx"
-#include "SMDS_MeshPrism.hxx"
-#include "SMDS_MeshHexahedron.hxx"
-#include "SMDS_ListOfMesh.hxx"
-#include "SMDS_ListIteratorOfListOfMesh.hxx"
-
-
-#include <Standard_ErrorHandler.hxx>
-#include <Standard_NoSuchObject.hxx>
 
 #include "utilities.h"
+#include "SMDS_Mesh.hxx"
+#include "SMDS_VolumeOfNodes.hxx"
+#include "SMDS_VolumeOfFaces.hxx"
+#include "SMDS_FaceOfNodes.hxx"
+#include "SMDS_FaceOfEdges.hxx"
 
-
-//=======================================================================
-//function : SMDS_Mesh
-//purpose  : creation of a new mesh object
-//=======================================================================
-
-SMDS_Mesh::SMDS_Mesh(const Standard_Integer nbnodes,
-                    const Standard_Integer nbedges, 
-                    const Standard_Integer nbfaces,
-                    const Standard_Integer nbvolumes)
-  :myNodes(nbnodes),myEdges(nbedges),myFaces(nbfaces),myVolumes(nbvolumes),
-   myNodeIDFactory(new SMDS_MeshNodeIDFactory()), 
-   myElementIDFactory(new SMDS_MeshElementIDFactory()),myHasInverse(Standard_False)
+///////////////////////////////////////////////////////////////////////////////
+/// Create a new mesh object
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Mesh::SMDS_Mesh()
+       :myNodeIDFactory(new SMDS_MeshElementIDFactory()),
+       myElementIDFactory(new SMDS_MeshElementIDFactory()),
+       myHasConstructionEdges(false), myHasConstructionFaces(false),
+       myHasInverseElements(true)
 {
 }
 
-//=======================================================================
-//function : SMDS_Mesh
-//purpose  :  
-//=======================================================================
-
-SMDS_Mesh::SMDS_Mesh(const Handle(SMDS_Mesh)& parent,
-                    const Standard_Integer nbnodes)
-  :myNodes(nbnodes),myParent(parent),myNodeIDFactory(parent->myNodeIDFactory),
-   myElementIDFactory(parent->myElementIDFactory),
-   myHasInverse(Standard_False)
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
+       :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
+       myElementIDFactory(parent->myElementIDFactory),
+       myHasConstructionEdges(false), myHasConstructionFaces(false),
+       myHasInverseElements(true)
 {
 }
 
-//=======================================================================
-//function : AddSubMesh
-//purpose  : create an submesh
-//=======================================================================
+///////////////////////////////////////////////////////////////////////////////
+///Create a submesh and add it to the current mesh
+///////////////////////////////////////////////////////////////////////////////
 
-Handle(SMDS_Mesh) SMDS_Mesh::AddSubMesh()
+SMDS_Mesh *SMDS_Mesh::AddSubMesh()
 {
-  Handle(SMDS_Mesh) submesh = new SMDS_Mesh(this);
-  if (!submesh.IsNull()) {
-    myChildren.Append(submesh);
-  }
-
-  return submesh;
+       SMDS_Mesh *submesh = new SMDS_Mesh(this);
+       myChildren.insert(myChildren.end(), submesh);
+       return submesh;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+///create a MeshNode and add it to the current Mesh
+///@return : The created node
+///////////////////////////////////////////////////////////////////////////////
 
-//=======================================================================
-//function : AddNode
-//purpose  : create a MeshNode and returns an ID
-//=======================================================================
-
-Standard_Integer SMDS_Mesh::AddNode(const Standard_Real x, 
-                                   const Standard_Real y, 
-                                   const Standard_Real z)
+SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
 {
-  Standard_Integer ID = myNodeIDFactory->GetFreeID();
-
-  Handle(SMDS_MeshElement) node = new SMDS_MeshNode(ID,x,y,z);
-  AddNode(node);
-
-  return ID;
+       return AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID());
 }
 
-//=======================================================================
-//function : AddNode
-//purpose  : create a MeshNode. Returns False if the ID already exists
-//=======================================================================
-
-Standard_Boolean SMDS_Mesh::AddNodeWithID(const Standard_Real x, 
-                                         const Standard_Real y, 
-                                         const Standard_Real z,
-                                         const Standard_Integer ID)
+///////////////////////////////////////////////////////////////////////////////
+///create a MeshNode and add it to the current Mesh
+///@param ID : The ID of the MeshNode to create
+///@return : The created node or NULL if a node with this ID already exists
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
 {
+       // find the MeshNode corresponding to ID
+       const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
 
-  // find the MeshNode corresponding to ID
-  Handle(SMDS_MeshElement) node;
-  node = GetNode(ID);
-
-  if (node.IsNull()) {
-    node = new SMDS_MeshNode(ID,x,y,z);
-    AddNode(node);
-    return Standard_True;
-  } else
-    return Standard_False;
-    
-}
-
-//=======================================================================
-//function : AddNode
-//purpose  : add  an existing node in  the mesh (useful for submesh)
-//=======================================================================
-
-Standard_Boolean SMDS_Mesh::AddNode(const Standard_Integer ID)
-{
-  // find the MeshNode corresponding to ID
-  Handle(SMDS_MeshElement) node;
-
-  node = GetNode(ID);
-
-  if (!node.IsNull()) {
-    myNodes.Add(node);
-    return Standard_True;;
-  } else
-    return Standard_False;
-}
-
-//=======================================================================
-//function : AddNode
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean SMDS_Mesh::AddNode(const Handle(SMDS_MeshElement)& node)
-{
-
-  if (!node.IsNull()) {
-    myNodes.Add(node);
-    if (!myParent.IsNull()) {
-      myParent->AddNode(node);
-    }
-    return Standard_True;
-  } else
-    return Standard_False;
-}
-
-
-//=======================================================================
-//function : AddEdge
-//purpose  : 
-//=======================================================================
-
-Standard_Integer SMDS_Mesh::AddEdge(const Standard_Integer idnode1,
-                                           const Standard_Integer idnode2)
-{
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddEdgeWithID(idnode1,idnode2,ID))
-    return ID;
-  else 
-    return 0;
-
+       if (node == NULL)
+       {
+               SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z);
+               myNodes.insert(node);
+               myNodeIDFactory->BindID(ID,node);
+               return node;
+       }
+       else
+               return NULL;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///create a MeshEdge and add it to the current Mesh
+///@return : The created MeshEdge
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshEdge* SMDS_Mesh::AddEdge(int idnode1, int idnode2)
+{
+       return AddEdgeWithID(idnode1, idnode2, myElementIDFactory->GetFreeID());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///Create a new edge and at it to the mesh
+///@param idnode1 ID of the first node
+///@param idnode2 ID of the second node
+///@param ID ID of the edge to create
+///@return The created edge or NULL if an edge with this ID already exists or
+///if input nodes are not found.
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
+{
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       if((node1==NULL)||(node2==NULL)) return NULL;
+       SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1, node2);
+       if(myElementIDFactory->BindID(ID, edge))
+       {
+               node1->AddInverseElement(edge);
+               node2->AddInverseElement(edge);         
+               myEdges.insert(edge);
+               return edge;
+       } 
+       else
+       {
+               delete edge;
+               return NULL;
+       }
 }
 
-//=======================================================================
-//function : AddEdge
-//purpose  : 
-//=======================================================================
+///////////////////////////////////////////////////////////////////////////////
+/// Add a triangle defined by its nodes IDs
+///////////////////////////////////////////////////////////////////////////////
 
-Standard_Boolean SMDS_Mesh::AddEdgeWithID(const Standard_Integer idnode1,
-                                         const Standard_Integer idnode2,
-                                         const Standard_Integer ID)
+SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1, int idnode2, int idnode3)
 {
-  Handle(SMDS_MeshElement) edge,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      elem = CreateEdge(ID,idnode1,idnode2);
-      edge = FindEdge(elem);
-      if (edge.IsNull()) {
-       edge = elem;
-       myEdges.Add(edge);
-      }
-      successAdd = myElementIDFactory->BindID(ID,edge);
-    }
-  }
-  
-  return successAdd;
-
+       return AddFaceWithID(idnode1,idnode2,idnode3,
+               myElementIDFactory->GetFreeID());
 }
 
-//=======================================================================
-//function : AddFace
-//purpose  : 
-//=======================================================================
+///////////////////////////////////////////////////////////////////////////////
+/// Add a quandrangle defined by its nodes IDs
+///////////////////////////////////////////////////////////////////////////////
 
-Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, 
-                                   const Standard_Integer idnode2,
-                                   const Standard_Integer idnode3)
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
 {
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddFaceWithID(idnode1,idnode2,idnode3,ID))
-    return ID;
-  else 
-    return 0;
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
 
-}
-
-//=======================================================================
-//function : AddFace
-//purpose  : 
-//=======================================================================
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
+    SMDS_MeshFace * face=createTriangle(node1,node2,node3);
 
-Standard_Boolean SMDS_Mesh::AddFaceWithID(const Standard_Integer idnode1, 
-                                         const Standard_Integer idnode2,
-                                         const Standard_Integer idnode3,
-                                         const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) face,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       elem = CreateFace(ID,idnode1,idnode2,idnode3);
-       face = FindFace(elem);
-       if (face.IsNull()) {
-         face = elem;
-         myFaces.Add(face);
+       if(myElementIDFactory->BindID(ID, face))
+       {
+               node1->AddInverseElement(face);
+               node2->AddInverseElement(face);
+        node3->AddInverseElement(face);
+               return face;
+       }       
+       else
+       {
+               RemoveFace(face);
+               return NULL;
        }
-       successAdd = myElementIDFactory->BindID(ID,face);
-      }
-    }
-  }
-
-  return successAdd;
-
 }
 
-
 //=======================================================================
 //function : AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, 
-                                           const Standard_Integer idnode2,
-                                           const Standard_Integer idnode3,
-                                           const Standard_Integer idnode4)
+SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1,
+       int idnode2, int idnode3, int idnode4)
 {
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddFaceWithID(idnode1,idnode2,idnode3,idnode4,ID))
-    return ID;
-  else
-    return 0;
-
+       int ID=myElementIDFactory->GetFreeID();
+       SMDS_MeshFace* f= AddFaceWithID(idnode1, idnode2, idnode3, idnode4, ID);
+       if(f==NULL) myElementIDFactory->ReleaseID(ID);
 }
 
-
 //=======================================================================
 //function : AddFace
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean SMDS_Mesh::AddFaceWithID(const Standard_Integer idnode1, 
-                                         const Standard_Integer idnode2,
-                                         const Standard_Integer idnode3,
-                                         const Standard_Integer idnode4,
-                                         const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) face,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       // find the MeshNode corresponding to idnode4
-       if (AddNode(idnode4)) {
-         elem = CreateFace(ID,idnode1,idnode2,idnode3,idnode4);
-         face = FindFace(elem);
-         if (face.IsNull()) {
-           face = elem;
-           myFaces.Add(face);
-         }
-         successAdd = myElementIDFactory->BindID(ID,face);
+//purpose  :
+//=======================================================================
+
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1,
+       int idnode2, int idnode3, int idnode4, int ID)
+{
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
+       SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
+
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL;
+    SMDS_MeshFace * face=createQuadrangle(node1,node2,node3,node4);
+
+       if(myElementIDFactory->BindID(ID, face))
+       {
+               node1->AddInverseElement(face);
+               node2->AddInverseElement(face);
+        node3->AddInverseElement(face);
+               node4->AddInverseElement(face);
+               return face;
+       }       
+       else
+       {
+               RemoveFace(face);
+               return NULL;
        }
-      }
-    }
-  }
-
-  return successAdd;
-
 }
 
-
-
 //=======================================================================
 //function : AddVolume
 //purpose  : Tetrahedra
 //=======================================================================
 
-Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, 
-                                     const Standard_Integer idnode2,
-                                     const Standard_Integer idnode3,
-                                     const Standard_Integer idnode4)
+SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3,
+       int idnode4)
 {
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,ID))
-    return ID;
-  else
-    return 0;
-
+       int ID = myElementIDFactory->GetFreeID();
+       SMDS_MeshVolume * v=
+               AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, ID);
+       if(v==NULL) myElementIDFactory->ReleaseID(ID);
 }
 
-//=======================================================================
-//function : AddVolume
-//purpose  : Tetrahedra
-//=======================================================================
 
-Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, 
-                                           const Standard_Integer idnode2,
-                                           const Standard_Integer idnode3,
-                                           const Standard_Integer idnode4,
-                                           const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) volume,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       // find the MeshNode corresponding to idnode4
-       if (AddNode(idnode4)) {
-         elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4);
-         volume = FindVolume(elem);
-         if (volume.IsNull()) {
-           volume = elem;
-           myVolumes.Add(volume);
-         }
-         successAdd = myElementIDFactory->BindID(ID,volume);
-       }
-      }
-    }
-  }
+///////////////////////////////////////////////////////////////////////////////
+///Create a new tetrahedron and add it to the mesh. 
+///@return The created tetrahedron or NULL if an edge with this ID already exists
+///or if input nodes are not found.
+///////////////////////////////////////////////////////////////////////////////
 
-  return successAdd;
-
-}
-
-//=======================================================================
-//function : AddVolume
-//purpose  : Pyramid
-//=======================================================================
-
-Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, 
-                                     const Standard_Integer idnode2,
-                                     const Standard_Integer idnode3,
-                                     const Standard_Integer idnode4,
-                                     const Standard_Integer idnode5)
+SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
+       int idnode3, int idnode4, int ID)
 {
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,idnode5,ID))
-    return ID;
-  else
-    return 0;
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
+       SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
 
-}
-
-//=======================================================================
-//function : AddVolume
-//purpose  : Pyramid
-//=======================================================================
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)) return NULL;
+       
+       SMDS_MeshVolume* volume;
+       if(hasConstructionFaces())
+       {
+               SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
+               SMDS_MeshFace * f2=createTriangle(node1,node2,node4);
+               SMDS_MeshFace * f3=createTriangle(node1,node3,node4);
+               SMDS_MeshFace * f4=createTriangle(node2,node3,node4);
+               SMDS_MeshVolume* volume=
+                       new SMDS_VolumeOfFaces(f1,f2,f3,f4);
+               myVolumes.insert(volume);
+       }
+       else if(hasConstructionEdges())
+       {
+               /** @todo */
+       }
+       else
+       {
+               /** @todo */
+       }
 
-Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, 
-                                                   const Standard_Integer idnode2,
-                                                   const Standard_Integer idnode3,
-                                                   const Standard_Integer idnode4,
-                                                   const Standard_Integer idnode5,
-                                                   const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) volume,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       // find the MeshNode corresponding to idnode4
-       if (AddNode(idnode4)) {
-         // find the MeshNode corresponding to idnode5
-         if (AddNode(idnode5)) {
-           elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5);
-           volume = FindVolume(elem);
-           if (volume.IsNull()) {
-             volume = elem;
-             myVolumes.Add(volume);
-           }
-           successAdd = myElementIDFactory->BindID(ID,volume);
-         }
+       if(myElementIDFactory->BindID(ID, volume))
+       {
+               node1->AddInverseElement(volume);
+               node2->AddInverseElement(volume);
+        node3->AddInverseElement(volume);
+               node4->AddInverseElement(volume);
+               return volume;
+       }       
+       else
+       {
+               RemoveVolume(volume);
+               return NULL;
        }
-      }
-    }
-  }
+}
 
-  return successAdd;
+///////////////////////////////////////////////////////////////////////////////
+/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1,
+       int idnode2, int idnode3, int idnode4, int idnode5)
+{
+       int ID = myElementIDFactory->GetFreeID();
+       SMDS_MeshVolume * v=
+               AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, ID);
+       if(v==NULL) myElementIDFactory->ReleaseID(ID);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
+       int idnode3, int idnode4, int idnode5, int ID)
+{
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
+       SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
+       SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
+
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL))
+               return NULL;
+       
+       SMDS_MeshVolume* volume;
+       if(hasConstructionFaces())
+       {
+               SMDS_MeshFace * f1=createQuadrangle(node1,node2,node3,node4);
+               SMDS_MeshFace * f2=createTriangle(node1,node2,node5);
+               SMDS_MeshFace * f3=createTriangle(node2,node3,node5);
+               SMDS_MeshFace * f4=createTriangle(node3,node4,node5);
+               SMDS_MeshFace * f5=createTriangle(node4,node1,node4);
+               SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
+               myVolumes.insert(volume);
+       }
+       else if(hasConstructionEdges())
+       {
+               /** @todo */
+       }
+       else
+       {
+               /** @todo */
+       }
 
+       if(myElementIDFactory->BindID(ID, volume))
+       {
+               node1->AddInverseElement(volume);
+               node2->AddInverseElement(volume);
+        node3->AddInverseElement(volume);
+               node4->AddInverseElement(volume);
+               node5->AddInverseElement(volume);
+               return volume;
+       }       
+       else
+       {
+               RemoveVolume(volume);
+               return NULL;
+       }
 }
 
-//=======================================================================
-//function : AddVolume
-//purpose  : Prism
-//=======================================================================
-
-Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, 
-                                     const Standard_Integer idnode2,
-                                     const Standard_Integer idnode3,
-                                     const Standard_Integer idnode4,
-                                     const Standard_Integer idnode5,
-                                     const Standard_Integer idnode6)
+///////////////////////////////////////////////////////////////////////////////
+/// Add a prism. Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3,
+       int idnode4, int idnode5, int idnode6)
 {
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,
-                     idnode5,idnode6,ID))
-    return ID;
-  else
-    return 0;
-
+       int ID = myElementIDFactory->GetFreeID();
+       SMDS_MeshVolume * v=
+               AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6,
+               ID);
+       if(v==NULL) myElementIDFactory->ReleaseID(ID);
 }
 
 //=======================================================================
@@ -479,69 +356,56 @@ Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1,
 //purpose  : Prism
 //=======================================================================
 
-Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, 
-                                           const Standard_Integer idnode2,
-                                           const Standard_Integer idnode3,
-                                           const Standard_Integer idnode4,
-                                           const Standard_Integer idnode5,
-                                           const Standard_Integer idnode6,
-                                           const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) volume,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       // find the MeshNode corresponding to idnode4
-       if (AddNode(idnode4)) {
-         // find the MeshNode corresponding to idnode5
-         if (AddNode(idnode5)) {
-           // find the MeshNode corresponding to idnode6
-           if (AddNode(idnode6)) {
-             elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6);
-             volume = FindVolume(elem);
-             if (volume.IsNull()) {
-               volume = elem;
-               myVolumes.Add(volume);
-             }
-             successAdd = myElementIDFactory->BindID(ID,volume);
-           }
-         }
+SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3,
+       int idnode4, int idnode5, int idnode6, int ID)
+{
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
+       SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
+       SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
+       SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
+
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)||
+               (node6==NULL)) return NULL;
+       
+       SMDS_MeshVolume* volume;
+       if(hasConstructionFaces())
+
+       {
+               SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
+               SMDS_MeshFace * f2=createTriangle(node4,node5,node6);
+               SMDS_MeshFace * f3=createQuadrangle(node1,node4,node5,node2);
+               SMDS_MeshFace * f4=createQuadrangle(node2,node5,node6,node3);
+               SMDS_MeshFace * f5=createQuadrangle(node3,node6,node4,node1);
+               
+               SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
+               myVolumes.insert(volume);
+       }
+       else if(hasConstructionEdges())
+       {
+               /** @todo */
+       }
+       else
+       {
+               /** @todo */
        }
-      }
-    }
-  }
-
-  return successAdd;
-
-}
-
-//=======================================================================
-//function : AddVolume
-//purpose  : Hexahedra
-//=======================================================================
-
-Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, 
-                                     const Standard_Integer idnode2,
-                                     const Standard_Integer idnode3,
-                                     const Standard_Integer idnode4,
-                                     const Standard_Integer idnode5,
-                                     const Standard_Integer idnode6,
-                                     const Standard_Integer idnode7,
-                                     const Standard_Integer idnode8)
-{
-  Standard_Integer ID = myElementIDFactory->GetFreeID();
-  
-  if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,
-                     idnode5,idnode6,idnode7,idnode8,ID))
-    return ID;
-  else
-    return 0;
 
+       if(myElementIDFactory->BindID(ID, volume))
+       {
+               node1->AddInverseElement(volume);
+               node2->AddInverseElement(volume);
+        node3->AddInverseElement(volume);
+               node4->AddInverseElement(volume);
+               node5->AddInverseElement(volume);
+               node6->AddInverseElement(volume);
+               return volume;
+       }       
+       else
+       {
+               RemoveVolume(volume);
+               return NULL;
+       }
 }
 
 //=======================================================================
@@ -549,708 +413,513 @@ Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1,
 //purpose  : Hexahedra
 //=======================================================================
 
-Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, 
-                                           const Standard_Integer idnode2,
-                                           const Standard_Integer idnode3,
-                                           const Standard_Integer idnode4,
-                                           const Standard_Integer idnode5,
-                                           const Standard_Integer idnode6,
-                                           const Standard_Integer idnode7,
-                                           const Standard_Integer idnode8,
-                                           const Standard_Integer ID)
-{
-  Handle(SMDS_MeshElement) volume,elem;
-  Standard_Boolean successAdd = Standard_False;
-
-  // find the MeshNode corresponding to idnode1
-  if (AddNode(idnode1)) {
-    // find the MeshNode corresponding to idnode2
-    if (AddNode(idnode2)) {
-      // find the MeshNode corresponding to idnode3
-      if (AddNode(idnode3)) {
-       // find the MeshNode corresponding to idnode4
-       if (AddNode(idnode4)) {
-         // find the MeshNode corresponding to idnode5
-         if (AddNode(idnode5)) {
-           // find the MeshNode corresponding to idnode6
-           if (AddNode(idnode6)) {
-             // find the MeshNode corresponding to idnode7
-             if (AddNode(idnode7)) {
-               // find the MeshNode corresponding to idnode8
-               if (AddNode(idnode8)) {
-                 elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5,
-                                     idnode6,idnode7,idnode8);
-                 volume = FindVolume(elem);
-                 if (volume.IsNull()) {
-                   volume = elem;
-                   myVolumes.Add(volume);
-                 }
-                 successAdd = myElementIDFactory->BindID(ID,volume);
-               }
-             }
-           }
-         }
+SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3,
+       int idnode4, int idnode5, int idnode6, int idnode7, int idnode8)
+{
+       int ID = myElementIDFactory->GetFreeID();
+       SMDS_MeshVolume * v=
+               AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6,
+               idnode7, idnode8, ID);
+       if(v==NULL) myElementIDFactory->ReleaseID(ID);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Add an hexahedron to the mesh. node 1,2,3,4 and 5,6,7,8 are quadrangle and
+/// 5,1 and 7,3 are an edges.
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshVolume*  SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3,
+       int idnode4, int idnode5, int idnode6, int idnode7, int idnode8, int ID)
+{
+       SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
+       SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
+       SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
+       SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
+       SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
+       SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
+       SMDS_MeshNode * node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
+       SMDS_MeshNode * node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
+
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)||
+               (node6==NULL)||(node7==NULL)||(node8==NULL)) return NULL;
+       
+       SMDS_MeshVolume* volume;
+       if(hasConstructionFaces())
+       {
+               SMDS_MeshFace * f1=FindFaceOrCreate(node1,node2,node3,node4);
+               SMDS_MeshFace * f2=FindFaceOrCreate(node5,node6,node7,node8);
+               SMDS_MeshFace * f3=FindFaceOrCreate(node1,node4,node8,node5);
+               SMDS_MeshFace * f4=FindFaceOrCreate(node1,node2,node6,node5);
+               SMDS_MeshFace * f5=FindFaceOrCreate(node2,node3,node7,node6);
+               SMDS_MeshFace * f6=FindFaceOrCreate(node3,node4,node8,node7);
+               volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
+               myVolumes.insert(volume);
+       }
+       else if(hasConstructionEdges())
+       {
+               MESSAGE("Error : Not Implemented");
+       }
+       else
+       {
+               volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6,node7,node8);
+               myVolumes.insert(volume);
        }
-      }
-    }
-  }
-
-  return successAdd;
-
-}
-
-
-//=======================================================================
-//function : GetNode
-//purpose  : returns the MeshNode corresponding to the ID
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::GetNode(const Standard_Integer idnode) const
-{
-
-  Handle(SMDS_MeshElement) node;
-
-  Handle(SMDS_MeshElement) elem = FindNode(idnode);
-  if (!elem.IsNull()) { // found one correspondance
-    node =  elem;
-  } else {
-    if (!myParent.IsNull())
-      node = myParent->GetNode(idnode);
-  }
-
-  return node;
-}
-
-//=======================================================================
-//function : FindNode
-//purpose  : 
-//=======================================================================
 
-Handle(SMDS_MeshElement) SMDS_Mesh::FindNode(const Standard_Integer ID) const
-{
-  Handle(SMDS_MeshElement) elem;
-  if (myNodes.ContainsID(ID))
-    elem = myNodes.FindID(ID);
-  return elem;
+       if(myElementIDFactory->BindID(ID, volume))
+       {
+               //MESSAGE("SMDS_Mesh::AddVolumeWithID: update inverse elements");
+               node1->AddInverseElement(volume);
+               node2->AddInverseElement(volume);
+        node3->AddInverseElement(volume);
+               node4->AddInverseElement(volume);
+               node5->AddInverseElement(volume);
+               node6->AddInverseElement(volume);
+               node7->AddInverseElement(volume);
+               node8->AddInverseElement(volume);
+               return volume;
+       }       
+       else
+       {
+               RemoveVolume(volume);
+               return NULL;
+       }
 }
 
 //=======================================================================
 //function : FindNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-Handle(SMDS_MeshElement) SMDS_Mesh::FindNode(const Handle(SMDS_MeshElement)& node) const
+const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
 {
-  Handle(SMDS_MeshElement) elem;
-  if (myNodes.Contains(node))
-    elem = myNodes.Find(node);
-
-  return elem;
+       return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID);
 }
 
-//=======================================================================
-//function : CreateEdge
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateEdge(const Standard_Integer ID,
-                                              const Standard_Integer idnode1,
-                                              const Standard_Integer idnode2) const
+///////////////////////////////////////////////////////////////////////////////
+///Create a triangle and add it to the current mesh. This methode do not bind a
+///ID to the create triangle.
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1,
+       SMDS_MeshNode * node2, SMDS_MeshNode * node3)
 {
-  Handle(SMDS_MeshEdge) edge = new SMDS_MeshEdge(ID,idnode1,idnode2);
-  return edge;
-}
-
-
-//=======================================================================
-//function : CreateFace
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateFace(const Standard_Integer ID,
-                                              const Standard_Integer idnode1,
-                                              const Standard_Integer idnode2,
-                                              const Standard_Integer idnode3) const
-{
-  Handle(SMDS_MeshFace) face = new SMDS_MeshTriangle(ID,idnode1,idnode2,idnode3);
-  return face;
-}
-
-
-//=======================================================================
-//function : CreateFace
-//purpose  : 
-//=======================================================================
+       if(hasConstructionEdges())
+       {
+               SMDS_MeshEdge *edge1, *edge2, *edge3;
+               edge1=FindEdgeOrCreate(node1,node2);
+               edge2=FindEdgeOrCreate(node2,node3);
+               edge3=FindEdgeOrCreate(node3,node1);
 
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateFace(const Standard_Integer ID,
-                                              const Standard_Integer idnode1,
-                                              const Standard_Integer idnode2,
-                                              const Standard_Integer idnode3,
-                                              const Standard_Integer idnode4) const
-{
-  Handle(SMDS_MeshFace) face = new SMDS_MeshQuadrangle(ID,idnode1,idnode2,idnode3,idnode4);
-  return face;
-}
-
-//=======================================================================
-//function : CreateVolume
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID,
-                                                const Standard_Integer idnode1,
-                                                const Standard_Integer idnode2,
-                                                const Standard_Integer idnode3,
-                                                const Standard_Integer idnode4) const
-{
-  Handle(SMDS_MeshVolume) volume = new SMDS_MeshTetrahedron(ID,idnode1,idnode2,idnode3,idnode4);
-  return volume;
-}
-
-//=======================================================================
-//function : CreateVolume
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID,
-                                                const Standard_Integer idnode1,
-                                                const Standard_Integer idnode2,
-                                                const Standard_Integer idnode3,
-                                                const Standard_Integer idnode4,
-                                                const Standard_Integer idnode5) const
-{
-  Handle(SMDS_MeshVolume) volume = new SMDS_MeshPyramid(ID,idnode1,idnode2,idnode3,idnode4,idnode5);
-  return volume;
-}
-
-//=======================================================================
-//function : CreateVolume
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID,
-                                                const Standard_Integer idnode1,
-                                                const Standard_Integer idnode2,
-                                                const Standard_Integer idnode3,
-                                                const Standard_Integer idnode4,
-                                                const Standard_Integer idnode5,
-                                                const Standard_Integer idnode6) const
-{
-  Handle(SMDS_MeshVolume) volume = new SMDS_MeshPrism(ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6);
-  return volume;
-}
-
-//=======================================================================
-//function : CreateVolume
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID,
-                                                const Standard_Integer idnode1,
-                                                const Standard_Integer idnode2,
-                                                const Standard_Integer idnode3,
-                                                const Standard_Integer idnode4,
-                                                const Standard_Integer idnode5,
-                                                const Standard_Integer idnode6,
-                                                const Standard_Integer idnode7,
-                                                const Standard_Integer idnode8) const
-{
-  Handle(SMDS_MeshVolume) volume = new SMDS_MeshHexahedron(ID,idnode1,idnode2,idnode3,idnode4,
-                                                          idnode5,idnode6,idnode7,idnode8);
-  return volume;
-}
-
-//=======================================================================
-//function : Contains
-//purpose  : 
-//=======================================================================
-
-Standard_Boolean SMDS_Mesh::Contains(const Handle(SMDS_MeshElement)& elem) const
-{
-  Standard_Boolean isinmesh = Standard_False;
-  if (myNodes.Contains(elem))
-    isinmesh = Standard_True;
-  else if (myEdges.Contains(elem))
-    isinmesh = Standard_True;
-  else if (myFaces.Contains(elem))
-    isinmesh = Standard_True;
-  else if (myVolumes.Contains(elem))
-    isinmesh = Standard_True;
-
-  return isinmesh;
-}
-
-//=======================================================================
-//function : FindEdge
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindEdge(const Handle(SMDS_MeshElement)& edge) const
-{
-  Handle(SMDS_MeshElement) elem;
-  if (myEdges.Contains(edge))
-    elem = myEdges.Find(edge);
-
-  return elem;
-}
-
-//=======================================================================
-//function : FindFace
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Handle(SMDS_MeshElement)& face) const
-{
-  Handle(SMDS_MeshElement) elem;
-  if (myFaces.Contains(face))
-    elem = myFaces.Find(face);
-
-  return elem;
-}
-
-
-//=======================================================================
-//function : FindVolume
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindVolume(const Handle(SMDS_MeshElement)& volume) const
-{
-  Handle(SMDS_MeshElement) elem;
-  if (myVolumes.Contains(volume))
-    elem = myVolumes.Find(volume);
-
-  return elem;
+               SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
+               myFaces.insert(face);
+               return face;
+       }
+       else
+       {
+               SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3);
+               myFaces.insert(face);
+               return face;
+       }
 }
 
-
-//=======================================================================
-//function : FreeNode
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::FreeNode(const Handle(SMDS_MeshElement)& node)
-{
-    myNodes.Remove(node);
-
-    SMDS_ListIteratorOfListOfMesh itmsh(myChildren);
-    for (;itmsh.More(); itmsh.Next()) {
-      const Handle(SMDS_Mesh)& submesh = itmsh.Value();
-      submesh->RemoveNode(node->GetID());
-    }
+///////////////////////////////////////////////////////////////////////////////
+///Create a quadrangle and add it to the current mesh. This methode do not bind
+///a ID to the create triangle.
+///////////////////////////////////////////////////////////////////////////////
+SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1,
+       SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4)
+{
+       if(hasConstructionEdges())
+       {
+               SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
+               edge1=FindEdgeOrCreate(node1,node2);
+               edge2=FindEdgeOrCreate(node2,node3);
+               edge3=FindEdgeOrCreate(node3,node4);
+               edge4=FindEdgeOrCreate(node4,node1);
+
+               SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
+               myFaces.insert(face);
+               return face;
+       }
+       else
+       {
+               SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
+               myFaces.insert(face);
+               return face;
+       }
 }
 
-
-
 //=======================================================================
 //function : RemoveNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveNode(const Standard_Integer IDnode)
+void SMDS_Mesh::RemoveNode(int IDnode)
 {
-  // find the MeshNode corresponding to IDnode
-  Handle(SMDS_MeshElement) node = FindNode(IDnode);
-  if (RemoveNode(node)) {
-    if (myParent.IsNull()) { // if no parent we can release the ID
-      myNodeIDFactory->ReleaseID(IDnode);
-    }
-  }
-  
+       RemoveNode(FindNode(IDnode));
 }
 
 //=======================================================================
 //function : RemoveNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-Standard_Boolean SMDS_Mesh::RemoveNode(const Handle(SMDS_MeshElement)& node)
+bool SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 {
-  Standard_Boolean successRemove = Standard_False;
-
-  if (!node.IsNull()) {
-    if (myHasInverse && myNodes.Contains(node)) {
-      SMDS_MapOfMeshOrientedElement map(1);
-      BuildMapNodeAncestors(node,map);
-      RemoveAncestors(node,map);
-    }
-
-    FreeNode(node);
-    successRemove = Standard_True;
-  }
-
-  return successRemove;
+       SMDS_Iterator<const SMDS_MeshElement *> * it=
+               node->GetInverseElementIterator();
+       while(it->more()) RemoveElement(it->next(),true);
+       myNodeIDFactory->ReleaseID(node->GetID());
+       myNodes.erase(const_cast<SMDS_MeshNode*>(node));
 }
 
 //=======================================================================
 //function : RemoveEdge
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveEdge(const Standard_Integer idnode1, const Standard_Integer idnode2)
+void SMDS_Mesh::RemoveEdge(int idnode1, int idnode2)
 {
-  Handle(SMDS_MeshElement) edge = FindEdge(idnode1,idnode2);
-  RemoveEdge(edge);
+       RemoveEdge(FindEdge(idnode1, idnode2));
 }
 
 //=======================================================================
 //function : RemoveEdge
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveEdge(const Handle(SMDS_MeshElement)& edge)
+void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 {
-
-  if (!edge.IsNull()) {
-    myEdges.Remove(edge);
-
-    myElementIDFactory->ReleaseID(edge->GetID());
-  }
+       /** @todo to be fix */
+       myEdges.erase(const_cast<SMDS_MeshEdge*>(edge));
+       //removeElementDependencies(edge);
+       delete edge;
 }
 
-
 //=======================================================================
 //function : RemoveFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, 
-                          const Standard_Integer idnode2,
-                          const Standard_Integer idnode3)
+void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3)
 {
-  Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3);
-  RemoveFace(face);
+       RemoveFace(FindFace(idnode1, idnode2, idnode3));
 }
 
 //=======================================================================
 //function : RemoveFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, 
-                          const Standard_Integer idnode2,
-                          const Standard_Integer idnode3,
-                          const Standard_Integer idnode4)
+void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3, int idnode4)
 {
-  Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3,idnode4);
-  RemoveFace(face);
+       RemoveFace(FindFace(idnode1, idnode2, idnode3, idnode4));
 }
 
-
 //=======================================================================
 //function : RemoveFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveFace(const Handle(SMDS_MeshElement)& face)
+void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 {
-  if (!face.IsNull()) {
-    myFaces.Remove(face);
-    myElementIDFactory->ReleaseID(face->GetID());
-  }
+       /** @todo to be fix */
+       myFaces.erase(const_cast<SMDS_MeshFace*>(face));
+       //removeElementDependencies(face);
+       delete face;
 }
 
 //=======================================================================
 //function : RemoveVolume
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::RemoveVolume(const Handle(SMDS_MeshElement)& volume)
-{
-  if (myVolumes.Contains(volume)) {
-    myVolumes.Remove(volume);
-    myElementIDFactory->ReleaseID(volume->GetID());
-  }
+//purpose  :
+//=======================================================================
+
+void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
+{
+       /** @todo to be fix */
+       myVolumes.erase(const_cast<SMDS_MeshVolume*>(volume));
+       //removeElementDependencies(volume);
+       delete volume;
+}
+///////////////////////////////////////////////////////////////////////////////
+/// Remove no longer used sub element of an element. Unbind the element ID
+///////////////////////////////////////////////////////////////////////////////
+void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * element)
+{
+       /** @todo to be fix */
+       myElementIDFactory->ReleaseID(element->GetID());
+       SMDS_Iterator<const SMDS_MeshElement*> * it=element->nodesIterator();
+       while(it->more())
+       {
+               SMDS_MeshNode * node=static_cast<SMDS_MeshNode*>(
+                       const_cast<SMDS_MeshElement*>(it->next()));
+               node->RemoveInverseElement(element);
+               if(node->emptyInverseElements()) RemoveNode(node);
+       }
 }
-
 //=======================================================================
 //function : RemoveElement
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMDS_Mesh::RemoveElement(const Standard_Integer IDelem,const Standard_Boolean removenodes)
+void SMDS_Mesh::RemoveElement(int IDelem, const bool removenodes)
 {
-  Handle(SMDS_MeshElement) elem =  myElementIDFactory->MeshElement(IDelem);
-  RemoveElement(elem,removenodes);
-
-
-    
+       RemoveElement(myElementIDFactory->MeshElement(IDelem), removenodes);
 }
 
 //=======================================================================
 //function : RemoveElement
-//purpose  : 
-//=======================================================================
+//purpose  :
+//=======================================================================
+
+void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
+       const bool removenodes)
+{
+       /** @todo to be fix */
+       switch(elem->GetType())
+       {
+    case SMDSAbs_Node:
+               RemoveNode((const SMDS_MeshNode*)elem);
+               return;
+    case SMDSAbs_Edge:
+               RemoveEdge((const SMDS_MeshEdge*)elem);
+               break;
+    case SMDSAbs_Face:
+               RemoveFace((const SMDS_MeshFace*)elem);
+               break;
+    case SMDSAbs_Volume:
+               RemoveVolume((const SMDS_MeshVolume*)elem);
+               break;
+    default :
+               MESSAGE("remove function : unknown type");
+               return;
+       }
+/*     
+       SMDS_Iterator<const SMDS_MeshNode*> * it=elem->nodesIterator();
+       while(it->more())
+       {
+               const SMDS_MeshNode * node=it->next();
+               
+       }*/
+}
 
-void SMDS_Mesh::RemoveElement(const Handle(SMDS_MeshElement)& elem,const Standard_Boolean removenodes)
-{
-  if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshEdge)) ) {
-    RemoveEdge(elem);
-  } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshNode))) {
-    RemoveNode(elem);
-    return;
-  } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshFace))) {
-    RemoveFace(elem);
-  } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshVolume))) {
-    RemoveVolume(elem);
-  } else {
-    MESSAGE( "remove function : unknown type" );
-    return;
-  }
-
-  Standard_Integer nbcnx = elem->NbNodes();
-  Standard_Integer i;
-  for (i=1; i <= nbcnx; ++i) {
-    RemoveInverseElement(GetNode(i,elem),elem);
-    
-  }
-
-  if (removenodes) {
-    for (i=1; i <= nbcnx; ++i) {
-      if (GetNode(i,elem)->InverseElements().IsEmpty())
-       FreeNode(GetNode(i,elem));
-    }
-  }
-
-}
 //=======================================================================
 //function : RemoveFromParent
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-Standard_Boolean SMDS_Mesh::RemoveFromParent()
+bool SMDS_Mesh::RemoveFromParent()
 {
-  if (myParent.IsNull())
-    return Standard_False;
-
-  return (myParent->RemoveSubMesh(this));
-
+       if (myParent==NULL) return false;
+       else return (myParent->RemoveSubMesh(this));
 }
 
 //=======================================================================
 //function : RemoveSubMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-Standard_Boolean SMDS_Mesh::RemoveSubMesh(const Handle(SMDS_Mesh)& aMesh)
+bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
 {
-  Standard_Boolean found = Standard_False;
-
-  SMDS_ListIteratorOfListOfMesh itmsh(myChildren);
-  for (;itmsh.More() && !found; itmsh.Next()) {
-    Handle(SMDS_Mesh) submesh;
-    submesh = itmsh.Value();
-    if (submesh == aMesh) {
-      found = Standard_True;
-      myChildren.Remove(itmsh);
-    }
-  }
+       bool found = false;
 
-  return found;
-}
-
-//=======================================================================
-//function : RemoveInverseElement
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::RemoveInverseElement(const Handle(SMDS_MeshElement)& elem, 
-                                    const Handle(SMDS_MeshElement)& parent) const
-{
-  if (!myHasInverse) 
-    return;
-
-  Handle(SMDS_MeshNode)& node = *((Handle(SMDS_MeshNode)*)&elem);
-  node->RemoveInverseElement(parent);
-}
-//=======================================================================
-//function : RemoveAncestors
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::RemoveAncestors(const Handle(SMDS_MeshElement)& elem,
-                               const SMDS_MapOfMeshOrientedElement& map)
-{
-
-  if (!myHasInverse) 
-    return;
-
-  SMDS_MapIteratorOfExtendedOrientedMap itAnc(map);
-
-  for (;itAnc.More();itAnc.Next()) {
-    const Handle(SMDS_MeshElement)& ME = itAnc.Key();
-    Standard_Integer nbcnx = ME->NbNodes();
-
-    for (Standard_Integer i=1; i <= nbcnx; ++i) {
-      RemoveInverseElement(GetNode(i,ME),ME);
-    }
-  }
-
-  SMDS_MapIteratorOfExtendedOrientedMap itAnc2(map);
-
-  for (;itAnc2.More();itAnc2.Next()) {
-    const Handle(SMDS_MeshElement)& ME = itAnc2.Key();
-    RemoveElement(ME);
-  }
-}
-
-//=======================================================================
-//function : BuildMapNodeAncestors
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::BuildMapNodeAncestors(const Handle(SMDS_MeshElement)& ME, 
-                                     SMDS_MapOfMeshOrientedElement& map) const
-{
-
-  if (!myHasInverse) 
-    return;
-
-  Standard_Integer nbcnx = ME->NbNodes();
-
-  for (Standard_Integer i=1; i <= nbcnx; ++i) {
-    const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements();
-
-    SMDS_ListIteratorOfListOfMeshElement it(lstInvElements);
-    for (;it.More();it.Next()) {
-      const Handle(SMDS_MeshElement)& meParent = it.Value();
-      if (Contains(meParent))
-       map.Add(meParent);
-    }
-
-  }
-
-}
-
-
-//=======================================================================
-//function : BuildMapEdgeAncestors
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::BuildMapEdgeAncestors(const Handle(SMDS_MeshElement)& ME, 
-                                     SMDS_MapOfMeshOrientedElement& map) const
-{
-
-  if (!myHasInverse) 
-    return;
-
-  Standard_Integer nbcnx = ME->NbNodes();
-
-  for (Standard_Integer i=1; i <= nbcnx; ++i) {
-    const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements();
-
-    SMDS_ListIteratorOfListOfMeshElement it(lstInvElements);
-    for (;it.More();it.Next()) {
-      const Handle(SMDS_MeshElement)& meParent = it.Value();
-      if ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshEdge)) && Contains(meParent))
-       map.Add(meParent);
-    }
-
-  }
+       list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
+       for (; itmsh!=myChildren.end() && !found; itmsh++)
+       {
+               SMDS_Mesh * submesh = *itmsh;
+               if (submesh == aMesh)
+               {
+                       found = true;
+                       myChildren.erase(itmsh);
+               }
+       }
 
+       return found;
 }
 
 
 //=======================================================================
-//function : BuildMapFaceAncestors
-//purpose  : 
-//=======================================================================
-
-void SMDS_Mesh::BuildMapFaceAncestors(const Handle(SMDS_MeshElement)& ME, 
-                                     SMDS_MapOfMeshOrientedElement& map) const
-{
-
-  if (!myHasInverse) 
-    return;
-
-  Standard_Integer nbcnx = ME->NbNodes();
-
-  for (Standard_Integer i=1; i <= nbcnx; ++i) {
-    const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements();
-
-    SMDS_ListIteratorOfListOfMeshElement it(lstInvElements);
-    for (;it.More();it.Next()) {
-      const Handle(SMDS_MeshElement)& meParent = it.Value();
-      if ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshEdge))
-          && ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshFace))) && Contains(meParent) )
-       map.Add(meParent);
-    }
-
-  }
-
+//function : FindEdge
+//purpose  :
+//=======================================================================
+
+const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const
+{
+       const SMDS_MeshNode * node1=FindNode(idnode1);
+       const SMDS_MeshNode * node2=FindNode(idnode2);
+       if((node1==NULL)||(node2==NULL)) return NULL;
+       return FindEdge(node1,node2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///
+///////////////////////////////////////////////////////////////////////////////
+//#include "Profiler.h"
+const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
+       const SMDS_MeshNode * node2) const
+{
+       const SMDS_MeshEdge * toReturn=NULL;
+       //PROFILER_Init();
+       //PROFILER_Set();
+       SMDS_Iterator<const SMDS_MeshElement *>*  it1=node1->edgesIterator();
+       //PROFILER_Get(0);
+       //PROFILER_Set();
+       while(it1->more())
+       {
+               const SMDS_MeshEdge * e=static_cast<const SMDS_MeshEdge *>
+                       (it1->next());
+               SMDS_Iterator<const SMDS_MeshElement *>* it2=e->nodesIterator();
+               while(it2->more())
+               {
+                       if(it2->next()->GetID()==node2->GetID())
+                       {
+                               toReturn=e;
+                               break;
+                       }
+               }
+               delete it2;
+       }
+       //PROFILER_Get(1);
+       delete it1;
+       return toReturn;
 }
 
 
-//=======================================================================
-//function : FindEdge
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindEdge(const Standard_Integer idnode1,
-                                            const Standard_Integer idnode2 ) const
+SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
+       const SMDS_MeshNode * node2) 
 {
-  Handle(SMDS_MeshEdge) edge = new SMDS_MeshEdge(0,idnode1,idnode2);
-  return FindEdge(edge);
+       SMDS_MeshEdge * toReturn=NULL;
+       toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
+       if(toReturn==NULL)      
+       {
+               toReturn=new SMDS_MeshEdge(const_cast<SMDS_MeshNode*>(node1),
+                       const_cast<SMDS_MeshNode*>(node2));
+               myEdges.insert(toReturn);
+       } 
+       return toReturn;
 }
 
 //=======================================================================
 //function : FindFace
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Standard_Integer idnode1,
-                                            const Standard_Integer idnode2,
-                                            const Standard_Integer idnode3 ) const
-{
-  Handle(SMDS_MeshFace) face = new SMDS_MeshTriangle(0,idnode1,idnode2,idnode3);
-  return FindFace(face);
+//purpose  :
+//=======================================================================
+
+const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
+       int idnode3) const
+{
+       const SMDS_MeshNode * node1=FindNode(idnode1);
+       const SMDS_MeshNode * node2=FindNode(idnode2);
+       const SMDS_MeshNode * node3=FindNode(idnode3);
+       const SMDS_MeshFace * face;
+       const SMDS_MeshElement * node;
+       bool node2found, node3found;
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
+
+       SMDS_Iterator<const SMDS_MeshElement *>*  it1=node1->facesIterator();
+       while(it1->more())
+       {
+               face=static_cast<const SMDS_MeshFace*>(it1->next());
+               if(face->NbNodes()!=3) continue;
+               SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
+               node2found=false;
+               node3found=false;
+               while(it2->more())
+               {
+                       node=it2->next();
+                       if(node->GetID()==idnode2) node2found=true;
+                       if(node->GetID()==idnode3) node3found=true;
+               }
+               delete it2;
+               if(node2found&&node3found)
+               {
+                       delete it1;
+                       return face;
+               }
+       }
+       delete it1;
+       return NULL;
 }
 
 //=======================================================================
 //function : FindFace
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Standard_Integer idnode1,
-                                            const Standard_Integer idnode2,
-                                            const Standard_Integer idnode3,
-                                            const Standard_Integer idnode4 ) const
-{
-  Handle(SMDS_MeshFace) face = new SMDS_MeshQuadrangle(0,idnode1,idnode2,idnode3,idnode4);
-  return FindFace(face);
+//purpose  :
+//=======================================================================
+
+const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, int idnode3,
+       int idnode4) const
+{
+       const SMDS_MeshNode * node1=FindNode(idnode1);
+       const SMDS_MeshNode * node2=FindNode(idnode2);
+       const SMDS_MeshNode * node3=FindNode(idnode3);
+       const SMDS_MeshNode * node4=FindNode(idnode4);
+       if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL;
+       return FindFace(node1, node2, node3, node4);
+}
+
+const SMDS_MeshFace* SMDS_Mesh::FindFace(
+               const SMDS_MeshNode *node1,
+               const SMDS_MeshNode *node2,
+               const SMDS_MeshNode *node3,
+               const SMDS_MeshNode *node4) const
+{
+       const SMDS_MeshFace * face;
+       const SMDS_MeshElement * node;
+       bool node2found, node3found, node4found;
+       SMDS_Iterator<const SMDS_MeshElement *>*  it1=node1->facesIterator();
+       while(it1->more())
+       {
+               face=static_cast<const SMDS_MeshFace *>(it1->next());
+               if(face->NbNodes()!=4) continue;
+               SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
+               node2found=false;
+               node3found=false;
+               node4found=false;
+               while(it2->more())
+               {
+                       node=it2->next();
+                       if(node->GetID()==node2->GetID()) node2found=true;
+                       if(node->GetID()==node3->GetID()) node3found=true;
+                       if(node->GetID()==node4->GetID()) node4found=true;
+               }
+               delete it2;
+               if(node2found&&node3found&&node4found)
+               {
+                       delete it1;
+                       return face;
+               }
+       }
+       delete it1;
+       return NULL;
 }
 
-//=======================================================================
-//function : FindElement
-//purpose  : 
-//=======================================================================
-
-Handle(SMDS_MeshElement) SMDS_Mesh::FindElement(const Standard_Integer IDelem) const
+SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(
+               const SMDS_MeshNode *node1,
+               const SMDS_MeshNode *node2,
+               const SMDS_MeshNode *node3,
+               const SMDS_MeshNode *node4)
 {
-  return myElementIDFactory->MeshElement(IDelem);
+       SMDS_MeshFace * toReturn=NULL;
+       toReturn=const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3,node4));
+       if(toReturn==NULL)      
+       {
+               toReturn=createQuadrangle(
+                       const_cast<SMDS_MeshNode *>(node1),
+                       const_cast<SMDS_MeshNode *>(node2),
+                       const_cast<SMDS_MeshNode *>(node3),
+                       const_cast<SMDS_MeshNode *>(node4)
+               );
+       } 
+       return toReturn;
 }
 
 //=======================================================================
-//function : GetNode
-//purpose  : 
+//function : FindElement
+//purpose  :
 //=======================================================================
 
-Handle(SMDS_MeshNode) SMDS_Mesh::GetNode(const Standard_Integer rank, 
-                                        const Handle(SMDS_MeshElement)& ME) const
-
+const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
 {
-  const Standard_Integer idnode = ME->GetConnection(rank); // take care, no control of bounds
-
-  Handle(SMDS_MeshElement) elem = FindNode(idnode);
-  Handle(SMDS_MeshNode)& node = *((Handle(SMDS_MeshNode)*)&elem);
-  return node;
-
+       return myElementIDFactory->MeshElement(IDelem);
 }
 
-
 //=======================================================================
 //function : DumpNodes
 //purpose  : 
@@ -1258,20 +927,12 @@ Handle(SMDS_MeshNode) SMDS_Mesh::GetNode(const Standard_Integer rank,
 
 void SMDS_Mesh::DumpNodes() const
 {
-  MESSAGE( "dump nodes of mesh : " );
-
-  SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes);
-
-  for (;itnode.More();itnode.Next()) {
-    const Handle(SMDS_MeshElement)& node = itnode.Key();
-    MESSAGE( node);
-    
-  }
-
+       MESSAGE("dump nodes of mesh : ");
+       SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
+       while(itnode->more()) MESSAGE(itnode->next());
+       delete itnode;
 }
 
-
-
 //=======================================================================
 //function : DumpEdges
 //purpose  : 
@@ -1279,18 +940,12 @@ void SMDS_Mesh::DumpNodes() const
 
 void SMDS_Mesh::DumpEdges() const
 {
-  MESSAGE( "dump edges of mesh : " );
-
-  SMDS_MapIteratorOfExtendedOrientedMap itedge(myEdges);
-
-  for (;itedge.More();itedge.Next()) {
-    const Handle(SMDS_MeshElement)& edge = itedge.Key();
-    MESSAGE( edge);
-  }
+       MESSAGE("dump edges of mesh : ");
+       SMDS_Iterator<const SMDS_MeshEdge *> * itedge=edgesIterator();
+       while(itedge->more()) MESSAGE(itedge->next());
+       delete itedge;
 }
 
-
-
 //=======================================================================
 //function : DumpFaces
 //purpose  : 
@@ -1298,17 +953,12 @@ void SMDS_Mesh::DumpEdges() const
 
 void SMDS_Mesh::DumpFaces() const
 {
-  MESSAGE( "dump faces of mesh : " );
-
-  SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces);
-
-  for (;itface.More();itface.Next()) {
-    const Handle(SMDS_MeshElement)& face = itface.Key();
-    MESSAGE( face);
-  }
+       MESSAGE("dump faces of mesh : ");
+       SMDS_Iterator<const SMDS_MeshFace *> * itface=facesIterator();
+       while(itface->more()) MESSAGE(itface->next());
+       delete itface;
 }
 
-
 //=======================================================================
 //function : DumpVolumes
 //purpose  : 
@@ -1316,18 +966,12 @@ void SMDS_Mesh::DumpFaces() const
 
 void SMDS_Mesh::DumpVolumes() const
 {
-  MESSAGE( "dump volumes of mesh : " );
-
-  SMDS_MapIteratorOfExtendedOrientedMap itvol(myVolumes);
-
-  for (;itvol.More();itvol.Next()) {
-    const Handle(SMDS_MeshElement)& volume = itvol.Key();
-    MESSAGE( volume);
-  }
+       MESSAGE("dump volumes of mesh : ");
+       SMDS_Iterator<const SMDS_MeshVolume *> * itvol=volumesIterator();
+       while(itvol->more()) MESSAGE(itvol->next());
+       delete itvol;
 }
 
-
-
 //=======================================================================
 //function : DebugStats
 //purpose  : 
@@ -1335,159 +979,288 @@ void SMDS_Mesh::DumpVolumes() const
 
 void SMDS_Mesh::DebugStats() const
 {
-  //VRV: T2.4 impossible to use Logger server
-  MESSAGE( "Debug stats of mesh : " );
-
-  MESSAGE( "===== NODES =====" );
-  myNodes.Statistics(cout);
-
-  MESSAGE( "===== EDGES =====" );
-  myEdges.Statistics(cout);
-
-  MESSAGE( "===== FACES =====" );
-  myFaces.Statistics(cout);
-
-  MESSAGE( "===== VOLUMES =====" );
-  myVolumes.Statistics(cout);
-  //VRV: T2.4 impossible to use Logger server
-
-  MESSAGE( "End Debug stats of mesh " );
+       MESSAGE("Debug stats of mesh : ");
+
+       MESSAGE("===== NODES ====="<<NbNodes());
+       MESSAGE("===== EDGES ====="<<NbEdges());
+       MESSAGE("===== FACES ====="<<NbFaces());
+       MESSAGE("===== VOLUMES ====="<<NbVolumes());
+
+       MESSAGE("End Debug stats of mesh ");
+
+       //#ifdef DEB
+       
+       SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
+       int sizeofnodes = 0;
+       int sizeoffaces = 0;
+
+       while(itnode->more())
+       {
+               const SMDS_MeshNode *node = itnode->next();
+
+               sizeofnodes += sizeof(*node);
+               
+               SMDS_Iterator<const SMDS_MeshElement *> * it=
+                       node->GetInverseElementIterator();
+               while(it->more())
+               {
+                       const SMDS_MeshElement *me = it->next();
+                       sizeofnodes += sizeof(me);
+               }
+               delete it;
 
-  //#ifdef DEB
-  SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes);
-  Standard_Integer sizeofnodes = 0;
-  Standard_Integer sizeoffaces = 0;
+       }
+       delete itnode;
+       SMDS_Iterator<const SMDS_MeshFace*>* itface=facesIterator();
+       
+       while(itface->more())
+       {
+               const SMDS_MeshElement *face = itface->next();          
+               sizeoffaces += sizeof(*face);
 
+       }
+       MESSAGE("total size of node elements = " << sizeofnodes);;
+       MESSAGE("total size of face elements = " << sizeoffaces);;
 
-  for (;itnode.More();itnode.Next()) {
-    const Handle(SMDS_MeshElement)& node = itnode.Key();
-    
-    Standard_Transient *p = node->This();
-    sizeofnodes += sizeof( *((SMDS_MeshNode *)p) );
+       //#endif
 
-    SMDS_ListIteratorOfListOfMeshElement it(node->InverseElements());
-    for (;it.More();it.Next()) {
-      const Handle(SMDS_MeshElement)& me = it.Value();
-      sizeofnodes += sizeof(me);
-    }
-    
-  }
+}
 
-  SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces);
+int SMDS_Mesh::NbNodes() const
+{
+       myNodes.size();
+}
 
-  for (;itface.More();itface.Next()) {
-    const Handle(SMDS_MeshElement)& face = itface.Key();
-    
-    Standard_Transient *p = face->This();
-    sizeoffaces += sizeof( *((SMDS_MeshFace *)p) );
-    
-  }
-  MESSAGE( "total size of node elements = " << sizeofnodes );;
-  MESSAGE( "total size of face elements = " << sizeoffaces );;
+int SMDS_Mesh::NbEdges() const
+{
+       return myEdges.size();
+}
 
-  //#endif
+int SMDS_Mesh::NbFaces() const
+{
+       return myFaces.size();
+}
 
+int SMDS_Mesh::NbVolumes() const
+{
+       return myVolumes.size();
 }
 
-//=======================================================================
-//function : RebuildAllInverseConnections
-//purpose  : 
-//=======================================================================
+int SMDS_Mesh::NbSubMesh() const
+{
+       return myChildren.size();
+}
 
-void SMDS_Mesh::RebuildAllInverseConnections()
+SMDS_Mesh::~SMDS_Mesh()
 {
-  if (!myParent.IsNull())
-    myParent->RebuildAllInverseConnections();
+       if(myParent==NULL)
+       {
+               delete myNodeIDFactory;
+               delete myElementIDFactory;
+       }
 
-  else {
-    // Clear all inverseconnections from nodes
-    SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes);
-    
-    for (;itnode.More();itnode.Next()) {
-      const Handle(SMDS_MeshElement)& elem = itnode.Key();
-      elem->ClearInverseElements();
-    }
-    
+       list<SMDS_Mesh*>::iterator itc=myChildren.begin();
+       while(itc!=myChildren.end())
+       {
+               delete *itc;
+               itc++;
+       }
+       
+       SMDS_Iterator<const SMDS_MeshNode*> * itn=nodesIterator();
+       while(itn->more())
+       {
+               delete itn->next();
+       }
+       delete itn;
+
+       set<SMDS_MeshEdge*>::iterator ite=myEdges.begin();
+       while(ite!=myEdges.end())
+       {
+               delete *ite;
+               ite++;
+       }
 
-    RebuildInverseConnections();
+       set<SMDS_MeshFace*>::iterator itf=myFaces.begin();
+       while(itf!=myFaces.end())
+       {
+               delete *itf;
+               itf++;
+       }
 
-    SMDS_ListIteratorOfListOfMesh itmsh(myChildren);
-    for (;itmsh.More(); itmsh.Next()) {
-      Handle(SMDS_Mesh) submesh;
-      submesh = itmsh.Value();
-    
-      submesh->RebuildInverseConnections();
+       set<SMDS_MeshVolume*>::iterator itv=myVolumes.begin();
+       while(itv!=myVolumes.end())
+       {
+               delete *itv;
+               itv++;
+       }
 
-    }
-  }
 }
 
-//=======================================================================
-//function : RebuildInverseConnections
-//purpose  : 
-//=======================================================================
+bool SMDS_Mesh::hasConstructionEdges()
+{
+       return myHasConstructionEdges;
+}
 
-void SMDS_Mesh::RebuildInverseConnections()
+bool SMDS_Mesh::hasConstructionFaces()
 {
-  // rebuld inverse connections to volumes
-  SMDS_MapIteratorOfExtendedOrientedMap itvol(myVolumes);
+       return myHasConstructionFaces;
+}
 
-  for (;itvol.More();itvol.Next()) {
-    const Handle(SMDS_MeshElement)& vol = itvol.Key();
+bool SMDS_Mesh::hasInverseElements()
+{
+       return myHasInverseElements;
+}
 
-    Standard_Integer nbcnx = vol->NbNodes();
-    for (Standard_Integer inode=1; inode<=nbcnx; ++inode) {
-      Standard_Integer idnode = vol->GetConnection(inode);
-      Handle(SMDS_MeshElement) node = FindNode(idnode);
-      if (!node.IsNull())
-       node->AddInverseElement(vol);
-    }
-    
-  }
+void SMDS_Mesh::setConstructionEdges(bool b)
+{
+       myHasConstructionEdges=b;
+}
 
-  // rebuld inverse connections to faces
-  SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces);
+void SMDS_Mesh::setConstructionFaces(bool b)
+{
+        myHasConstructionFaces=b;
+}
 
-  for (;itface.More();itface.Next()) {
-    const Handle(SMDS_MeshElement)& face = itface.Key();
+void SMDS_Mesh::setInverseElements(bool b)
+{
+       if(!b) MESSAGE("Error : inverseElement=false not implemented");
+       myHasInverseElements=b;
+}
 
-    Standard_Integer nbcnx = face->NbNodes();
-    for (Standard_Integer inode=1; inode<=nbcnx; ++inode) {
-      Standard_Integer idnode = face->GetConnection(inode);
-      Handle(SMDS_MeshElement) node = FindNode(idnode);
-      if (!node.IsNull())
-       node->AddInverseElement(face);
-    }
-    
-  }
+///////////////////////////////////////////////////////////////////////////////
+///Return an iterator on nodes of the current mesh. Once used this iterator
+///must be free by the caller
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshNode *> * SMDS_Mesh::nodesIterator() const
+{
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshNode*>
+       {
+               const SetOfNodes& mySet;
+               SetOfNodes::iterator myIterator;
+         public:
+               MyIterator(const SetOfNodes& s):mySet(s)
+               {
+                       myIterator=mySet.begin();
+               }
 
-  // rebuld inverse connections to edges
-  SMDS_MapIteratorOfExtendedOrientedMap itedge(myEdges);
+               bool more()
+               {
+                       myIterator!=mySet.end();
+               }
 
-  for (;itedge.More();itedge.Next()) {
-    const Handle(SMDS_MeshElement)& edge = itedge.Key();
+               const SMDS_MeshNode* next()
+               {
+                       const SMDS_MeshNode* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+       return new MyIterator(myNodes);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///Return an iterator on volumes of the current mesh. Once used this iterator
+///must be free by the caller
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshEdge *> * SMDS_Mesh::edgesIterator() const
+{
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshEdge*>
+       {
+               const SetOfEdges& mySet;
+               const SMDS_MeshEdge * myEdge;
+               SetOfEdges::iterator myIterator;
+         public:
+               MyIterator(const SetOfEdges& s):mySet(s)
+               {
+                       myIterator=mySet.begin();
+               }
 
-    Standard_Integer nbcnx = edge->NbNodes();
-    for (Standard_Integer inode=1; inode<=nbcnx; ++inode) {
-      Standard_Integer idnode = edge->GetConnection(inode);
-      Handle(SMDS_MeshElement) node = FindNode(idnode);
-      if (!node.IsNull())
-       node->AddInverseElement(edge);
-    }
-    
-  }
+               bool more()
+               {
+                       while((myIterator!=mySet.end()))
+                       {
+                               if((*myIterator)->GetID()!=-1)
+                                       return true;
+                               myIterator++;
+                       }
+                       return false;
+               }
 
-  myHasInverse = Standard_True;
-}
+               const SMDS_MeshEdge* next()
+               {
+                       const SMDS_MeshEdge* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+       return new MyIterator(myEdges);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///Return an iterator on faces of the current mesh. Once used this iterator
+///must be free by the caller
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshFace *> * SMDS_Mesh::facesIterator() const
+{
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshFace*>
+       {
+               const SetOfFaces& mySet;
+               set<SMDS_MeshFace*>::iterator myIterator;
+         public:
+               MyIterator(const SetOfFaces& s):mySet(s)
+               {
+                       myIterator=mySet.begin();
+               }
 
+               bool more()
+               {
+                       while((myIterator!=mySet.end()))
+                       {
+                               if((*myIterator)->GetID()!=-1)
+                                       return true;
+                               myIterator++;
+                       }
+                       return false;
+               }
 
-//=======================================================================
-//function : SubMeshIterator
-//purpose  : returns the ith SubMesh
-//=======================================================================
+               const SMDS_MeshFace* next()
+               {
+                       const SMDS_MeshFace* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+       return new MyIterator(myFaces);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///Return an iterator on volumes of the current mesh. Once used this iterator
+///must be free by the caller
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshVolume *> * SMDS_Mesh::volumesIterator() const
+{
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshVolume*>
+       {
+               const SetOfVolumes& mySet;
+               SetOfVolumes::iterator myIterator;
+         public:
+               MyIterator(const SetOfVolumes& s):mySet(s)
+               {
+                       myIterator=mySet.begin();
+               }
 
-void SMDS_Mesh::SubMeshIterator(SMDS_ListIteratorOfListOfMesh& itmsh) const
-{
-  itmsh.Initialize(myChildren);
+               bool more()
+               {
+                       myIterator!=mySet.end();
+               }
+
+               const SMDS_MeshVolume* next()
+               {
+                       const SMDS_MeshVolume* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+       return new MyIterator(myVolumes);
 }
 
index d847620..946d9b0 100644 (file)
 #ifndef _SMDS_Mesh_HeaderFile
 #define _SMDS_Mesh_HeaderFile
 
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_Mesh_HeaderFile
-#include "Handle_SMDS_Mesh.hxx"
-#endif
-
-#ifndef _SMDS_MapOfMeshOrientedElement_HeaderFile
-#include "SMDS_MapOfMeshOrientedElement.hxx"
-#endif
-#ifndef _Handle_SMDS_Mesh_HeaderFile
-#include "Handle_SMDS_Mesh.hxx"
-#endif
-#ifndef _SMDS_ListOfMesh_HeaderFile
-#include "SMDS_ListOfMesh.hxx"
-#endif
-#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile
-#include "Handle_SMDS_MeshNodeIDFactory.hxx"
-#endif
-#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile
-#include "Handle_SMDS_MeshElementIDFactory.hxx"
-#endif
-#ifndef _Standard_Boolean_HeaderFile
-#include "Standard_Boolean.hxx"
-#endif
-#ifndef _SMDS_MeshObject_HeaderFile
-#include "SMDS_MeshObject.hxx"
-#endif
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _Standard_Real_HeaderFile
-#include <Standard_Real.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshElement_HeaderFile
-#include "Handle_SMDS_MeshElement.hxx"
-#endif
-#ifndef _Handle_SMDS_MeshNode_HeaderFile
-#include "Handle_SMDS_MeshNode.hxx"
-#endif
-class SMDS_MeshNodeIDFactory;
-class SMDS_MeshElementIDFactory;
-class Standard_NoSuchObject;
-class SMDS_MeshVolumesIterator;
-class SMDS_MeshFacesIterator;
-class SMDS_MeshEdgesIterator;
-class SMDS_MeshNodesIterator;
-class SMDS_MeshElement;
-class SMDS_MeshNode;
-class SMDS_ListIteratorOfListOfMesh;
-class SMDS_MapOfMeshOrientedElement;
-
-
-class SMDS_Mesh : public SMDS_MeshObject {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT SMDS_Mesh(const Standard_Integer nbnodes = 10,const Standard_Integer nbedges = 10,const Standard_Integer nbfaces = 10,const Standard_Integer nbvolumes = 10);
-Standard_EXPORT   Handle_SMDS_Mesh AddSubMesh() ;
-Standard_EXPORT virtual  Standard_Integer AddNode(const Standard_Real x,const Standard_Real y,const Standard_Real z) ;
-Standard_EXPORT virtual  Standard_Boolean AddNodeWithID(const Standard_Real x,const Standard_Real y,const Standard_Real z,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Boolean AddNode(const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) ;
-Standard_EXPORT virtual  Standard_Boolean AddEdgeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ;
-Standard_EXPORT virtual  Standard_Boolean AddFaceWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ;
-Standard_EXPORT virtual  Standard_Boolean AddFaceWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ;
-Standard_EXPORT virtual  Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) ;
-Standard_EXPORT virtual  Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6) ;
-Standard_EXPORT virtual  Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer ID) ;
-Standard_EXPORT virtual  Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8) ;
-Standard_EXPORT virtual  Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8,const Standard_Integer ID) ;
-Standard_EXPORT   Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4) ;
-Standard_EXPORT   Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5) ;
-Standard_EXPORT   Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5,const Handle(SMDS_MeshElement)& node6) ;
-Standard_EXPORT   Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5,const Handle(SMDS_MeshElement)& node6,const Handle(SMDS_MeshElement)& node7,const Handle(SMDS_MeshElement)& node8) ;
-Standard_EXPORT virtual  void RemoveNode(const Standard_Integer IDnode) ;
-Standard_EXPORT virtual  void RemoveEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) ;
-Standard_EXPORT virtual  void RemoveFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ;
-Standard_EXPORT virtual  void RemoveFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ;
-Standard_EXPORT virtual  void RemoveElement(const Standard_Integer IDelem,const Standard_Boolean removenodes = Standard_False) ;
-Standard_EXPORT   void RemoveElement(const Handle(SMDS_MeshElement)& elem,const Standard_Boolean removenodes = Standard_False) ;
-Standard_EXPORT virtual  Standard_Boolean RemoveFromParent() ;
-Standard_EXPORT virtual  Standard_Boolean RemoveSubMesh(const Handle(SMDS_Mesh)& aMesh) ;
-Standard_EXPORT   Handle_SMDS_MeshNode GetNode(const Standard_Integer rank,const Handle(SMDS_MeshElement)& ME) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindNode(const Standard_Integer idnode) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindElement(const Standard_Integer IDelem) const;
-Standard_EXPORT   Standard_Boolean Contains(const Handle(SMDS_MeshElement)& elem) const;
-Standard_EXPORT   void RebuildAllInverseConnections() ;
-Standard_EXPORT   void SubMeshIterator(SMDS_ListIteratorOfListOfMesh& itmsh) const;
-Standard_EXPORT inline   Standard_Integer NbNodes() const;
-Standard_EXPORT inline   Standard_Integer NbEdges() const;
-Standard_EXPORT inline   Standard_Integer NbFaces() const;
-Standard_EXPORT inline   Standard_Integer NbVolumes() const;
-Standard_EXPORT inline   Standard_Integer NbSubMesh() const;
-Standard_EXPORT   void DumpNodes() const;
-Standard_EXPORT   void DumpEdges() const;
-Standard_EXPORT   void DumpFaces() const;
-Standard_EXPORT   void DumpVolumes() const;
-Standard_EXPORT   void DebugStats() const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateEdge(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateFace(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateFace(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6) const;
-Standard_EXPORT   Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8) const;
-Standard_EXPORT ~SMDS_Mesh();
-
-
-friend class SMDS_MeshVolumesIterator;
-friend class SMDS_MeshFacesIterator;
-friend class SMDS_MeshEdgesIterator;
-friend class SMDS_MeshNodesIterator;
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_Mesh_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
-
-protected:
-
- // Methods PROTECTED
- // 
-Standard_EXPORT   Handle_SMDS_MeshElement FindNode(const Handle(SMDS_MeshElement)& node) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindEdge(const Handle(SMDS_MeshElement)& edge) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindFace(const Handle(SMDS_MeshElement)& face) const;
-Standard_EXPORT   Handle_SMDS_MeshElement FindVolume(const Handle(SMDS_MeshElement)& volume) const;
-Standard_EXPORT   void RemoveInverseElement(const Handle(SMDS_MeshElement)& node,const Handle(SMDS_MeshElement)& parent) const;
-Standard_EXPORT   Standard_Boolean RemoveNode(const Handle(SMDS_MeshElement)& node) ;
-Standard_EXPORT   void RemoveEdge(const Handle(SMDS_MeshElement)& edge) ;
-Standard_EXPORT   void RemoveFace(const Handle(SMDS_MeshElement)& face) ;
-Standard_EXPORT   void RemoveVolume(const Handle(SMDS_MeshElement)& volume) ;
-Standard_EXPORT   Handle_SMDS_MeshElement GetNode(const Standard_Integer ID) const;
-Standard_EXPORT   void RemoveAncestors(const Handle(SMDS_MeshElement)& ME,const SMDS_MapOfMeshOrientedElement& map) ;
-
-
- // Fields PROTECTED
- //
-
-
-private: 
-
- // Methods PRIVATE
- // 
-Standard_EXPORT SMDS_Mesh(const Handle(SMDS_Mesh)& parent,const Standard_Integer nbnodes = 10);
-Standard_EXPORT   Standard_Boolean AddNode(const Handle(SMDS_MeshElement)& node) ;
-Standard_EXPORT   void FreeNode(const Handle(SMDS_MeshElement)& node) ;
-Standard_EXPORT   void BuildMapNodeAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const;
-Standard_EXPORT   void BuildMapEdgeAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const;
-Standard_EXPORT   void BuildMapFaceAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const;
-Standard_EXPORT   void RebuildInverseConnections() ;
-
-
- // Fields PRIVATE
- //
-SMDS_MapOfMeshOrientedElement myNodes;
-SMDS_MapOfMeshOrientedElement myEdges;
-SMDS_MapOfMeshOrientedElement myFaces;
-SMDS_MapOfMeshOrientedElement myVolumes;
-Handle_SMDS_Mesh myParent;
-SMDS_ListOfMesh myChildren;
-Handle_SMDS_MeshNodeIDFactory myNodeIDFactory;
-Handle_SMDS_MeshElementIDFactory myElementIDFactory;
-Standard_Boolean myHasInverse;
-
-
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshEdge.hxx"
+#include "SMDS_MeshFace.hxx"
+#include "SMDS_MeshVolume.hxx"
+#include "SMDS_MeshElementIDFactory.hxx"
+#include "SMDS_Iterator.hxx"
+
+#include <set>
+#include <list>
+
+class SMDSControl_BoundaryEdges;
+
+class SMDS_Mesh:public SMDS_MeshObject
+{
+
+  public:
+
+       SMDS_Mesh();
+
+       SMDS_Iterator<const SMDS_MeshNode *> * nodesIterator() const;
+       SMDS_Iterator<const SMDS_MeshEdge *> * edgesIterator() const;
+       SMDS_Iterator<const SMDS_MeshFace *> * facesIterator() const;
+       SMDS_Iterator<const SMDS_MeshVolume *> * volumesIterator() const;
+
+       SMDS_Mesh *AddSubMesh();
+       virtual SMDS_MeshNode* AddNode(double x, double y, double z);
+       virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
+
+       virtual SMDS_MeshEdge* AddEdge(int idnode1, int idnode2);
+       virtual SMDS_MeshEdge* AddEdgeWithID(int idnode1, int idnode2, int ID);
+       virtual SMDS_MeshFace* AddFace(int idnode1, int idnode2, int idnode3);
+       virtual SMDS_MeshFace* AddFaceWithID(int idnode1, int idnode2, int idnode3,
+               int ID);
+       virtual SMDS_MeshFace* AddFace(int idnode1, int idnode2, int idnode3,
+               int idnode4);
+       virtual SMDS_MeshFace* AddFaceWithID(int idnode1, int idnode2, int idnode3,
+               int idnode4, int ID);
+       virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3,
+               int idnode4);
+       virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2,
+               int idnode3, int idnode4, int ID);
+       virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3,
+               int idnode4, int idnode5);
+       virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, int idnode3,
+               int idnode4, int idnode5, int ID);
+       virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3,
+               int idnode4, int idnode5, int idnode6);
+       virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2,
+               int idnode3, int idnode4, int idnode5, int idnode6, int ID);
+       virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3,
+               int idnode4, int idnode5, int idnode6, int idnode7, int idnode8);
+       virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, int idnode3,
+               int idnode4, int idnode5, int idnode6, int idnode7, int idnode8,
+               int ID);
+       virtual void RemoveNode(int IDnode);
+       virtual void RemoveEdge(int idnode1, int idnode2);
+       virtual void RemoveFace(int idnode1, int idnode2, int idnode3);
+       virtual void RemoveFace(int idnode1, int idnode2, int idnode3, int idnode4);
+       virtual void RemoveElement(int IDelem, const bool removenodes = false);
+       void RemoveElement(const SMDS_MeshElement * elem, const bool removenodes =
+               false);
+    bool RemoveNode(const SMDS_MeshNode * node);       //Remove a node and elements which need this node
+       void RemoveEdge(const SMDS_MeshEdge * edge);
+       void RemoveFace(const SMDS_MeshFace * face);
+       void RemoveVolume(const SMDS_MeshVolume * volume);
+
+       virtual bool RemoveFromParent();
+       virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh);
+       
+       const SMDS_MeshNode *FindNode(int idnode) const;
+       const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
+       const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
+       const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const;
+       const SMDS_MeshElement *FindElement(int IDelem) const;
+       
+       int NbNodes() const;
+       int NbEdges() const;
+       int NbFaces() const;
+       int NbVolumes() const;
+       int NbSubMesh() const;
+       void DumpNodes() const;
+       void DumpEdges() const;
+       void DumpFaces() const;
+       void DumpVolumes() const;
+       void DebugStats() const;
+       SMDS_Mesh *boundaryFaces();
+       SMDS_Mesh *boundaryEdges();
+        ~SMDS_Mesh();
+    bool hasConstructionEdges();
+    bool hasConstructionFaces();
+       bool hasInverseElements();
+    void setConstructionEdges(bool);
+    void setConstructionFaces(bool);
+       void setInverseElements(bool);
+
+  private:
+    SMDS_Mesh(SMDS_Mesh * parent);
+    SMDS_MeshFace * createTriangle(SMDS_MeshNode * node1,
+               SMDS_MeshNode * node2, SMDS_MeshNode * node3);
+       SMDS_MeshFace * createQuadrangle(SMDS_MeshNode * node1,
+               SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4);
+       void removeElementDependencies(SMDS_MeshElement * element);
+       const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
+               const SMDS_MeshNode * n2) const;
+       SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
+               const SMDS_MeshNode * n2);
+       SMDS_MeshFace* FindFaceOrCreate(
+               const SMDS_MeshNode *n1,
+               const SMDS_MeshNode *n2,
+               const SMDS_MeshNode *n3);
+       const SMDS_MeshFace* FindFace(
+               const SMDS_MeshNode *n1,
+               const SMDS_MeshNode *n2,
+               const SMDS_MeshNode *n3,
+               const SMDS_MeshNode *n4) const;
+       SMDS_MeshFace* FindFaceOrCreate(
+               const SMDS_MeshNode *n1,
+               const SMDS_MeshNode *n2,
+               const SMDS_MeshNode *n3,
+               const SMDS_MeshNode *n4);
+
+       // Fields PRIVATE
+       typedef set<SMDS_MeshNode *> SetOfNodes;
+       typedef set<SMDS_MeshEdge *> SetOfEdges;
+       typedef set<SMDS_MeshFace *> SetOfFaces;
+       typedef set<SMDS_MeshVolume *> SetOfVolumes;
+
+       SetOfNodes myNodes;
+       SetOfEdges myEdges;
+       SetOfFaces myFaces;
+       SetOfVolumes myVolumes;
+       SMDS_Mesh *myParent;
+       list<SMDS_Mesh *> myChildren;
+       SMDS_MeshElementIDFactory *myNodeIDFactory;
+       SMDS_MeshElementIDFactory *myElementIDFactory;
+
+    bool myHasConstructionEdges;
+    bool myHasConstructionFaces;
+       bool myHasInverseElements;
 };
 
-
-#include "SMDS_Mesh.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif
index c6d6b78..3f7994c 100644 (file)
 //  Author : Jean-Michel BOULCOURT
 //  Module : SMESH
 
-using namespace std;
-#include "SMDS_MeshEdge.ixx"
+
+#include "SMDS_MeshEdge.hxx"
+#include "SMDS_IteratorOfElements.hxx"
+#include "SMDS_MeshNode.hxx"
+#include <iostream>
 
 //=======================================================================
 //function : SMDS_MeshEdge
 //purpose  : 
 //=======================================================================
 
-SMDS_MeshEdge::SMDS_MeshEdge(const Standard_Integer ID,
-                            const Standard_Integer idnode1, 
-                            const Standard_Integer idnode2) :
-SMDS_MeshElement(ID,2,SMDSAbs_Edge)
-{
-  SetConnections(idnode1,idnode2);
-  ComputeKey();
+SMDS_MeshEdge::SMDS_MeshEdge(SMDS_MeshNode * node1, SMDS_MeshNode * node2)
+{      
+       myNodes[0]=node1;
+       myNodes[1]=node2;
 }
 
 //=======================================================================
-//function : SetConnections
+//function : Print
 //purpose  : 
 //=======================================================================
-void SMDS_MeshEdge::SetConnections(const Standard_Integer idnode1, 
-                                  const Standard_Integer idnode2)
+
+void SMDS_MeshEdge::Print(ostream & OS) const
 {
-  Standard_Integer idmin = (idnode1 < idnode2? idnode1 : idnode2);
-
-  myNodes[0] = idmin;
-  if (idmin == idnode1) {
-    myNodes[1] = idnode2;
-  } else {
-    myNodes[1] = idnode1;
-  }
+       OS << "edge <" << GetID() << "> : (" << myNodes[0] << " , " << myNodes[1] <<
+               ") " << endl;
 }
 
-//=======================================================================
-//function : Print
-//purpose  : 
-//=======================================================================
+int SMDS_MeshEdge::NbNodes() const
+{
+       return 2;
+}
 
-void SMDS_MeshEdge::Print(Standard_OStream& OS) const
+int SMDS_MeshEdge::NbEdges() const
 {
-  OS << "edge <" << myID <<"> : (" << myNodes[0] << " , " << myNodes[1] << ") " << endl;  
+       return 1;
 }
 
+SMDSAbs_ElementType SMDS_MeshEdge::GetType() const
+{
+       return SMDSAbs_Edge;
+}
+
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshEdge::
+       elementsIterator(SMDSAbs_ElementType type) const
+{
+       class MyNodeIterator:public SMDS_Iterator<const SMDS_MeshElement *>
+       {
+               SMDS_MeshNode *const* myNodes;
+               int myIndex;
+         public:
+               MyNodeIterator(SMDS_MeshNode * const* nodes):myNodes(nodes),myIndex(0)
+               {}      
+
+               bool more()
+               {
+                       return myIndex<2;
+               }
+
+               const SMDS_MeshElement* next()
+               {
+                       myIndex++;
+                       return myNodes[myIndex-1];
+               }       
+       };
 
+       switch(type)
+       {
+       case SMDSAbs_Edge:return SMDS_MeshElement::elementsIterator(SMDSAbs_Edge); 
+       case SMDSAbs_Node:return new MyNodeIterator(myNodes);
+       default: return new SMDS_IteratorOfElements(this,type, nodesIterator());
+       }
 
+}
+
+bool operator<(const SMDS_MeshEdge & e1, const SMDS_MeshEdge & e2)
+{
+       int id11=e1.myNodes[0]->GetID();
+       int id21=e2.myNodes[0]->GetID();
+       int id12=e1.myNodes[1]->GetID();
+       int id22=e2.myNodes[1]->GetID();
+       int tmp;
 
+       if(id11>=id12) 
+       {
+               tmp=id11;
+               id11=id12;
+               id12=tmp;       
+       }
+       if(id21>=id22) 
+       {
+               tmp=id21;
+               id21=id22;
+               id22=tmp;       
+       }
+
+       if(id11<id21) return true;
+       else if(id11==id21) return (id21<id22);
+       else return false;
+}
index 4d82d00..0ed6e55 100644 (file)
 #ifndef _SMDS_MeshEdge_HeaderFile
 #define _SMDS_MeshEdge_HeaderFile
 
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshEdge_HeaderFile
-#include "Handle_SMDS_MeshEdge.hxx"
-#endif
-
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _SMDS_MeshElement_HeaderFile
 #include "SMDS_MeshElement.hxx"
-#endif
-#ifndef _Standard_Address_HeaderFile
-#include <Standard_Address.hxx>
-#endif
-#ifndef _Standard_OStream_HeaderFile
-#include <Standard_OStream.hxx>
-#endif
-
-
-class SMDS_MeshEdge : public SMDS_MeshElement {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT SMDS_MeshEdge(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2);
-Standard_EXPORT inline   void ComputeKey() ;
-Standard_EXPORT inline   Standard_Integer GetKey() const;
-Standard_EXPORT inline   Standard_Address GetConnections() const;
-Standard_EXPORT inline   Standard_Integer GetConnection(const Standard_Integer rank) const;
-Standard_EXPORT   void Print(Standard_OStream& OS) const;
-Standard_EXPORT ~SMDS_MeshEdge();
-
-
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshEdge_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
+#include <ostream>
 
-protected:
+class SMDS_MeshEdge:public SMDS_MeshElement
+{
 
- // Methods PROTECTED
- // 
+  public:
+       SMDS_MeshEdge(SMDS_MeshNode * node1, SMDS_MeshNode * node2);
+       void Print(ostream & OS) const;
 
+       SMDSAbs_ElementType GetType() const;
+       int NbNodes() const;
+       int NbEdges() const;
+       friend bool operator<(const SMDS_MeshEdge& e1, const SMDS_MeshEdge& e2);
+  protected:
+       SMDS_Iterator<const SMDS_MeshElement *> *
+               elementsIterator(SMDSAbs_ElementType type) const;
 
- // Fields PROTECTED
- //
-
-
-private: 
-
- // Methods PRIVATE
- // 
-Standard_EXPORT   void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2) ;
-
-
- // Fields PRIVATE
- //
-Standard_Integer myKey;
-Standard_Integer myNodes[2];
-
+  private:
+       SMDS_MeshNode* myNodes[2];
 
 };
-
-
-#include "SMDS_MeshEdge.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif
index 10432de..8277372 100644 (file)
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : SMDS_MeshElement.cxx
-//  Author : Jean-Michel BOULCOURT
-//  Module : SMESH
-
-using namespace std;
-#include "SMDS_MeshElement.ixx"
 
-//=======================================================================
-//function : SMDS_MeshElement
-//purpose  : 
-//=======================================================================
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshEdge.hxx"
+#include "SMDS_MeshFace.hxx"
+#include "SMDS_MeshVolume.hxx"
+#include "utilities.h"
 
-SMDS_MeshElement::SMDS_MeshElement(const Standard_Integer ID, const Standard_Integer nb,const SMDSAbs_ElementType Type) 
-  :myID(ID),myNbNodes(nb),myType(Type)
+SMDS_MeshElement::SMDS_MeshElement(int ID):myID(ID)
 {
 }
 
-//=======================================================================
-//function : GetConnections
-//purpose  : 
-//=======================================================================
-
-Standard_Address SMDS_MeshElement::GetConnections() const
+void SMDS_MeshElement::Print(ostream & OS) const
 {
-  return (Standard_Address)&myID;
+       OS << "dump of mesh element" << endl;
 }
 
-
-//=======================================================================
-//function : GetConnection
-//purpose  : 
-//=======================================================================
-
-Standard_Integer SMDS_MeshElement::GetConnection(const Standard_Integer rank) const
+ostream & operator <<(ostream & OS, const SMDS_MeshElement * ME)
 {
-  return myID;
+       ME->Print(OS);
+       return OS;
 }
 
-
-//=======================================================================
-//function : InverseElements
-//purpose  : 
-//=======================================================================
-
-const SMDS_ListOfMeshElement& SMDS_MeshElement::InverseElements() const
+///////////////////////////////////////////////////////////////////////////////
+/// Create an iterator which iterate on nodes owned by the element.
+/// This method call elementsIterator().
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshElement::nodesIterator() const
 {
-  static SMDS_ListOfMeshElement empty;
-  return empty;
+       return elementsIterator(SMDSAbs_Node);
 }
 
-//=======================================================================
-//function : ClearInverseElements
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::ClearInverseElements()
+///////////////////////////////////////////////////////////////////////////////
+/// Create an iterator which iterate on edges linked with or owned by the element.
+/// This method call elementsIterator().
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshElement::edgesIterator() const
 {
+       return elementsIterator(SMDSAbs_Edge);
 }
 
-//=======================================================================
-//function : AddInverseElement
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::AddInverseElement(const Handle(SMDS_MeshElement)& elem)
+///////////////////////////////////////////////////////////////////////////////
+/// Create an iterator which iterate on faces linked with or owned by the element.
+/// This method call elementsIterator().
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshElement::facesIterator() const
 {
+       return elementsIterator(SMDSAbs_Face);
 }
 
-//=======================================================================
-//function : NbEdges
-//purpose  : 
-//=======================================================================
-
-Standard_Integer SMDS_MeshElement::NbEdges() const
+///////////////////////////////////////////////////////////////////////////////
+///Return The number of nodes owned by the current element
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_MeshElement::NbNodes() const
 {
-  return 0;
+       int nbnodes=0;
+       SMDS_Iterator<const SMDS_MeshElement *> * it=nodesIterator();
+       while(it->more())
+       {
+               it->next();
+               nbnodes++;
+       }
+       delete it;
+       return nbnodes;
 }
 
-//=======================================================================
-//function : NbFaces
-//purpose  : 
-//=======================================================================
-
-Standard_Integer SMDS_MeshElement::NbFaces() const
+///////////////////////////////////////////////////////////////////////////////
+///Return the number of edges owned by or linked with the current element
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_MeshElement::NbEdges() const
 {
-  return 0;
+       int nbedges=0;
+       SMDS_Iterator<const SMDS_MeshElement *> * it=edgesIterator();
+       while(it->more())
+       {
+               it->next();
+               nbedges++;
+       }
+       delete it;
+       return nbedges;
 }
 
-
-//=======================================================================
-//function : GetEdgeDefinedByNodes
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::GetEdgeDefinedByNodes(const Standard_Integer rank,
-                                            Standard_Integer& idnode1,
-                                            Standard_Integer& idnode2) const
+///////////////////////////////////////////////////////////////////////////////
+///Return the number of faces owned by or linked with the current element
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_MeshElement::NbFaces() const
 {
-  idnode1 = 0;
-  idnode2 = 0;
+       int nbfaces=0;
+       SMDS_Iterator<const SMDS_MeshElement *> * it=facesIterator();
+       while(it->more())
+       {
+               it->next();
+               nbfaces++;
+       }
+       delete it;
+       return nbfaces;
 }
 
-//=======================================================================
-//function : GetFaceDefinedByNodes
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::GetFaceDefinedByNodes(const Standard_Integer rank,
-                                            const Standard_Address idnode,
-                                            Standard_Integer& nb) const
+///////////////////////////////////////////////////////////////////////////////
+///Create and iterator which iterate on elements linked with the current element.
+///The iterator must be free by the caller (call delete myIterator).
+///@param type The of elements on which you want to iterate
+///@return An iterator, that you must free when you no longer need it
+///////////////////////////////////////////////////////////////////////////////
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshElement::
+       elementsIterator(SMDSAbs_ElementType type) const
 {
-  nb = 0;
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshElement*>
+       {
+               const SMDS_MeshElement * myElement;
+               bool myMore;
+         public:
+               MyIterator(const SMDS_MeshElement * element):
+                       myElement(element),myMore(true)
+               {
+               }
+
+               bool more()
+               {
+                       return myMore;
+               }
+
+               const SMDS_MeshElement* next()
+               {
+                       myMore=false;
+                       return myElement;       
+               }       
+       };
+       
+       if(type==GetType()) return new MyIterator(this);
+       else 
+       {
+               MESSAGE("Iterator not implemented");            
+               return NULL;
+       }
 }
 
-//=======================================================================
-//function : SetNormal
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::SetNormal(const Standard_Integer rank,
-                                const Standard_Real vx,
-                                const Standard_Real vy,
-                                const Standard_Real vz)
-
-{
-  if (myNormals.IsNull()) {
-    myNormals = new TColgp_HArray1OfDir(1,NbNodes());
-  }
-  myNormals->SetValue(rank, gp_Dir(vx,vy,vz));
-}
-
-//=======================================================================
-//function : SetNormal
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::SetNormal(const Standard_Integer rank,
-                                const gp_Vec& V)
+///////////////////////////////////////////////////////////////////////////////
+///Return the ID of the element
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_MeshElement::GetID() const
 {
-  if (myNormals.IsNull()) {
-    myNormals = new TColgp_HArray1OfDir(1,NbNodes());
-  }
-  myNormals->SetValue(rank, gp_Dir(V));
+       return myID;
 }
 
-//=======================================================================
-//function : GetNormal
-//purpose  : 
-//=======================================================================
-
-gp_Dir SMDS_MeshElement::GetNormal(const Standard_Integer rank) 
-{
-  if (myNormals.IsNull()) {
-    myNormals = new TColgp_HArray1OfDir(1,NbNodes());
-  }
-  return myNormals->Value(rank);
-}
-
-//=======================================================================
-//function : Print
-//purpose  : 
-//=======================================================================
-
-void SMDS_MeshElement::Print(Standard_OStream& OS) const
-{
-  OS << "dump of mesh element" << endl;
-}
-
-
-Standard_OStream& operator << (Standard_OStream& OS
-                             ,const Handle(SMDS_MeshElement)& ME) 
+bool operator<(const SMDS_MeshElement& e1, const SMDS_MeshElement& e2)
 {
-  ME->Print(OS);
-  return OS;
+       if(e1.GetType()!=e2.GetType()) return false;
+       switch(e1.GetType())
+       {
+       case SMDSAbs_Node:
+               return static_cast<const SMDS_MeshNode &>(e1) <
+                       static_cast<const SMDS_MeshNode &>(e2);
+
+       case SMDSAbs_Edge:
+               return static_cast<const SMDS_MeshEdge &>(e1) <
+                       static_cast<const SMDS_MeshEdge &>(e2);
+
+       case SMDSAbs_Face:
+               return static_cast<const SMDS_MeshFace &>(e1) <
+                       static_cast<const SMDS_MeshFace &>(e2);
+
+       case SMDSAbs_Volume:
+               return static_cast<const SMDS_MeshVolume &>(e1) <
+                       static_cast<const SMDS_MeshVolume &>(e2);
+
+       default : MESSAGE("Internal Error");
+       }
 }
index 0bd0d40..d35e151 100644 (file)
 
 #ifndef _SMDS_MeshElement_HeaderFile
 #define _SMDS_MeshElement_HeaderFile
-
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshElement_HeaderFile
-#include "Handle_SMDS_MeshElement.hxx"
-#endif
-
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _SMDSAbs_ElementType_HeaderFile                                                                           
+       
 #include "SMDSAbs_ElementType.hxx"
-#endif
-#ifndef _Handle_TColgp_HArray1OfDir_HeaderFile
-#include "Handle_TColgp_HArray1OfDir.hxx"
-#endif
-#ifndef _SMDS_MeshObject_HeaderFile
 #include "SMDS_MeshObject.hxx"
-#endif
-#ifndef _Standard_Boolean_HeaderFile
-#include <Standard_Boolean.hxx>
-#endif
-#ifndef _Standard_Address_HeaderFile
-#include <Standard_Address.hxx>
-#endif
-#ifndef _Standard_Real_HeaderFile
-#include <Standard_Real.hxx>
-#endif
-#ifndef _Standard_OStream_HeaderFile
-#include <Standard_OStream.hxx>
-#endif
-class TColgp_HArray1OfDir;
-class Standard_OutOfRange;
-class SMDS_ListOfMeshElement;
-class gp_Vec;
-class gp_Dir;
-
-
-class SMDS_MeshElement : public SMDS_MeshObject {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT inline   Standard_Integer HashCode(const Standard_Integer Upper) const;
-Standard_EXPORT inline   Standard_Boolean IsSame(const Handle(SMDS_MeshElement)& other) const;
-Standard_EXPORT inline   Standard_Boolean IsEqual(const Handle(SMDS_MeshElement)& other) const;
-Standard_EXPORT inline   Standard_Boolean IsNodeInElement(const Standard_Integer idnode) const;
-Standard_EXPORT virtual  void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const;
-Standard_EXPORT virtual  void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const;
-Standard_EXPORT virtual  Standard_Integer GetConnection(const Standard_Integer rank) const;
-Standard_EXPORT virtual  void AddInverseElement(const Handle(SMDS_MeshElement)& ME) ;
-Standard_EXPORT virtual const SMDS_ListOfMeshElement& InverseElements() const;
-Standard_EXPORT virtual  void ClearInverseElements() ;
-Standard_EXPORT inline   Standard_Integer NbNodes() const;
-Standard_EXPORT virtual  Standard_Integer NbEdges() const;
-Standard_EXPORT virtual  Standard_Integer NbFaces() const;
-Standard_EXPORT inline   Standard_Integer GetID() const;
-Standard_EXPORT virtual  Standard_Integer GetKey() const = 0;
-Standard_EXPORT virtual  void SetNormal(const Standard_Integer rank,const Standard_Real vx,const Standard_Real vy,const Standard_Real vz) ;
-Standard_EXPORT virtual  void SetNormal(const Standard_Integer rank,const gp_Vec& v) ;
-Standard_EXPORT virtual  gp_Dir GetNormal(const Standard_Integer rank) ;
-Standard_EXPORT virtual  void Print(Standard_OStream& OS) const;
-friend Standard_EXPORT Standard_OStream& operator << (Standard_OStream& OS, const Handle(SMDS_MeshElement)& );
-Standard_EXPORT inline   SMDSAbs_ElementType GetType() const;
-Standard_EXPORT ~SMDS_MeshElement();
-
-
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshElement_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
-
-protected:
-
- // Methods PROTECTED
- // 
-Standard_EXPORT SMDS_MeshElement(const Standard_Integer ID,const Standard_Integer NbConnections,const SMDSAbs_ElementType Type);
-Standard_EXPORT virtual  Standard_Address GetConnections() const;
-
-
- // Fields PROTECTED
- //
-Standard_Integer myID;
-Standard_Integer myNbNodes;
-Handle_TColgp_HArray1OfDir myNormals;
-
-
-private: 
-
- // Methods PRIVATE
- // 
-
-
- // Fields PRIVATE
- //
-SMDSAbs_ElementType myType;
-
-
+#include "SMDS_Iterator.hxx"
+#include "SMDS_MeshElementIDFactory.hxx"
+
+#include <vector>
+#include <ostream>
+
+using namespace std;
+class SMDS_MeshNode;
+class SMDS_MeshEdge;
+class SMDS_MeshFace;   
+
+///////////////////////////////////////////////////////////////////////////////
+/// Base class for elements
+///////////////////////////////////////////////////////////////////////////////
+class SMDS_MeshElement:public SMDS_MeshObject
+{
+
+  public:
+       SMDS_Iterator<const SMDS_MeshElement *> * nodesIterator() const;
+       SMDS_Iterator<const SMDS_MeshElement *> * edgesIterator() const;
+       SMDS_Iterator<const SMDS_MeshElement *> * facesIterator() const;
+       virtual SMDS_Iterator<const SMDS_MeshElement *> *
+               elementsIterator(SMDSAbs_ElementType type) const;
+
+       virtual int NbNodes() const;
+       virtual int NbEdges() const;
+       virtual int NbFaces() const;
+       int GetID() const;
+
+       ///Return the type of the current element
+       virtual SMDSAbs_ElementType GetType() const = 0;
+       friend ostream & operator <<(ostream & OS, const SMDS_MeshElement *);
+       friend bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement*elem);
+
+  protected:
+       SMDS_MeshElement(int ID=-1);
+       virtual void Print(ostream & OS) const;
+       
+  private:
+       int myID;
 };
 
-
-#include "SMDS_MeshElement.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif
index 7441cc5..b701429 100644 (file)
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : SMDS_MeshFace.cxx
-//  Author : Jean-Michel BOULCOURT
-//  Module : SMESH
-
-using namespace std;
-#include "SMDS_MeshFace.ixx"
-
-
-//=======================================================================
-//function : SMDS_MeshFace
-//purpose  : 
-//=======================================================================
-
-SMDS_MeshFace::SMDS_MeshFace(const Standard_Integer ID, const Standard_Integer nb) 
-:SMDS_MeshElement(ID,nb,SMDSAbs_Face)
-{
-}
-
-
-//=======================================================================
-//function : NbEdges
-//purpose  : 
-//=======================================================================
-
-Standard_Integer SMDS_MeshFace::NbEdges() const
-{
-  return myNbNodes;
-}
 
-//=======================================================================
-//function : Print
-//purpose  : 
-//=======================================================================
+#include "SMDS_MeshFace.hxx"
 
-void SMDS_MeshFace::Print(Standard_OStream& OS) const
+SMDSAbs_ElementType SMDS_MeshFace::GetType() const
 {
-  OS << "face <" << myID <<" > : ";
-  for (Standard_Integer i=1; i<myNbNodes; ++i)
-    OS << GetConnection(i) << ",";
-  OS << GetConnection(myNbNodes) << ") " << endl;
+       return SMDSAbs_Face;
 }
-
-
index 5d218f9..36f2fa5 100644 (file)
 #ifndef _SMDS_MeshFace_HeaderFile
 #define _SMDS_MeshFace_HeaderFile
 
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshFace_HeaderFile
-#include "Handle_SMDS_MeshFace.hxx"
-#endif
-
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _SMDS_MeshElement_HeaderFile
 #include "SMDS_MeshElement.hxx"
-#endif
-#ifndef _Standard_OStream_HeaderFile
-#include <Standard_OStream.hxx>
-#endif
-
-
-class SMDS_MeshFace : public SMDS_MeshElement {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT virtual  void ComputeKey()  = 0;
-Standard_EXPORT inline   Standard_Integer GetKey() const;
-Standard_EXPORT virtual  Standard_Integer NbEdges() const;
-Standard_EXPORT virtual  void Print(Standard_OStream& OS) const;
-Standard_EXPORT ~SMDS_MeshFace();
-
-
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshFace_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
-
-protected:
-
- // Methods PROTECTED
- // 
-Standard_EXPORT SMDS_MeshFace(const Standard_Integer ID,const Standard_Integer NbConnections);
-
-
- // Fields PROTECTED
- //
-Standard_Integer myKey;
-
-
-private: 
-
- // Methods PRIVATE
- // 
-
-
- // Fields PRIVATE
- //
-
 
+class SMDS_MeshFace:public SMDS_MeshElement
+{
+  public:
+       SMDSAbs_ElementType GetType() const;
 };
 
-
-#include "SMDS_MeshFace.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif
index 6a95560..271d53f 100644 (file)
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
 // 
 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
-//
-//
-//
-//  File   : SMDS_MeshNode.cxx
-//  Author : Jean-Michel BOULCOURT
-//  Module : SMESH
 
-using namespace std;
-#include "SMDS_MeshNode.ixx"
-#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
-#include "SMDS_SpacePosition.hxx"
 
-static Handle(SMDS_Position)& StaticInstancePosition()
-{
-  static Handle(SMDS_SpacePosition) staticpos;
-  if (staticpos.IsNull())
-    staticpos = new SMDS_SpacePosition();
-
-  return staticpos;
-}
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_SpacePosition.hxx"
+#include "SMDS_IteratorOfElements.hxx"
 
 //=======================================================================
 //function : SMDS_MeshNode
 //purpose  : 
 //=======================================================================
 
-SMDS_MeshNode::SMDS_MeshNode(const Standard_Integer ID,
-                            const Standard_Real x, const Standard_Real y, const Standard_Real z) :
-  SMDS_MeshElement(ID,1,SMDSAbs_Node),myPnt(x,y,z),myPosition(StaticInstancePosition())
+SMDS_MeshNode::SMDS_MeshNode(double x, double y, double z):
+       myX(x), myY(y), myZ(z),
+       myPosition(SMDS_SpacePosition::originSpacePosition())
 {
 }
 
-
 //=======================================================================
 //function : RemoveInverseElement
 //purpose  : 
 //=======================================================================
 
-void SMDS_MeshNode::RemoveInverseElement(const Handle(SMDS_MeshElement)& parent)
+void SMDS_MeshNode::RemoveInverseElement(const SMDS_MeshElement * parent)
 {
-
-  SMDS_ListIteratorOfListOfMeshElement itLstInvCnx(myInverseElements);
-
-  for (;itLstInvCnx.More();itLstInvCnx.Next()) {
-    Handle(SMDS_MeshElement)& ME = itLstInvCnx.Value();
-    if (ME->IsSame(parent))
-      myInverseElements.Remove(itLstInvCnx);
-    if (!itLstInvCnx.More())
-      break;
-  }
+       myInverseElements.erase(parent);
 }
 
-
 //=======================================================================
 //function : Print
 //purpose  : 
 //=======================================================================
 
-void SMDS_MeshNode::Print(Standard_OStream& OS) const
+void SMDS_MeshNode::Print(ostream & OS) const
 {
-  OS << "Node <" << myID << "> : X = " << myPnt.X() << " Y = " << myPnt.Y() << " Z = " << myPnt.Z() << endl;
+       OS << "Node <" << GetID() << "> : X = " << myX << " Y = "
+               << myY << " Z = " << myZ << endl;
 }
 
-
 //=======================================================================
 //function : SetPosition
 //purpose  : 
 //=======================================================================
 
-void SMDS_MeshNode::SetPosition(const Handle(SMDS_Position)& aPos)
+void SMDS_MeshNode::SetPosition(SMDS_Position * aPos)
 {
-  myPosition = aPos;
+       myPosition = aPos;
 }
 
 //=======================================================================
@@ -97,8 +71,164 @@ void SMDS_MeshNode::SetPosition(const Handle(SMDS_Position)& aPos)
 //purpose  : 
 //=======================================================================
 
-Handle(SMDS_Position) SMDS_MeshNode::GetPosition() const
+SMDS_Position *SMDS_MeshNode::GetPosition()
+{
+       return myPosition;
+}
+
+const SMDS_Position *SMDS_MeshNode::GetPosition() const
+{
+       return myPosition;
+}
+/**
+*/
+SMDS_Iterator<const SMDS_MeshElement*> * SMDS_MeshNode::
+       GetInverseElementIterator() const
+{
+       class SMDS_InverseElementIterator:public SMDS_Iterator<const SMDS_MeshElement*>
+       {
+               const set<const SMDS_MeshElement*>& mySet;
+               set<const SMDS_MeshElement*>::iterator myIterator;
+         public:
+               SMDS_InverseElementIterator(const set<const SMDS_MeshElement*>& s):mySet(s)
+               {
+                       myIterator=mySet.begin();
+               }
+
+               bool more()
+               {
+                       myIterator!=mySet.end();
+               }
+
+               const SMDS_MeshElement* next()
+               {
+                       const SMDS_MeshElement* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+       return new SMDS_InverseElementIterator(myInverseElements);
+}
+
+SMDS_Iterator<const SMDS_MeshElement *> * SMDS_MeshNode::
+       elementsIterator(SMDSAbs_ElementType type) const
+{
+       // Same as GetInverseElementIterator but the create iterator only return
+       // wanted type elements.
+       class MyIterator:public SMDS_Iterator<const SMDS_MeshElement*>
+       {
+               set<const SMDS_MeshElement*> mySet;
+               set<const SMDS_MeshElement*>::iterator myIterator;
+         public:
+               MyIterator(SMDSAbs_ElementType type,
+                       const set<const SMDS_MeshElement*>& s) 
+               {
+                       const SMDS_MeshElement * e;
+                       bool toInsert;
+                       set<const SMDS_MeshElement*>::iterator it=s.begin();
+                       while(it!=s.end())
+                       {
+                               e=*it;
+                               switch(type)
+                               {
+                               case SMDSAbs_Edge: toInsert=true; break;
+                               case SMDSAbs_Face: toInsert=(e->GetType()!=SMDSAbs_Edge); break;
+                               case SMDSAbs_Volume: toInsert=(e->GetType()==SMDSAbs_Volume); break;
+                               }
+                               if(toInsert) mySet.insert(e);
+                               it++;
+                       }       
+                       myIterator=mySet.begin();
+               }
+
+               bool more()
+               {
+                       myIterator!=mySet.end();
+               }
+
+               const SMDS_MeshElement* next()
+               {
+                       const SMDS_MeshElement* current=*myIterator;
+                       myIterator++;
+                       return current; 
+               }       
+       };
+
+       if(type==SMDSAbs_Node)
+               return SMDS_MeshElement::elementsIterator(SMDSAbs_Node); 
+       else
+               return new SMDS_IteratorOfElements(this,type,
+                       new MyIterator(type, myInverseElements));
+}
+
+int SMDS_MeshNode::NbNodes() const
+{
+       return 1;
+}
+
+double SMDS_MeshNode::X() const
+{
+       return myX;
+}
+
+double SMDS_MeshNode::Y() const
+{
+       return myY;
+}
+
+double SMDS_MeshNode::Z() const
+{
+       return myZ;
+}
+
+void SMDS_MeshNode::setXYZ(double x, double y, double z)
+{
+       myX=x;
+       myY=y;
+       myZ=z;  
+}
+
+SMDSAbs_ElementType SMDS_MeshNode::GetType() const
+{
+       return SMDSAbs_Node;
+}
+
+//=======================================================================
+//function : AddInverseElement
+//purpose  :
+//=======================================================================
+void SMDS_MeshNode::AddInverseElement(const SMDS_MeshElement* ME)
+{
+       myInverseElements.insert(ME);
+}
+
+//=======================================================================
+//function : ClearInverseElements
+//purpose  :
+//=======================================================================
+void SMDS_MeshNode::ClearInverseElements()
+{
+       myInverseElements.clear();
+}
+
+bool SMDS_MeshNode::emptyInverseElements()
+{
+       return myInverseElements.empty();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// To be used with STL set
+///////////////////////////////////////////////////////////////////////////////
+bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2)
 {
-  return myPosition;
+       return e1.GetID()<e2.GetID();
+       /*if(e1.myX<e2.myX) return true;
+       else if(e1.myX==e2.myX)
+       {
+               if(e1.myY<e2.myY) return true;
+               else if(e1.myY==e2.myY) return (e1.myZ<e2.myZ);
+               else return false;
+       }
+       else return false;*/
 }
 
index 9ef605e..f536307 100644 (file)
 #ifndef _SMDS_MeshNode_HeaderFile
 #define _SMDS_MeshNode_HeaderFile
 
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshNode_HeaderFile
-#include "Handle_SMDS_MeshNode.hxx"
-#endif
-
-#ifndef _gp_Pnt_HeaderFile
-#include <gp_Pnt.hxx>
-#endif
-#ifndef _SMDS_ListOfMeshElement_HeaderFile
-#include "SMDS_ListOfMeshElement.hxx"
-#endif
-#ifndef _Handle_SMDS_Position_HeaderFile
-#include "Handle_SMDS_Position.hxx"
-#endif
-#ifndef _SMDS_MeshElement_HeaderFile
 #include "SMDS_MeshElement.hxx"
-#endif
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _Standard_Real_HeaderFile
-#include <Standard_Real.hxx>
-#endif
-#ifndef _Standard_OStream_HeaderFile
-#include <Standard_OStream.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshElement_HeaderFile
-#include "Handle_SMDS_MeshElement.hxx"
-#endif
-class SMDS_Position;
-class gp_Pnt;
-class SMDS_MeshElement;
-class SMDS_ListOfMeshElement;
-
-
-class SMDS_MeshNode : public SMDS_MeshElement {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT SMDS_MeshNode(const Standard_Integer ID,const Standard_Real x,const Standard_Real y,const Standard_Real z);
-Standard_EXPORT   void Print(Standard_OStream& OS) const;
-Standard_EXPORT inline   Standard_Integer GetKey() const;
-Standard_EXPORT inline   Standard_Real X() const;
-Standard_EXPORT inline   Standard_Real Y() const;
-Standard_EXPORT inline   Standard_Real Z() const;
-Standard_EXPORT inline   gp_Pnt Pnt() const;
-Standard_EXPORT inline   void SetPnt(const gp_Pnt& P) ;
-Standard_EXPORT inline   void AddInverseElement(const Handle(SMDS_MeshElement)& ME) ;
-Standard_EXPORT   void RemoveInverseElement(const Handle(SMDS_MeshElement)& parent) ;
-Standard_EXPORT inline  const SMDS_ListOfMeshElement& InverseElements() const;
-Standard_EXPORT inline   void ClearInverseElements() ;
-Standard_EXPORT   void SetPosition(const Handle(SMDS_Position)& aPos) ;
-Standard_EXPORT   Handle_SMDS_Position GetPosition() const;
-Standard_EXPORT ~SMDS_MeshNode();
-
-
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshNode_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
-
-protected:
-
- // Methods PROTECTED
- // 
-
-
- // Fields PROTECTED
- //
-
-
-private: 
-
- // Methods PRIVATE
- // 
-
-
- // Fields PRIVATE
- //
-gp_Pnt myPnt;
-SMDS_ListOfMeshElement myInverseElements;
-Handle_SMDS_Position myPosition;
-
-
+#include "SMDS_Position.hxx"
+
+#include <set>
+using namespace std;
+
+class SMDS_MeshNode:public SMDS_MeshElement
+{
+
+  public:
+       SMDS_MeshNode(double x, double y, double z);
+       void Print(ostream & OS) const;
+       double X() const;
+       double Y() const;
+       double Z() const;
+       void AddInverseElement(const SMDS_MeshElement * ME);
+       void RemoveInverseElement(const SMDS_MeshElement * parent);
+       void ClearInverseElements();
+       bool emptyInverseElements();
+       SMDS_Iterator<const SMDS_MeshElement*> * GetInverseElementIterator() const;     
+       void SetPosition(SMDS_Position * aPos);
+       SMDS_Position *GetPosition();
+       const SMDS_Position *GetPosition() const;
+       SMDSAbs_ElementType GetType() const;
+       int NbNodes() const;
+       void setXYZ(double x, double y, double z);
+       friend bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2);
+
+  protected:
+       SMDS_Iterator<const SMDS_MeshElement *> *
+               elementsIterator(SMDSAbs_ElementType type) const;
+
+  private:
+       double myX, myY, myZ;
+       SMDS_Position *myPosition;
+       set<const SMDS_MeshElement*> myInverseElements;
 };
 
-
-#include "SMDS_MeshNode.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif
index 20e40f3..561f0dc 100644 (file)
 //  Author : Jean-Michel BOULCOURT
 //  Module : SMESH
 
-using namespace std;
-#include "SMDS_MeshVolume.ixx"
-#include <Standard_ConstructionError.hxx>
-
-//=======================================================================
-//function : SMDS_MeshVolume
-//purpose  : 
-//=======================================================================
-
-SMDS_MeshVolume::SMDS_MeshVolume(const Standard_Integer ID, const Standard_Integer nb) 
-:SMDS_MeshElement(ID,nb,SMDSAbs_Volume)
-{
-}
-
+#include "SMDS_MeshVolume.hxx"
 //=======================================================================
 //function : Print
 //purpose  : 
 //=======================================================================
 
-void SMDS_MeshVolume::Print(Standard_OStream& OS) const
+SMDSAbs_ElementType SMDS_MeshVolume::GetType() const
 {
-  OS << "volume <" << myID <<"> : " ;
-  for (Standard_Integer i=1; i<myNbNodes; ++i)
-    OS << GetConnection(i) << ",";
-  OS << GetConnection(myNbNodes) << ") " << endl;
+       return SMDSAbs_Volume;
 }
 
-
index 5b6496b..c543c30 100644 (file)
 #ifndef _SMDS_MeshVolume_HeaderFile
 #define _SMDS_MeshVolume_HeaderFile
 
-#ifndef _Standard_HeaderFile
-#include <Standard.hxx>
-#endif
-#ifndef _Handle_SMDS_MeshVolume_HeaderFile
-#include "Handle_SMDS_MeshVolume.hxx"
-#endif
-
-#ifndef _Standard_Integer_HeaderFile
-#include <Standard_Integer.hxx>
-#endif
-#ifndef _SMDS_MeshElement_HeaderFile
 #include "SMDS_MeshElement.hxx"
-#endif
-#ifndef _Standard_OStream_HeaderFile
-#include <Standard_OStream.hxx>
-#endif
-class Standard_ConstructionError;
-
-
-class SMDS_MeshVolume : public SMDS_MeshElement {
-
-public:
-
-    inline void* operator new(size_t,void* anAddress) 
-      {
-        return anAddress;
-      }
-    inline void* operator new(size_t size) 
-      { 
-        return Standard::Allocate(size); 
-      }
-    inline void  operator delete(void *anAddress) 
-      { 
-        if (anAddress) Standard::Free((Standard_Address&)anAddress); 
-      }
-//    inline void  operator delete(void *anAddress, size_t size) 
-//      { 
-//        if (anAddress) Standard::Free((Standard_Address&)anAddress,size); 
-//      }
- // Methods PUBLIC
- // 
-Standard_EXPORT virtual  void ComputeKey()  = 0;
-Standard_EXPORT inline   Standard_Integer GetKey() const;
-Standard_EXPORT virtual  void Print(Standard_OStream& OS) const;
-Standard_EXPORT ~SMDS_MeshVolume();
-
-
-
-
- // Type management
- //
- Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshVolume_Type_();
- Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
- Standard_EXPORT Standard_Boolean             IsKind(const Handle(Standard_Type)&) const;
-
-protected:
-
- // Methods PROTECTED
- // 
-Standard_EXPORT SMDS_MeshVolume(const Standard_Integer ID,const Standard_Integer NbConnections);
-
-
- // Fields PROTECTED
- //
-Standard_Integer myKey;
-
-
-private: 
-
- // Methods PRIVATE
- // 
-
-
- // Fields PRIVATE
- //
-
 
+class SMDS_MeshVolume:public SMDS_MeshElement
+{
+       
+  public:
+       SMDSAbs_ElementType GetType() const;
 };
-
-
-#include "SMDS_MeshVolume.lxx"
-
-
-
-// other inline functions and methods (like "C++: function call" methods)
-//
-
-
 #endif