X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHUtils%2FSMESH_TypeDefs.hxx;h=f6fcdb505ef2105b2e757d4bd19c296b634715e6;hp=77c095cc17be56cee81a2854fa400945cf35d4be;hb=refs%2Ftags%2FV9_7_0b1;hpb=bc95c31002da130977f9cdbb0a5482741c529104

diff --git a/src/SMESHUtils/SMESH_TypeDefs.hxx b/src/SMESHUtils/SMESH_TypeDefs.hxx
index 77c095cc1..f6fcdb505 100644
--- a/src/SMESHUtils/SMESH_TypeDefs.hxx
+++ b/src/SMESHUtils/SMESH_TypeDefs.hxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021  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
@@ -29,8 +29,11 @@
 
 #include "SMESH_Utils.hxx"
 
+#include "SMDS_SetIterator.hxx"
 #include "SMDS_MeshNode.hxx"
 
+#include <smIdType.hxx>
+
 #include <gp_XYZ.hxx>
 #include <gp_XY.hxx>
 
@@ -39,6 +42,8 @@
 #include <set>
 #include <cassert>
 
+#include <boost/make_shared.hpp>
+
 typedef std::map<const SMDS_MeshElement*,
                  std::list<const SMDS_MeshElement*>, TIDCompare > TElemOfElemListMap;
 typedef std::map<const SMDS_MeshElement*,
@@ -73,6 +78,7 @@ namespace SMESHUtils
     TVECTOR v2( vec );
     vec.swap( v2 );
   }
+
   /*!
    * \brief Auto pointer
    */
@@ -88,6 +94,7 @@ namespace SMESHUtils
   private:
     Deleter( const Deleter& );
   };
+
   /*!
    * \brief Auto pointer to array
    */
@@ -100,6 +107,35 @@ namespace SMESHUtils
   private:
     ArrayDeleter( const ArrayDeleter& );
   };
+
+  /*!
+   * \return SMDS_ElemIteratorPtr on an std container of SMDS_MeshElement's
+   */
+  template < class ELEM_SET >
+  SMDS_ElemIteratorPtr elemSetIterator( const ELEM_SET& elements )
+  {
+    typedef SMDS_SetIterator
+      < SMDS_pElement, typename ELEM_SET::const_iterator> TSetIterator;
+    return boost::make_shared< TSetIterator >( elements.begin(), elements.end() );
+  }
+
+  /*!
+   * \brief Increment enum value
+   */
+  template < typename ENUM >
+  void Increment( ENUM& v, int delta=1 )
+  {
+    v = ENUM( int(v)+delta );
+  }
+
+  /*!
+   * \brief Return incremented enum value
+   */
+  template < typename ENUM >
+  ENUM Add( ENUM v, int delta )
+  {
+    return ENUM( int(v)+delta );
+  }
 }
 
 //=======================================================================
@@ -120,13 +156,14 @@ struct SMESH_TLink: public NLink
   // methods for usage of SMESH_TLink as a hasher in NCollection maps
   static int HashCode(const SMESH_TLink& link, int aLimit)
   {
-    return ::HashCode( link.node1()->GetID() + link.node2()->GetID(), aLimit );
+    return smIdHasher::HashCode( link.node1()->GetID() + link.node2()->GetID(), aLimit );
   }
   static Standard_Boolean IsEqual(const SMESH_TLink& l1, const SMESH_TLink& l2)
   {
     return ( l1.node1() == l2.node1() && l1.node2() == l2.node2() );
   }
 };
+typedef SMESH_TLink SMESH_Link;
 
 //=======================================================================
 /*!
@@ -143,13 +180,12 @@ struct SMESH_OrientedLink: public SMESH_TLink
 
 //------------------------------------------
 /*!
- * \brief SMDS_MeshNode -> gp_XYZ convertor
+ * \brief SMDS_MeshNode -> gp_XYZ converter
  */
 //------------------------------------------
 struct SMESH_TNodeXYZ : public gp_XYZ
 {
   const SMDS_MeshNode* _node;
-  double               _xyz[3];
   SMESH_TNodeXYZ( const SMDS_MeshElement* e=0):gp_XYZ(0,0,0),_node(0)
   {
     Set(e);
@@ -159,15 +195,34 @@ struct SMESH_TNodeXYZ : public gp_XYZ
     if (e) {
       assert( e->GetType() == SMDSAbs_Node );
       _node = static_cast<const SMDS_MeshNode*>(e);
-      _node->GetXYZ(_xyz); // - thread safe getting coords
-      SetCoord( _xyz[0], _xyz[1], _xyz[2] );
+      _node->GetXYZ( ChangeData() ); // - thread safe getting coords
       return true;
     }
     return false;
   }
+  const SMDS_MeshNode* Node() const { return _node; }
   double Distance(const SMDS_MeshNode* n)       const { return (SMESH_TNodeXYZ( n )-*this).Modulus(); }
   double SquareDistance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).SquareModulus(); }
-  bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
+  bool operator==(const SMESH_TNodeXYZ& other)  const { return _node == other._node; }
+  bool operator!=(const SMESH_TNodeXYZ& other)  const { return _node != other._node; }
+  bool operator!() const { return !_node; }
+  const SMDS_MeshNode* operator->() const { return _node; }
+};
+typedef SMESH_TNodeXYZ SMESH_NodeXYZ;
+
+// --------------------------------------------------------------------------------
+// SMESH_Hasher provide methods needed to put mesh data to NCollection maps
+
+struct SMESH_Hasher
+{
+  static Standard_Integer HashCode(const SMDS_MeshElement* e, const Standard_Integer upper)
+  {
+    return smIdHasher::HashCode( e->GetID(), upper );
+  }
+  static Standard_Boolean IsEqual( const SMDS_MeshElement* e1, const SMDS_MeshElement* e2 )
+  {
+    return ( e1 == e2 );
+  }
 };
 
 //--------------------------------------------------
@@ -183,7 +238,7 @@ typedef struct uvPtStruct
   double x, y; // 2d parameter, normalized [0,1]
   const SMDS_MeshNode * node;
 
-  uvPtStruct(): node(NULL) {}
+  uvPtStruct(const SMDS_MeshNode* n = 0): node(n) {}
 
   inline gp_XY UV() const { return gp_XY( u, v ); }
   inline void  SetUV( const gp_XY& uv ) { u = uv.X(); v = uv.Y(); }
@@ -199,17 +254,12 @@ typedef std::vector< UVPtStruct > UVPtStructVec;
 
 // --------------------------------------------------------------------------------
 // class SMESH_SequenceOfElemPtr
-#include <NCollection_DefineSequence.hxx>
-
-class SMDS_MeshElement;
-
-typedef const SMDS_MeshElement* SMDS_MeshElementPtr;
-
-DEFINE_SEQUENCE (SMESH_SequenceOfElemPtr, SMESH_BaseCollectionElemPtr, SMDS_MeshElementPtr)
 
+typedef std::vector< const SMDS_MeshElement* > SMESH_SequenceOfElemPtr;
 
 // --------------------------------------------------------------------------------
 // class SMESH_SequenceOfNode
+#include <NCollection_DefineSequence.hxx>
 typedef const SMDS_MeshNode* SMDS_MeshNodePtr;
 
 DEFINE_SEQUENCE(SMESH_SequenceOfNode,