SMESHDS_Mesh structures

[modules/smesh.git] / src / SMESHDS / SMESHDS_SubMesh.cxx

diff --git a/src/SMESHDS/SMESHDS_SubMesh.cxx b/src/SMESHDS/SMESHDS_SubMesh.cxx
index 127c5c2d99ccd100786b66dd0e3c858ab40f4574..d8c4d1eaee0d2c88bb02e6f8482bd96819250fe5 100644 (file)
--- a/src/SMESHDS/SMESHDS_SubMesh.cxx
+++ b/src/SMESHDS/SMESHDS_SubMesh.cxx
@@ -29,9 +29,19 @@
 
 #include "utilities.h"
 #include "SMDS_SetIterator.hxx"
+#include <iostream>
+#include <cassert>
 
 using namespace std;
 
+SMESHDS_SubMesh::SMESHDS_SubMesh()
+{
+  myElements.clear();
+  myNodes.clear();
+  myUnusedIdNodes = 0;
+  myUnusedIdElements = 0;
+}
+
 //=======================================================================
 //function : AddElement
 //purpose  : 
@@ -39,17 +49,42 @@ using namespace std;
 void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
 {
   if ( !IsComplexSubmesh() )
-    myElements.insert(ME);
+    {
+      int idInSubShape = ME->getIdInShape();
+      assert(idInSubShape == -1);
+      SMDS_MeshElement* elem = (SMDS_MeshElement*)(ME);
+      elem->setIdInShape(myElements.size());
+      myElements.push_back(ME);
+    }
 }
 
 //=======================================================================
 //function : RemoveElement
 //purpose  : 
 //=======================================================================
-bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME)
+bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted)
 {
-  if ( !IsComplexSubmesh() && NbElements() )
-    return myElements.erase(ME);
+//  if ( !IsComplexSubmesh() && NbElements() ) {
+
+    if (!isElemDeleted) // alive element has valid ID and can be found
+      {
+        int idInSubShape = ME->getIdInShape();
+        assert(idInSubShape >= 0);
+        assert(idInSubShape < myElements.size());
+        myElements[idInSubShape] = 0; // this vector entry is no more used
+        myUnusedIdElements++;
+        return true;
+      }
+
+    
+// --- strange ?
+//     TElemSet::iterator e = myElements.begin(), eEnd = myElements.end();
+//     for ( ; e != eEnd; ++e )
+//       if ( ME == *e ) {
+//         myElements.erase( e );
+//         return true;
+//       }
+//   }
   
   return false;
 }
@@ -61,7 +96,13 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME)
 void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
 {
   if ( !IsComplexSubmesh() )
-    myNodes.insert(N);
+    {
+      int idInSubShape = N->getIdInShape();
+      assert(idInSubShape == -1);
+      SMDS_MeshNode* node = (SMDS_MeshNode*)(N);
+      node->setIdInShape(myNodes.size());
+      myNodes.push_back(N);
+    }
 }
 
 //=======================================================================
@@ -69,10 +110,28 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
 //purpose  : 
 //=======================================================================
 
-bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N)
+bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
 {
-  if ( !IsComplexSubmesh() && NbNodes() )
-    return myNodes.erase(N);
+//   if ( !IsComplexSubmesh() && NbNodes() ) {
+
+    if (!isNodeDeleted) // alive node has valid ID and can be found
+      {
+        int idInSubShape = N->getIdInShape();
+        assert(idInSubShape >= 0);
+        assert(idInSubShape < myNodes.size());
+        myNodes[idInSubShape] = 0; // this vector entry is no more used
+        myUnusedIdNodes++;
+        return true;
+      }
+
+// --- strange ?
+//     TElemSet::iterator e = myNodes.begin(), eEnd = myNodes.end();
+//     for ( ; e != eEnd; ++e )
+//       if ( N == *e ) {
+//         myNodes.erase( e );
+//         return true;
+//       }
+//   }
 
   return false;
 }
@@ -84,14 +143,10 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N)
 int SMESHDS_SubMesh::NbElements() const
 {
   if ( !IsComplexSubmesh() )
-    return myElements.size();
+    return myElements.size() - myUnusedIdElements;
 
   int nbElems = 0;
-#ifndef WNT
-  set<const SMESHDS_SubMesh*>::iterator it = mySubMeshes.begin();
-#else
   set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin();
-#endif
   for ( ; it != mySubMeshes.end(); it++ )
     nbElems += (*it)->NbElements();
 
@@ -106,14 +161,10 @@ int SMESHDS_SubMesh::NbElements() const
 int SMESHDS_SubMesh::NbNodes() const
 {
  if ( !IsComplexSubmesh() )
-   return myNodes.size(); 
+   return myNodes.size() - myUnusedIdNodes;
 
   int nbElems = 0;
-#ifndef WNT
-  set<const SMESHDS_SubMesh*>::iterator it = mySubMeshes.begin();
-#else
   set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin();
-#endif
   for ( ; it != mySubMeshes.end(); it++ )
     nbElems += (*it)->NbNodes();
 
@@ -124,26 +175,13 @@ int SMESHDS_SubMesh::NbNodes() const
 // class MySetIterator
 // =====================
 
-template<typename T> class MySetIterator:public SMDS_Iterator<const T*>
+template<class ELEM, typename TSET> class MySetIterator:
+  public SMDS_SetIterator<ELEM, typename TSET::const_iterator >
 {
-  typedef const set<const T*> TSet;
-  typename TSet::const_iterator myIt;
-  TSet& mySet;
-
+  typedef SMDS_SetIterator<ELEM, typename TSET::const_iterator > TFather;
   public:
-       MySetIterator(const set<const T*>& s):mySet(s), myIt(s.begin())
-       {
-       }
-
-       bool more()
-       {
-               return myIt!=mySet.end();
-       }
-       const T* next()
+       MySetIterator(const TSET& s):TFather(s.begin(),s.end())
        {
-               const T* t=*myIt;
-               myIt++;
-               return t;                       
        }
 };
 
@@ -155,12 +193,11 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 {
  public:
   MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
-    : mySubMeshes( theSubMeshes ), mySubIt( theSubMeshes.begin() ), myMore(false)
+    : mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() ), myMore(false)
     {}
   bool more()
   {
-    while (( !myElemIt.get() || !myElemIt->more() ) &&
-           mySubIt != mySubMeshes.end())
+    while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
     {
       myElemIt = getElements(*mySubIt);
       mySubIt++;
@@ -181,8 +218,7 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 
  private:
   bool                                        myMore;
-  const set<const SMESHDS_SubMesh*>&          mySubMeshes;
-  set<const SMESHDS_SubMesh*>::const_iterator mySubIt;
+  set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
   boost::shared_ptr< SMDS_Iterator<VALUE> >   myElemIt;
 };
 
@@ -222,7 +258,7 @@ SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const
   if ( IsComplexSubmesh() )
     return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
 
-  return SMDS_ElemIteratorPtr(new MySetIterator<SMDS_MeshElement>(myElements));
+  return SMDS_ElemIteratorPtr(new MySetIterator<const SMDS_MeshElement*,TElemSet>(myElements));
 }
 
 //=======================================================================
@@ -235,7 +271,7 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
   if ( IsComplexSubmesh() )
     return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
 
-  return SMDS_NodeIteratorPtr(new MySetIterator<SMDS_MeshNode>(myNodes));
+  return SMDS_NodeIteratorPtr(new MySetIterator<const SMDS_MeshNode*,TElemSet>(myNodes));
 }
 
 //=======================================================================
@@ -246,7 +282,8 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
 bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
 {
   // DO NOT TRY TO FIND A REMOVED ELEMENT !!
-  if ( !ME )
+  //if ( IsComplexSubmesh() || !ME )
+  if (!ME )
     return false;
 
   if ( IsComplexSubmesh() )
@@ -259,12 +296,18 @@ bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
   }
 
   if ( ME->GetType() == SMDSAbs_Node )
-  {
-    const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( ME );
-    return ( myNodes.find( n ) != myNodes.end() );
-  }
-
-  return ( myElements.find( ME ) != myElements.end() );
+    {
+      int idInShape = ME->getIdInShape();
+      if ((idInShape >= 0) && (idInShape < myNodes.size()))
+       if (myNodes[idInShape] == ME) return true;
+    }
+  else
+    {
+      int idInShape = ME->getIdInShape();
+      if ((idInShape >= 0) && (idInShape < myElements.size()))
+       if (myElements[idInShape] == ME) return true;
+    }
+    return false;
 }
 
 //=======================================================================
@@ -326,3 +369,13 @@ void SMESHDS_SubMesh::Clear()
       sm->Clear();
   }
 }
+
+int SMESHDS_SubMesh::getSize()
+{
+  int c = NbNodes();
+  int d = NbElements();
+  cerr << "SMESHDS_SubMesh::NbNodes " << c << endl;
+  cerr << "SMESHDS_SubMesh::NbElements " << d << endl;
+  return c+d;
+}
+