X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESHDS%2FSMESHDS_SubMesh.cxx;h=89287301641073332320037784571d4cf499aa12;hb=e613ea2b8d537a9d7e94fda51e290cb9225e935b;hp=04a0021fc0fc2ef501ec1209d7c075c485fe3e8f;hpb=7084b4f9799cf4a0145ba86ab8b653de8f2d2bdb;p=modules%2Fsmesh.git

diff --git a/src/SMESHDS/SMESHDS_SubMesh.cxx b/src/SMESHDS/SMESHDS_SubMesh.cxx
index 04a0021fc..892873016 100644
--- a/src/SMESHDS/SMESHDS_SubMesh.cxx
+++ b/src/SMESHDS/SMESHDS_SubMesh.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2015  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -89,7 +89,7 @@ void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
         MESSAGE("add element in subshape already belonging to that subshape "
                 << ME->GetID() << " " << oldShapeId << " " << idInSubShape);
         // check if ok: do nothing if ok
-        if (idInSubShape >= myElements.size())
+        if (idInSubShape >= (int)myElements.size())
         {
           throw SALOME_Exception(LOCALIZED("out of bounds"));
         }
@@ -117,18 +117,27 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDele
 {
   if (!ME)
   {
-    MESSAGE("-----------------> Remove Null Element " << isElemDeleted);
     return false;
   }
   if (!IsComplexSubmesh())
   {
-    if ( ME->getshapeId() != myIndex )
+    if ( ME->getshapeId() != myIndex ) // elem not in a pool can loose it's data already
+    {
+      if ( isElemDeleted )
+        for ( size_t i = 0; i < myElements.size(); ++i )
+          if ( myElements[i] == ME )
+          {
+            myElements[i] = 0;
+            ++myUnusedIdElements;
+            return true;
+          }
       return false;
+    }
     int idInSubShape = ME->getIdInShape();
     SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
     elem->setShapeId(0);
     elem->setIdInShape(-1);
-    if ((idInSubShape >= 0) && (idInSubShape < myElements.size()))
+    if ((idInSubShape >= 0) && (idInSubShape < (int) myElements.size()))
     {
       myElements[idInSubShape] = 0; // this vector entry is no more used
       if ( ++myUnusedIdElements == (int) myElements.size() )
@@ -140,13 +149,12 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDele
     }
     return false;
   }
-  MESSAGE("Try to remove an element from a complex submesh ");
   return false;
 }
 
 //=======================================================================
 //function : AddNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
@@ -160,7 +168,7 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
       if ( shapeId != myIndex )
         throw SALOME_Exception
           (LOCALIZED("a node being in sub-mesh is added to another sub-mesh"));
-      if ( idInSubShape >= myNodes.size() || myNodes[ idInSubShape ] != N )
+      if ( idInSubShape >= (int)myNodes.size() || myNodes[ idInSubShape ] != N )
         throw SALOME_Exception
           (LOCALIZED("a node with wrong idInSubShape is re-added to the same sub-mesh"));
       return; // already in
@@ -182,12 +190,22 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
   if (!IsComplexSubmesh())
   {
     if ( N->getshapeId() != myIndex )
+    {
+      if ( isNodeDeleted )
+        for ( size_t i = 0; i < myNodes.size(); ++i )
+          if ( myNodes[i] == N )
+          {
+            myNodes[i] = 0;
+            ++myUnusedIdNodes;
+            return true;
+          }
       return false;
+    }
     int idInSubShape = N->getIdInShape();
     SMDS_MeshNode* node = (SMDS_MeshNode*) (N);
     node->setShapeId(0);
     node->setIdInShape(-1);
-    if ((idInSubShape >= 0) && (idInSubShape < myNodes.size()))
+    if ((idInSubShape >= 0) && (idInSubShape < (int) myNodes.size()))
     {
       myNodes[idInSubShape] = 0; // this vector entry is no more used
       if ( ++myUnusedIdNodes == (int) myNodes.size() )
@@ -199,13 +217,12 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
     }
     return false;
   }
-  MESSAGE("Try to remove a node from a complex submesh");
   return false;
 }
 
 //=======================================================================
 //function : NbElements
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 int SMESHDS_SubMesh::NbElements() const
@@ -223,7 +240,7 @@ int SMESHDS_SubMesh::NbElements() const
 
 //=======================================================================
 //function : NbNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 int SMESHDS_SubMesh::NbNodes() const
@@ -240,38 +257,44 @@ int SMESHDS_SubMesh::NbNodes() const
 }
 
 /*!
- * template class used for iteration on submesh elements. Interface of iterator remains
- * unchanged after redesign of SMDS to avoid modification everywhere in SMESH.
- * instances are stored in shared_ptr for automatic destruction.
- * Container is copied for iteration, because original can be modified
- * by addition of elements, for instance, and then reallocated (vector)
+ * Template class used for iteration on vector of elements which can resize
+ * during iteration. The iterator returns only elements present upon its creation.
  */
 template <class ELEM, typename TSET> class MySetIterator : public SMDS_Iterator<ELEM>
 {
 protected:
-  typename TSET::const_iterator _it, _end;
-  TSET _table;
+  int _iCur, _iEnd, _iDelta;
+  const TSET& _table;
 public:
-  MySetIterator(const TSET& table)
+  MySetIterator(const TSET& table, bool reverse): _table( table )
   {
-    _table = table;
-    _it = _table.begin();
-    _end = _table.end();
-    while ((_it != _end) && (*_it == 0))
-      _it++;
+    if ( reverse )
+    {
+      _iCur = _table.size()-1;
+      _iEnd = -1;
+      _iDelta = -1;
+    }
+    else
+    {
+      _iCur = 0;
+      _iEnd = _table.size();
+      _iDelta = 1;
+    }
+    if ( more() && !_table[ _iCur ])
+      next();
   }
 
   virtual bool more()
   {
-    while ((_it != _end) && (*_it == 0))
-      _it++;
-    return (_it != _end);
+    return ( _iEnd - _iCur ) * _iDelta > 0;
   }
 
   virtual ELEM next()
   {
-    ELEM e = *_it;
-    _it++;
+    ELEM e = more() ? _table[ _iCur ] : 0;
+    _iCur += _iDelta;
+    while ( more() && !_table[ _iCur ])
+      _iCur += _iDelta;
     return e;
   }
 };
@@ -282,10 +305,10 @@ public:
 
 template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 {
- public:
+public:
   MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
-    : mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() ), myMore(false)
-    {}
+    : myMore(false), mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() )
+  {}
   bool more()
   {
     while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
@@ -303,11 +326,11 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
       elem = myElemIt->next();
     return elem;
   }
- protected:
+protected:
   virtual boost::shared_ptr< SMDS_Iterator<VALUE> >
-    getElements(const SMESHDS_SubMesh*) const = 0;
+  getElements(const SMESHDS_SubMesh*) const = 0;
 
- private:
+private:
   bool                                        myMore;
   set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
   boost::shared_ptr< SMDS_Iterator<VALUE> >   myElemIt;
@@ -319,7 +342,7 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 
 class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
 {
- public:
+public:
   MyElemIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
     :MyIterator<const SMDS_MeshElement*>( theSubMeshes ) {}
   SMDS_ElemIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
@@ -332,36 +355,39 @@ class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
 
 class MyNodeIterator: public MyIterator<const SMDS_MeshNode*>
 {
- public:
+public:
   MyNodeIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
     :MyIterator<const SMDS_MeshNode*>( theSubMeshes ) {}
   SMDS_NodeIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
   { return theSubMesh->GetNodes(); }
 };
-  
+
 //=======================================================================
 //function : GetElements
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const
+SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements( bool reverse ) const
 {
   if ( IsComplexSubmesh() )
     return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
-  return SMDS_ElemIteratorPtr(new MySetIterator<const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> >(myElements));
+
+  typedef MySetIterator< const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> > TIter;
+  return SMDS_ElemIteratorPtr( new TIter( myElements, reverse ));
 }
 
 //=======================================================================
 //function : GetNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
+SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes( bool reverse ) const
 {
   if ( IsComplexSubmesh() )
     return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
 
-  return SMDS_NodeIteratorPtr(new MySetIterator<const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> >(myNodes));
+  typedef MySetIterator< const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> > TIter;
+  return SMDS_NodeIteratorPtr( new TIter( myNodes, reverse ));
 }
 
 //=======================================================================
@@ -388,14 +414,14 @@ bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
   if (ME->GetType() == SMDSAbs_Node)
   {
     int idInShape = ME->getIdInShape();
-    if ((idInShape >= 0) && (idInShape < myNodes.size()))
+    if ((idInShape >= 0) && (idInShape < (int) myNodes.size()))
       if (myNodes[idInShape] == ME)
         return true;
   }
   else
   {
     int idInShape = ME->getIdInShape();
-    if ((idInShape >= 0) && (idInShape < myElements.size()))
+    if ((idInShape >= 0) && (idInShape < (int) myElements.size()))
       if (myElements[idInShape] == ME)
         return true;
   }
@@ -427,7 +453,7 @@ bool SMESHDS_SubMesh::IsQuadratic() const
 
 //=======================================================================
 //function : AddSubMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 void SMESHDS_SubMesh::AddSubMesh( const SMESHDS_SubMesh* theSubMesh )
@@ -458,7 +484,7 @@ void SMESHDS_SubMesh::RemoveAllSubmeshes()
 
 //=======================================================================
 //function : ContainsSubMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 bool SMESHDS_SubMesh::ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const
@@ -468,7 +494,7 @@ bool SMESHDS_SubMesh::ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const
 
 //=======================================================================
 //function : GetSubMeshIterator
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const
@@ -486,6 +512,24 @@ SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const
 
 void SMESHDS_SubMesh::Clear()
 {
+  if ( myParent && myParent->NbNodes() > 0 )
+  {
+    for ( size_t i = 0; i < myElements.size(); ++i )
+    {
+      if ( myElements[i] &&
+           myElements[i]->GetID() > 0 &&
+           myElements[i] == myParent->FindElement( myElements[i]->GetID() )) // not deleted
+        const_cast< SMDS_MeshElement* >( myElements[i] )->setShapeId( 0 );
+    }
+    for ( size_t i = 0; i < myNodes.size(); ++i )
+    {
+      if ( myNodes[i] &&
+           myNodes[i]->GetID() > 0 &&
+           myNodes[i] == myParent->FindNode( myNodes[i]->GetID() )) // not deleted
+        const_cast< SMDS_MeshNode* >( myNodes[i] )->setShapeId( 0 );
+    }
+  }
+
   clearVector( myElements );
   clearVector( myNodes );
   myUnusedIdNodes = 0;
@@ -513,29 +557,57 @@ void SMESHDS_SubMesh::compactList()
   {
     std::vector<const SMDS_MeshElement*> newElems;
     newElems.reserve( myElements.size() - myUnusedIdElements );
-    for (size_t i = 0; i < myElements.size(); i++)
-      if (myElements[i])
+    for ( size_t i = 0; i < myElements.size(); i++)
+      if ( myElements[i] )
       {
         SMDS_MeshElement* elem = (SMDS_MeshElement*)myElements[i];
-        elem->setIdInShape(newElems.size());
-        newElems.push_back(elem);
+        elem->setIdInShape( newElems.size() );
+        newElems.push_back( elem );
       }
     myElements.swap(newElems);
     myUnusedIdElements = 0;
   }
+  else
+  {
+    std::vector<const SMDS_MeshElement*>( myElements ).swap( myElements );
+  }
 
   if ( myUnusedIdNodes > 0 )
   {
     std::vector<const SMDS_MeshNode*> newNodes;
     newNodes.reserve( myNodes.size() - myUnusedIdNodes );
-    for (size_t i = 0; i < myNodes.size(); i++)
-      if (myNodes[i])
+    for ( size_t i = 0; i < myNodes.size(); i++ )
+      if ( myNodes[i] )
       {
         SMDS_MeshNode* node = (SMDS_MeshNode*)myNodes[i];
-        node->setIdInShape(newNodes.size());
-        newNodes.push_back(node);
+        node->setIdInShape( newNodes.size() );
+        newNodes.push_back( node );
       }
     myNodes.swap(newNodes);
     myUnusedIdNodes = 0;
   }
+  else
+  {
+    std::vector<const SMDS_MeshNode*>( myNodes ).swap( myNodes );
+  }
+}
+
+//=======================================================================
+//function : GetElement
+//purpose  : Return an element by its IdInShape
+//=======================================================================
+
+const SMDS_MeshElement* SMESHDS_SubMesh::GetElement( size_t idInShape ) const
+{
+  return ( !IsComplexSubmesh() && idInShape < myElements.size() ) ? myElements[idInShape] : 0;
+}
+
+//=======================================================================
+//function : GetElement
+//purpose  : Return a node by its IdInShape
+//=======================================================================
+
+const SMDS_MeshNode* SMESHDS_SubMesh::GetNode( size_t idInShape ) const
+{
+  return ( !IsComplexSubmesh() && idInShape < myNodes.size() ) ? myNodes[idInShape] : 0;
 }