Salome HOME
PAL7933. Add static IsApplicableHypothesis()
[modules/smesh.git] / src / SMESH / SMESH_subMesh.hxx
index c86ab2e..8251c6b 100644 (file)
@@ -31,6 +31,7 @@
 
 #include "SMESHDS_Mesh.hxx"
 #include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Hypothesis.hxx"
 #include "Utils_SALOME_Exception.hxx"
 #include <TopoDS_Shape.hxx>
 #include <TColStd_IndexedMapOfTransient.hxx>
 
 class SMESH_Mesh;
 class SMESH_Hypothesis;
+class SMESH_Algo;
+class SMESH_Gen;
 
 class SMESH_subMesh
 {
-public:
-  SMESH_subMesh(int Id,
-               SMESH_Mesh* father,
-               const Handle(SMESHDS_Mesh)& meshDS,
+ public:
+  SMESH_subMesh(int Id, SMESH_Mesh * father, SMESHDS_Mesh * meshDS,
                const TopoDS_Shape & aSubShape);
-  virtual ~SMESH_subMesh();
+  virtual ~ SMESH_subMesh();
 
-  int GetId();
+  int GetId() const;
 
-//   bool Contains(const TopoDS_Shape & aSubShape)
-//     throw (SALOME_Exception);
+  //   bool Contains(const TopoDS_Shape & aSubShape)
+  //     throw (SALOME_Exception);
 
-  const Handle(SMESHDS_SubMesh)& GetSubMeshDS()
-    throw (SALOME_Exception);
+  SMESH_Mesh* GetFather() { return _father; }
+  
+  SMESHDS_SubMesh * GetSubMeshDS();
 
-  SMESH_subMesh* GetFirstToCompute()
-    throw (SALOME_Exception);
+  SMESHDS_SubMesh* CreateSubMeshDS();
+  // Explicit SMESHDS_SubMesh creation method, required for persistence mechanism
 
-  const map<int, SMESH_subMesh*>& DependsOn();
-  const map<int, SMESH_subMesh*>& Dependants();
+  SMESH_subMesh *GetFirstToCompute();
 
-  const TopoDS_Shape& GetSubShape();
+  const map < int, SMESH_subMesh * >&DependsOn();
+  //const map < int, SMESH_subMesh * >&Dependants();
 
-  bool _vertexSet;   // only for vertex subMesh, set to false for dim > 0
+  const TopoDS_Shape & GetSubShape();
 
-  enum compute_state { NOT_READY, READY_TO_COMPUTE,
-                      COMPUTE_OK, FAILED_TO_COMPUTE };
-  enum algo_state { NO_ALGO, MISSING_HYP, HYP_OK };
-  enum algo_event {ADD_HYP, ADD_ALGO,
-                  REMOVE_HYP, REMOVE_ALGO,
-                   ADD_FATHER_HYP, ADD_FATHER_ALGO,
-                  REMOVE_FATHER_HYP, REMOVE_FATHER_ALGO};
-  enum compute_event {MODIF_HYP, MODIF_ALGO_STATE, COMPUTE,
-                     CLEAN, CLEANDEP, SUBMESH_COMPUTED};
+//  bool _vertexSet;                   // only for vertex subMesh, set to false for dim > 0
 
-  bool AlgoStateEngine(int event, SMESH_Hypothesis* anHyp)
-    throw (SALOME_Exception);
+  enum compute_state
+  {
+    NOT_READY, READY_TO_COMPUTE,
+    COMPUTE_OK, FAILED_TO_COMPUTE
+    };
+  enum algo_state
+  {
+    NO_ALGO, MISSING_HYP, HYP_OK
+    };
+  enum algo_event
+  {
+    ADD_HYP, ADD_ALGO,
+    REMOVE_HYP, REMOVE_ALGO,
+    ADD_FATHER_HYP, ADD_FATHER_ALGO,
+    REMOVE_FATHER_HYP, REMOVE_FATHER_ALGO
+    };
+  enum compute_event
+  {
+    MODIF_HYP, MODIF_ALGO_STATE, COMPUTE,
+    CLEAN, CLEANDEP, SUBMESH_COMPUTED, SUBMESH_RESTORED,
+    MESH_ENTITY_REMOVED, CHECK_COMPUTE_STATE
+    };
 
-  void SubMeshesAlgoStateEngine(int event, SMESH_Hypothesis* anHyp)
-    throw (SALOME_Exception);
+  SMESH_Hypothesis::Hypothesis_Status
+    AlgoStateEngine(int event, SMESH_Hypothesis * anHyp);
+
+  SMESH_Hypothesis::Hypothesis_Status
+    SubMeshesAlgoStateEngine(int event, SMESH_Hypothesis * anHyp);
+
+  int GetAlgoState() { return _algoState; }
 
   void DumpAlgoState(bool isMain);
 
-  bool ComputeStateEngine(int event)
-    throw (SALOME_Exception);
+  bool ComputeStateEngine(int event);
+
+  int GetComputeState()
+  {
+    return _computeState;
+  };
+
+  bool IsConform(const SMESH_Algo* theAlgo);
+  // check if a conform mesh will be produced by the Algo
+
+  bool CanAddHypothesis(const SMESH_Hypothesis* theHypothesis) const;
+  // return true if theHypothesis can be attached to me:
+  // its dimention is checked
+
+  static bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
+                                    const TopAbs_ShapeEnum  theShapeType);
 
-  int GetComputeState() {return _computeState;};
+  bool IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis) const
+  { return IsApplicableHypotesis( theHypothesis, _subShape.ShapeType() ); }
+  // return true if theHypothesis can be used to mesh me:
+  // its shape type is checked
+  
+  SMESH_Hypothesis::Hypothesis_Status CheckConcurentHypothesis (const int theHypType);
+  // check if there are several applicable hypothesis on fathers
 
-protected:
+ protected:
   void InsertDependence(const TopoDS_Shape aSubShape);
-//   void FinalizeDependence(list<TopoDS_Shape>& shapeList);
 
-  bool SubMeshesComputed()
-    throw (SALOME_Exception);
+  bool SubMeshesComputed();
 
   bool SubMeshesReady();
 
   void RemoveSubMeshElementsAndNodes();
-  void UpdateDependantsState();
+  void UpdateDependantsState(const compute_event theEvent);
+  void UpdateSubMeshState(const compute_state theState);
+  void ComputeSubMeshStateEngine(int event);
   void CleanDependants();
-  void ExtractDependants(const TopTools_IndexedDataMapOfShapeListOfShape& M,
-                        const TopAbs_ShapeEnum etype);
+  void CleanDependsOn();
   void SetAlgoState(int state);
 
+  bool IsMeshComputed() const;
+  // check if _subMeshDS contains mesh elements
+
+  TopoDS_Shape GetCollection(SMESH_Gen * theGen, SMESH_Algo* theAlgo);
+  // return a shape containing all sub-shapes of the MainShape that can be
+  // meshed at once along with _subShape
+
+  bool ApplyToCollection (SMESH_Algo*         theAlgo,
+                          const TopoDS_Shape& theCollection);
+  // Apply theAlgo to all subshapes in theCollection
+
+  const SMESH_Hypothesis* GetSimilarAttached(const TopoDS_Shape&      theShape,
+                                             const SMESH_Hypothesis * theHyp,
+                                             const int                theHypType = 0);
+  // return a hypothesis attached to theShape.
+  // If theHyp is provided, similar but not same hypotheses
+  // is returned; else an applicable ones having theHypType
+  // is returned
+  
   TopoDS_Shape _subShape;
-  Handle (SMESHDS_Mesh) _meshDS;
-  Handle (SMESHDS_SubMesh) _subMeshDS;
+  SMESHDS_Mesh * _meshDS;
+  SMESHDS_SubMesh * _subMeshDS;
   int _Id;
-  SMESH_Mesh* _father;
-  map<int, SMESH_subMesh*> _mapDepend;
-  map<int, SMESH_subMesh*> _mapDependants;
+  SMESH_Mesh *_father;
+  map < int, SMESH_subMesh * >_mapDepend;
   bool _dependenceAnalysed;
-  bool _dependantsFound;
 
   int _algoState;
-  int _oldAlgoState;
   int _computeState;
 
 };