From c6248ade999eaffe5bbddbcaea61487811aa4e0c Mon Sep 17 00:00:00 2001 From: nri Date: Mon, 19 May 2003 13:49:00 +0000 Subject: [PATCH] NRI : First integration. --- src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx | 89 + src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx | 89 + src/SMDS/Handle_SMDSControl_MeshBoundary.hxx | 89 + ...taMapNodeOfDataMapOfIntegerMeshElement.hxx | 89 + ..._SMDS_DataMapNodeOfDataMapOfPntInteger.hxx | 89 + src/SMDS/Handle_SMDS_EdgePosition.hxx | 89 + src/SMDS/Handle_SMDS_FacePosition.hxx | 89 + src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx | 89 + src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx | 89 + ...andle_SMDS_ListNodeOfListOfMeshElement.hxx | 89 + .../Handle_SMDS_ListNodeOfListOfMeshGroup.hxx | 89 + src/SMDS/Handle_SMDS_Mesh.hxx | 89 + src/SMDS/Handle_SMDS_MeshEdge.hxx | 89 + src/SMDS/Handle_SMDS_MeshElement.hxx | 89 + src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx | 89 + src/SMDS/Handle_SMDS_MeshFace.hxx | 89 + src/SMDS/Handle_SMDS_MeshGroup.hxx | 89 + src/SMDS/Handle_SMDS_MeshHexahedron.hxx | 89 + src/SMDS/Handle_SMDS_MeshIDFactory.hxx | 89 + src/SMDS/Handle_SMDS_MeshNode.hxx | 89 + src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx | 89 + src/SMDS/Handle_SMDS_MeshObject.hxx | 89 + src/SMDS/Handle_SMDS_MeshPrism.hxx | 89 + src/SMDS/Handle_SMDS_MeshPyramid.hxx | 89 + src/SMDS/Handle_SMDS_MeshQuadrangle.hxx | 89 + src/SMDS/Handle_SMDS_MeshTetrahedron.hxx | 89 + src/SMDS/Handle_SMDS_MeshTriangle.hxx | 89 + src/SMDS/Handle_SMDS_MeshVolume.hxx | 89 + src/SMDS/Handle_SMDS_Position.hxx | 89 + ...ndle_SMDS_SequenceNodeOfSequenceOfMesh.hxx | 89 + src/SMDS/Handle_SMDS_SpacePosition.hxx | 89 + .../Handle_SMDS_StdMapNodeOfExtendedMap.hxx | 89 + ...e_SMDS_StdMapNodeOfExtendedOrientedMap.hxx | 89 + src/SMDS/Handle_SMDS_VertexPosition.hxx | 89 + src/SMDS/Makefile.in | 263 +++ src/SMDS/SMDS.cdl | 148 ++ src/SMDS/SMDSAbs.cdl | 24 + src/SMDS/SMDSAbs_ElementType.hxx | 31 + src/SMDS/SMDSControl.cdl | 39 + src/SMDS/SMDSControl.cxx | 214 +++ src/SMDS/SMDSControl.hxx | 104 ++ src/SMDS/SMDSControl.ixx | 19 + src/SMDS/SMDSControl.jxx | 9 + src/SMDS/SMDSControl_BoundaryEdges.cdl | 29 + src/SMDS/SMDSControl_BoundaryEdges.cxx | 59 + src/SMDS/SMDSControl_BoundaryEdges.hxx | 104 ++ src/SMDS/SMDSControl_BoundaryEdges.ixx | 71 + src/SMDS/SMDSControl_BoundaryEdges.jxx | 6 + src/SMDS/SMDSControl_BoundaryFaces.cdl | 31 + src/SMDS/SMDSControl_BoundaryFaces.cxx | 82 + src/SMDS/SMDSControl_BoundaryFaces.hxx | 104 ++ src/SMDS/SMDSControl_BoundaryFaces.ixx | 71 + src/SMDS/SMDSControl_BoundaryFaces.jxx | 6 + src/SMDS/SMDSControl_MeshBoundary.cdl | 35 + src/SMDS/SMDSControl_MeshBoundary.cxx | 40 + src/SMDS/SMDSControl_MeshBoundary.hxx | 104 ++ src/SMDS/SMDSControl_MeshBoundary.ixx | 69 + src/SMDS/SMDSControl_MeshBoundary.jxx | 6 + src/SMDS/SMDSEdit.cdl | 24 + src/SMDS/SMDSEdit_Transform.cdl | 47 + src/SMDS/SMDSEdit_Transform.cxx | 100 ++ src/SMDS/SMDSEdit_Transform.hxx | 104 ++ src/SMDS/SMDSEdit_Transform.ixx | 19 + src/SMDS/SMDSEdit_Transform.jxx | 12 + src/SMDS/SMDS_BasicMap.lxx | 1 + src/SMDS/SMDS_BasicMapIterator.lxx | 1 + ...pIteratorOfDataMapOfIntegerMeshElement.hxx | 106 ++ ...teratorOfDataMapOfIntegerMeshElement_0.cxx | 50 + ...S_DataMapIteratorOfDataMapOfPntInteger.hxx | 103 ++ ...DataMapIteratorOfDataMapOfPntInteger_0.cxx | 50 + ...taMapNodeOfDataMapOfIntegerMeshElement.hxx | 141 ++ ...MapNodeOfDataMapOfIntegerMeshElement_0.cxx | 99 ++ .../SMDS_DataMapNodeOfDataMapOfPntInteger.hxx | 141 ++ ...MDS_DataMapNodeOfDataMapOfPntInteger_0.cxx | 99 ++ src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx | 135 ++ .../SMDS_DataMapOfIntegerMeshElement_0.cxx | 53 + src/SMDS/SMDS_DataMapOfPntInteger.hxx | 132 ++ src/SMDS/SMDS_DataMapOfPntInteger_0.cxx | 53 + src/SMDS/SMDS_EdgePosition.cdl | 36 + src/SMDS/SMDS_EdgePosition.cxx | 41 + src/SMDS/SMDS_EdgePosition.hxx | 108 ++ src/SMDS/SMDS_EdgePosition.ixx | 71 + src/SMDS/SMDS_EdgePosition.jxx | 6 + src/SMDS/SMDS_EdgePosition.lxx | 24 + src/SMDS/SMDS_ExtendedMap.hxx | 122 ++ src/SMDS/SMDS_ExtendedMap_0.cxx | 48 + src/SMDS/SMDS_ExtendedOrientedMap.hxx | 122 ++ src/SMDS/SMDS_ExtendedOrientedMap_0.cxx | 48 + src/SMDS/SMDS_FacePosition.cdl | 44 + src/SMDS/SMDS_FacePosition.cxx | 43 + src/SMDS/SMDS_FacePosition.hxx | 111 ++ src/SMDS/SMDS_FacePosition.ixx | 71 + src/SMDS/SMDS_FacePosition.jxx | 6 + src/SMDS/SMDS_FacePosition.lxx | 44 + src/SMDS/SMDS_HSequenceOfMesh.hxx | 155 ++ src/SMDS/SMDS_HSequenceOfMesh_0.cxx | 91 + src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx | 131 ++ .../SMDS_ListIteratorOfListOfMeshElement.hxx | 131 ++ ...SMDS_ListIteratorOfListOfMeshElement_0.cxx | 46 + .../SMDS_ListIteratorOfListOfMeshGroup.hxx | 131 ++ .../SMDS_ListIteratorOfListOfMeshGroup_0.cxx | 46 + src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx | 46 + src/SMDS/SMDS_ListNodeOfListOfMesh.hxx | 127 ++ src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx | 127 ++ .../SMDS_ListNodeOfListOfMeshElement_0.cxx | 92 ++ src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx | 127 ++ src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx | 92 ++ src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx | 92 ++ src/SMDS/SMDS_ListOfMesh.hxx | 155 ++ src/SMDS/SMDS_ListOfMeshElement.hxx | 155 ++ src/SMDS/SMDS_ListOfMeshElement_0.cxx | 43 + src/SMDS/SMDS_ListOfMeshGroup.hxx | 155 ++ src/SMDS/SMDS_ListOfMeshGroup_0.cxx | 43 + src/SMDS/SMDS_ListOfMesh_0.cxx | 43 + src/SMDS/SMDS_Map.gxx | 1 + src/SMDS/SMDS_MapHasher.gxx | 1 + src/SMDS/SMDS_MapIterator.gxx | 1 + src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx | 102 ++ src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx | 48 + .../SMDS_MapIteratorOfExtendedOrientedMap.hxx | 102 ++ ...MDS_MapIteratorOfExtendedOrientedMap_0.cxx | 48 + src/SMDS/SMDS_MapNode.lxx | 1 + src/SMDS/SMDS_MapOfMeshElement.cdl | 60 + src/SMDS/SMDS_MapOfMeshElement.cxx | 131 ++ src/SMDS/SMDS_MapOfMeshElement.hxx | 119 ++ src/SMDS/SMDS_MapOfMeshElement.ixx | 19 + src/SMDS/SMDS_MapOfMeshElement.jxx | 9 + src/SMDS/SMDS_MapOfMeshElement.lxx | 12 + src/SMDS/SMDS_MapOfMeshOrientedElement.cdl | 60 + src/SMDS/SMDS_MapOfMeshOrientedElement.cxx | 131 ++ src/SMDS/SMDS_MapOfMeshOrientedElement.hxx | 119 ++ src/SMDS/SMDS_MapOfMeshOrientedElement.ixx | 19 + src/SMDS/SMDS_MapOfMeshOrientedElement.jxx | 9 + src/SMDS/SMDS_MapOfMeshOrientedElement.lxx | 12 + src/SMDS/SMDS_Mesh.cdl | 408 +++++ src/SMDS/SMDS_Mesh.cxx | 1472 +++++++++++++++++ src/SMDS/SMDS_Mesh.hxx | 224 +++ src/SMDS/SMDS_Mesh.ixx | 71 + src/SMDS/SMDS_Mesh.jxx | 36 + src/SMDS/SMDS_Mesh.lxx | 57 + src/SMDS/SMDS_MeshEdge.cdl | 38 + src/SMDS/SMDS_MeshEdge.cxx | 53 + src/SMDS/SMDS_MeshEdge.hxx | 113 ++ src/SMDS/SMDS_MeshEdge.ixx | 73 + src/SMDS/SMDS_MeshEdge.jxx | 3 + src/SMDS/SMDS_MeshEdge.lxx | 51 + src/SMDS/SMDS_MeshEdgesIterator.cdl | 35 + src/SMDS/SMDS_MeshEdgesIterator.cxx | 42 + src/SMDS/SMDS_MeshEdgesIterator.hxx | 96 ++ src/SMDS/SMDS_MeshEdgesIterator.ixx | 19 + src/SMDS/SMDS_MeshEdgesIterator.jxx | 12 + src/SMDS/SMDS_MeshElement.cdl | 115 ++ src/SMDS/SMDS_MeshElement.cxx | 177 ++ src/SMDS/SMDS_MeshElement.hxx | 148 ++ src/SMDS/SMDS_MeshElement.ixx | 71 + src/SMDS/SMDS_MeshElement.jxx | 18 + src/SMDS/SMDS_MeshElement.lxx | 131 ++ src/SMDS/SMDS_MeshElementIDFactory.cdl | 45 + src/SMDS/SMDS_MeshElementIDFactory.cxx | 18 + src/SMDS/SMDS_MeshElementIDFactory.hxx | 114 ++ src/SMDS/SMDS_MeshElementIDFactory.ixx | 73 + src/SMDS/SMDS_MeshElementIDFactory.jxx | 6 + src/SMDS/SMDS_MeshElementIDFactory.lxx | 56 + src/SMDS/SMDS_MeshElementMapHasher.cdl | 31 + src/SMDS/SMDS_MeshElementMapHasher.cxx | 8 + src/SMDS/SMDS_MeshElementMapHasher.hxx | 97 ++ src/SMDS/SMDS_MeshElementMapHasher.ixx | 19 + src/SMDS/SMDS_MeshElementMapHasher.jxx | 6 + src/SMDS/SMDS_MeshElementMapHasher.lxx | 27 + src/SMDS/SMDS_MeshElementsIterator.cdl | 56 + src/SMDS/SMDS_MeshElementsIterator.cxx | 24 + src/SMDS/SMDS_MeshElementsIterator.hxx | 109 ++ src/SMDS/SMDS_MeshElementsIterator.ixx | 19 + src/SMDS/SMDS_MeshElementsIterator.jxx | 15 + src/SMDS/SMDS_MeshElementsIterator.lxx | 28 + src/SMDS/SMDS_MeshFace.cdl | 34 + src/SMDS/SMDS_MeshFace.cxx | 45 + src/SMDS/SMDS_MeshFace.hxx | 107 ++ src/SMDS/SMDS_MeshFace.ixx | 73 + src/SMDS/SMDS_MeshFace.jxx | 3 + src/SMDS/SMDS_MeshFace.lxx | 16 + src/SMDS/SMDS_MeshFacesIterator.cdl | 34 + src/SMDS/SMDS_MeshFacesIterator.cxx | 42 + src/SMDS/SMDS_MeshFacesIterator.hxx | 96 ++ src/SMDS/SMDS_MeshFacesIterator.ixx | 19 + src/SMDS/SMDS_MeshFacesIterator.jxx | 12 + src/SMDS/SMDS_MeshGroup.cdl | 116 ++ src/SMDS/SMDS_MeshGroup.cxx | 162 ++ src/SMDS/SMDS_MeshGroup.hxx | 142 ++ src/SMDS/SMDS_MeshGroup.ixx | 71 + src/SMDS/SMDS_MeshGroup.jxx | 21 + src/SMDS/SMDS_MeshGroup.lxx | 14 + src/SMDS/SMDS_MeshHexahedron.cdl | 69 + src/SMDS/SMDS_MeshHexahedron.cxx | 196 +++ src/SMDS/SMDS_MeshHexahedron.hxx | 114 ++ src/SMDS/SMDS_MeshHexahedron.ixx | 75 + src/SMDS/SMDS_MeshHexahedron.jxx | 6 + src/SMDS/SMDS_MeshHexahedron.lxx | 63 + src/SMDS/SMDS_MeshIDFactory.cdl | 32 + src/SMDS/SMDS_MeshIDFactory.cxx | 19 + src/SMDS/SMDS_MeshIDFactory.hxx | 105 ++ src/SMDS/SMDS_MeshIDFactory.ixx | 71 + src/SMDS/SMDS_MeshIDFactory.jxx | 3 + src/SMDS/SMDS_MeshIDFactory.lxx | 34 + src/SMDS/SMDS_MeshNode.cdl | 64 + src/SMDS/SMDS_MeshNode.cxx | 83 + src/SMDS/SMDS_MeshNode.hxx | 137 ++ src/SMDS/SMDS_MeshNode.ixx | 73 + src/SMDS/SMDS_MeshNode.jxx | 12 + src/SMDS/SMDS_MeshNode.lxx | 103 ++ src/SMDS/SMDS_MeshNodeIDFactory.cdl | 26 + src/SMDS/SMDS_MeshNodeIDFactory.cxx | 18 + src/SMDS/SMDS_MeshNodeIDFactory.hxx | 101 ++ src/SMDS/SMDS_MeshNodeIDFactory.ixx | 73 + src/SMDS/SMDS_MeshNodeIDFactory.jxx | 3 + src/SMDS/SMDS_MeshNodeIDFactory.lxx | 34 + src/SMDS/SMDS_MeshNodesIterator.cdl | 34 + src/SMDS/SMDS_MeshNodesIterator.cxx | 42 + src/SMDS/SMDS_MeshNodesIterator.hxx | 96 ++ src/SMDS/SMDS_MeshNodesIterator.ixx | 19 + src/SMDS/SMDS_MeshNodesIterator.jxx | 12 + src/SMDS/SMDS_MeshObject.cdl | 15 + src/SMDS/SMDS_MeshObject.cxx | 8 + src/SMDS/SMDS_MeshObject.hxx | 94 ++ src/SMDS/SMDS_MeshObject.ixx | 69 + src/SMDS/SMDS_MeshObject.jxx | 3 + .../SMDS_MeshOrientedElementMapHasher.cdl | 31 + .../SMDS_MeshOrientedElementMapHasher.cxx | 8 + .../SMDS_MeshOrientedElementMapHasher.hxx | 97 ++ .../SMDS_MeshOrientedElementMapHasher.ixx | 19 + .../SMDS_MeshOrientedElementMapHasher.jxx | 6 + .../SMDS_MeshOrientedElementMapHasher.lxx | 27 + src/SMDS/SMDS_MeshPrism.cdl | 67 + src/SMDS/SMDS_MeshPrism.cxx | 161 ++ src/SMDS/SMDS_MeshPrism.hxx | 114 ++ src/SMDS/SMDS_MeshPrism.ixx | 75 + src/SMDS/SMDS_MeshPrism.jxx | 6 + src/SMDS/SMDS_MeshPrism.lxx | 62 + src/SMDS/SMDS_MeshPyramid.cdl | 68 + src/SMDS/SMDS_MeshPyramid.cxx | 147 ++ src/SMDS/SMDS_MeshPyramid.hxx | 114 ++ src/SMDS/SMDS_MeshPyramid.ixx | 75 + src/SMDS/SMDS_MeshPyramid.jxx | 6 + src/SMDS/SMDS_MeshPyramid.lxx | 61 + src/SMDS/SMDS_MeshQuadrangle.cdl | 43 + src/SMDS/SMDS_MeshQuadrangle.cxx | 62 + src/SMDS/SMDS_MeshQuadrangle.hxx | 108 ++ src/SMDS/SMDS_MeshQuadrangle.ixx | 75 + src/SMDS/SMDS_MeshQuadrangle.jxx | 3 + src/SMDS/SMDS_MeshQuadrangle.lxx | 53 + src/SMDS/SMDS_MeshTetrahedron.cdl | 67 + src/SMDS/SMDS_MeshTetrahedron.cxx | 128 ++ src/SMDS/SMDS_MeshTetrahedron.hxx | 114 ++ src/SMDS/SMDS_MeshTetrahedron.ixx | 75 + src/SMDS/SMDS_MeshTetrahedron.jxx | 6 + src/SMDS/SMDS_MeshTetrahedron.lxx | 62 + src/SMDS/SMDS_MeshTriangle.cdl | 44 + src/SMDS/SMDS_MeshTriangle.cxx | 50 + src/SMDS/SMDS_MeshTriangle.hxx | 108 ++ src/SMDS/SMDS_MeshTriangle.ixx | 75 + src/SMDS/SMDS_MeshTriangle.jxx | 3 + src/SMDS/SMDS_MeshTriangle.lxx | 56 + src/SMDS/SMDS_MeshVolume.cdl | 35 + src/SMDS/SMDS_MeshVolume.cxx | 34 + src/SMDS/SMDS_MeshVolume.hxx | 107 ++ src/SMDS/SMDS_MeshVolume.ixx | 73 + src/SMDS/SMDS_MeshVolume.jxx | 6 + src/SMDS/SMDS_MeshVolume.lxx | 16 + src/SMDS/SMDS_MeshVolumesIterator.cdl | 34 + src/SMDS/SMDS_MeshVolumesIterator.cxx | 42 + src/SMDS/SMDS_MeshVolumesIterator.hxx | 96 ++ src/SMDS/SMDS_MeshVolumesIterator.ixx | 19 + src/SMDS/SMDS_MeshVolumesIterator.jxx | 12 + src/SMDS/SMDS_PntHasher.cdl | 26 + src/SMDS/SMDS_PntHasher.cxx | 8 + src/SMDS/SMDS_PntHasher.hxx | 94 ++ src/SMDS/SMDS_PntHasher.ixx | 19 + src/SMDS/SMDS_PntHasher.jxx | 6 + src/SMDS/SMDS_PntHasher.lxx | 42 + src/SMDS/SMDS_Position.cdl | 48 + src/SMDS/SMDS_Position.cxx | 19 + src/SMDS/SMDS_Position.hxx | 109 ++ src/SMDS/SMDS_Position.ixx | 69 + src/SMDS/SMDS_Position.jxx | 6 + src/SMDS/SMDS_Position.lxx | 34 + .../SMDS_SequenceNodeOfSequenceOfMesh.hxx | 122 ++ .../SMDS_SequenceNodeOfSequenceOfMesh_0.cxx | 87 + src/SMDS/SMDS_SequenceOfMesh.hxx | 157 ++ src/SMDS/SMDS_SequenceOfMesh_0.cxx | 41 + src/SMDS/SMDS_SpacePosition.cdl | 38 + src/SMDS/SMDS_SpacePosition.cxx | 50 + src/SMDS/SMDS_SpacePosition.hxx | 109 ++ src/SMDS/SMDS_SpacePosition.ixx | 71 + src/SMDS/SMDS_SpacePosition.jxx | 6 + src/SMDS/SMDS_SpacePosition.lxx | 26 + src/SMDS/SMDS_StdMapNode.gxx | 1 + src/SMDS/SMDS_StdMapNode.lxx | 1 + src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx | 132 ++ src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx | 97 ++ .../SMDS_StdMapNodeOfExtendedOrientedMap.hxx | 132 ++ ...SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx | 97 ++ src/SMDS/SMDS_TypeOfPosition.hxx | 31 + src/SMDS/SMDS_VertexPosition.cdl | 26 + src/SMDS/SMDS_VertexPosition.cxx | 41 + src/SMDS/SMDS_VertexPosition.hxx | 101 ++ src/SMDS/SMDS_VertexPosition.ixx | 71 + src/SMDS/SMDS_VertexPosition.jxx | 6 + 307 files changed, 21941 insertions(+) create mode 100644 src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx create mode 100644 src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx create mode 100644 src/SMDS/Handle_SMDSControl_MeshBoundary.hxx create mode 100644 src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx create mode 100644 src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx create mode 100644 src/SMDS/Handle_SMDS_EdgePosition.hxx create mode 100644 src/SMDS/Handle_SMDS_FacePosition.hxx create mode 100644 src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx create mode 100644 src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx create mode 100644 src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx create mode 100644 src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx create mode 100644 src/SMDS/Handle_SMDS_Mesh.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshEdge.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshElement.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshFace.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshGroup.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshHexahedron.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshIDFactory.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshNode.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshObject.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshPrism.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshPyramid.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshQuadrangle.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshTetrahedron.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshTriangle.hxx create mode 100644 src/SMDS/Handle_SMDS_MeshVolume.hxx create mode 100644 src/SMDS/Handle_SMDS_Position.hxx create mode 100644 src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx create mode 100644 src/SMDS/Handle_SMDS_SpacePosition.hxx create mode 100644 src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx create mode 100644 src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx create mode 100644 src/SMDS/Handle_SMDS_VertexPosition.hxx create mode 100644 src/SMDS/Makefile.in create mode 100755 src/SMDS/SMDS.cdl create mode 100644 src/SMDS/SMDSAbs.cdl create mode 100644 src/SMDS/SMDSAbs_ElementType.hxx create mode 100644 src/SMDS/SMDSControl.cdl create mode 100644 src/SMDS/SMDSControl.cxx create mode 100644 src/SMDS/SMDSControl.hxx create mode 100644 src/SMDS/SMDSControl.ixx create mode 100644 src/SMDS/SMDSControl.jxx create mode 100644 src/SMDS/SMDSControl_BoundaryEdges.cdl create mode 100644 src/SMDS/SMDSControl_BoundaryEdges.cxx create mode 100644 src/SMDS/SMDSControl_BoundaryEdges.hxx create mode 100644 src/SMDS/SMDSControl_BoundaryEdges.ixx create mode 100644 src/SMDS/SMDSControl_BoundaryEdges.jxx create mode 100644 src/SMDS/SMDSControl_BoundaryFaces.cdl create mode 100644 src/SMDS/SMDSControl_BoundaryFaces.cxx create mode 100644 src/SMDS/SMDSControl_BoundaryFaces.hxx create mode 100644 src/SMDS/SMDSControl_BoundaryFaces.ixx create mode 100644 src/SMDS/SMDSControl_BoundaryFaces.jxx create mode 100644 src/SMDS/SMDSControl_MeshBoundary.cdl create mode 100644 src/SMDS/SMDSControl_MeshBoundary.cxx create mode 100644 src/SMDS/SMDSControl_MeshBoundary.hxx create mode 100644 src/SMDS/SMDSControl_MeshBoundary.ixx create mode 100644 src/SMDS/SMDSControl_MeshBoundary.jxx create mode 100644 src/SMDS/SMDSEdit.cdl create mode 100644 src/SMDS/SMDSEdit_Transform.cdl create mode 100644 src/SMDS/SMDSEdit_Transform.cxx create mode 100644 src/SMDS/SMDSEdit_Transform.hxx create mode 100644 src/SMDS/SMDSEdit_Transform.ixx create mode 100644 src/SMDS/SMDSEdit_Transform.jxx create mode 100644 src/SMDS/SMDS_BasicMap.lxx create mode 100644 src/SMDS/SMDS_BasicMapIterator.lxx create mode 100644 src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx create mode 100644 src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx create mode 100644 src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx create mode 100644 src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx create mode 100644 src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx create mode 100644 src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx create mode 100644 src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx create mode 100644 src/SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_DataMapOfPntInteger.hxx create mode 100644 src/SMDS/SMDS_DataMapOfPntInteger_0.cxx create mode 100644 src/SMDS/SMDS_EdgePosition.cdl create mode 100644 src/SMDS/SMDS_EdgePosition.cxx create mode 100644 src/SMDS/SMDS_EdgePosition.hxx create mode 100644 src/SMDS/SMDS_EdgePosition.ixx create mode 100644 src/SMDS/SMDS_EdgePosition.jxx create mode 100644 src/SMDS/SMDS_EdgePosition.lxx create mode 100644 src/SMDS/SMDS_ExtendedMap.hxx create mode 100644 src/SMDS/SMDS_ExtendedMap_0.cxx create mode 100644 src/SMDS/SMDS_ExtendedOrientedMap.hxx create mode 100644 src/SMDS/SMDS_ExtendedOrientedMap_0.cxx create mode 100644 src/SMDS/SMDS_FacePosition.cdl create mode 100644 src/SMDS/SMDS_FacePosition.cxx create mode 100644 src/SMDS/SMDS_FacePosition.hxx create mode 100644 src/SMDS/SMDS_FacePosition.ixx create mode 100644 src/SMDS/SMDS_FacePosition.jxx create mode 100644 src/SMDS/SMDS_FacePosition.lxx create mode 100644 src/SMDS/SMDS_HSequenceOfMesh.hxx create mode 100644 src/SMDS/SMDS_HSequenceOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx create mode 100644 src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMesh.hxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx create mode 100644 src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_ListOfMesh.hxx create mode 100644 src/SMDS/SMDS_ListOfMeshElement.hxx create mode 100644 src/SMDS/SMDS_ListOfMeshElement_0.cxx create mode 100644 src/SMDS/SMDS_ListOfMeshGroup.hxx create mode 100644 src/SMDS/SMDS_ListOfMeshGroup_0.cxx create mode 100644 src/SMDS/SMDS_ListOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_Map.gxx create mode 100644 src/SMDS/SMDS_MapHasher.gxx create mode 100644 src/SMDS/SMDS_MapIterator.gxx create mode 100644 src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx create mode 100644 src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx create mode 100644 src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx create mode 100644 src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx create mode 100644 src/SMDS/SMDS_MapNode.lxx create mode 100644 src/SMDS/SMDS_MapOfMeshElement.cdl create mode 100644 src/SMDS/SMDS_MapOfMeshElement.cxx create mode 100644 src/SMDS/SMDS_MapOfMeshElement.hxx create mode 100644 src/SMDS/SMDS_MapOfMeshElement.ixx create mode 100644 src/SMDS/SMDS_MapOfMeshElement.jxx create mode 100644 src/SMDS/SMDS_MapOfMeshElement.lxx create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.cdl create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.cxx create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.hxx create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.ixx create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.jxx create mode 100644 src/SMDS/SMDS_MapOfMeshOrientedElement.lxx create mode 100755 src/SMDS/SMDS_Mesh.cdl create mode 100644 src/SMDS/SMDS_Mesh.cxx create mode 100644 src/SMDS/SMDS_Mesh.hxx create mode 100644 src/SMDS/SMDS_Mesh.ixx create mode 100644 src/SMDS/SMDS_Mesh.jxx create mode 100644 src/SMDS/SMDS_Mesh.lxx create mode 100755 src/SMDS/SMDS_MeshEdge.cdl create mode 100644 src/SMDS/SMDS_MeshEdge.cxx create mode 100644 src/SMDS/SMDS_MeshEdge.hxx create mode 100644 src/SMDS/SMDS_MeshEdge.ixx create mode 100644 src/SMDS/SMDS_MeshEdge.jxx create mode 100644 src/SMDS/SMDS_MeshEdge.lxx create mode 100644 src/SMDS/SMDS_MeshEdgesIterator.cdl create mode 100644 src/SMDS/SMDS_MeshEdgesIterator.cxx create mode 100644 src/SMDS/SMDS_MeshEdgesIterator.hxx create mode 100644 src/SMDS/SMDS_MeshEdgesIterator.ixx create mode 100644 src/SMDS/SMDS_MeshEdgesIterator.jxx create mode 100644 src/SMDS/SMDS_MeshElement.cdl create mode 100644 src/SMDS/SMDS_MeshElement.cxx create mode 100644 src/SMDS/SMDS_MeshElement.hxx create mode 100644 src/SMDS/SMDS_MeshElement.ixx create mode 100644 src/SMDS/SMDS_MeshElement.jxx create mode 100644 src/SMDS/SMDS_MeshElement.lxx create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.cdl create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.cxx create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.hxx create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.ixx create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.jxx create mode 100644 src/SMDS/SMDS_MeshElementIDFactory.lxx create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.cdl create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.cxx create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.hxx create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.ixx create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.jxx create mode 100644 src/SMDS/SMDS_MeshElementMapHasher.lxx create mode 100644 src/SMDS/SMDS_MeshElementsIterator.cdl create mode 100644 src/SMDS/SMDS_MeshElementsIterator.cxx create mode 100644 src/SMDS/SMDS_MeshElementsIterator.hxx create mode 100644 src/SMDS/SMDS_MeshElementsIterator.ixx create mode 100644 src/SMDS/SMDS_MeshElementsIterator.jxx create mode 100644 src/SMDS/SMDS_MeshElementsIterator.lxx create mode 100755 src/SMDS/SMDS_MeshFace.cdl create mode 100644 src/SMDS/SMDS_MeshFace.cxx create mode 100644 src/SMDS/SMDS_MeshFace.hxx create mode 100644 src/SMDS/SMDS_MeshFace.ixx create mode 100644 src/SMDS/SMDS_MeshFace.jxx create mode 100644 src/SMDS/SMDS_MeshFace.lxx create mode 100644 src/SMDS/SMDS_MeshFacesIterator.cdl create mode 100644 src/SMDS/SMDS_MeshFacesIterator.cxx create mode 100644 src/SMDS/SMDS_MeshFacesIterator.hxx create mode 100644 src/SMDS/SMDS_MeshFacesIterator.ixx create mode 100644 src/SMDS/SMDS_MeshFacesIterator.jxx create mode 100644 src/SMDS/SMDS_MeshGroup.cdl create mode 100644 src/SMDS/SMDS_MeshGroup.cxx create mode 100644 src/SMDS/SMDS_MeshGroup.hxx create mode 100644 src/SMDS/SMDS_MeshGroup.ixx create mode 100644 src/SMDS/SMDS_MeshGroup.jxx create mode 100644 src/SMDS/SMDS_MeshGroup.lxx create mode 100644 src/SMDS/SMDS_MeshHexahedron.cdl create mode 100644 src/SMDS/SMDS_MeshHexahedron.cxx create mode 100644 src/SMDS/SMDS_MeshHexahedron.hxx create mode 100644 src/SMDS/SMDS_MeshHexahedron.ixx create mode 100644 src/SMDS/SMDS_MeshHexahedron.jxx create mode 100644 src/SMDS/SMDS_MeshHexahedron.lxx create mode 100644 src/SMDS/SMDS_MeshIDFactory.cdl create mode 100644 src/SMDS/SMDS_MeshIDFactory.cxx create mode 100644 src/SMDS/SMDS_MeshIDFactory.hxx create mode 100644 src/SMDS/SMDS_MeshIDFactory.ixx create mode 100644 src/SMDS/SMDS_MeshIDFactory.jxx create mode 100644 src/SMDS/SMDS_MeshIDFactory.lxx create mode 100755 src/SMDS/SMDS_MeshNode.cdl create mode 100644 src/SMDS/SMDS_MeshNode.cxx create mode 100644 src/SMDS/SMDS_MeshNode.hxx create mode 100644 src/SMDS/SMDS_MeshNode.ixx create mode 100644 src/SMDS/SMDS_MeshNode.jxx create mode 100644 src/SMDS/SMDS_MeshNode.lxx create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.cdl create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.cxx create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.hxx create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.ixx create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.jxx create mode 100644 src/SMDS/SMDS_MeshNodeIDFactory.lxx create mode 100644 src/SMDS/SMDS_MeshNodesIterator.cdl create mode 100644 src/SMDS/SMDS_MeshNodesIterator.cxx create mode 100644 src/SMDS/SMDS_MeshNodesIterator.hxx create mode 100644 src/SMDS/SMDS_MeshNodesIterator.ixx create mode 100644 src/SMDS/SMDS_MeshNodesIterator.jxx create mode 100644 src/SMDS/SMDS_MeshObject.cdl create mode 100644 src/SMDS/SMDS_MeshObject.cxx create mode 100644 src/SMDS/SMDS_MeshObject.hxx create mode 100644 src/SMDS/SMDS_MeshObject.ixx create mode 100644 src/SMDS/SMDS_MeshObject.jxx create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.cdl create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.cxx create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.hxx create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.ixx create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.jxx create mode 100644 src/SMDS/SMDS_MeshOrientedElementMapHasher.lxx create mode 100644 src/SMDS/SMDS_MeshPrism.cdl create mode 100644 src/SMDS/SMDS_MeshPrism.cxx create mode 100644 src/SMDS/SMDS_MeshPrism.hxx create mode 100644 src/SMDS/SMDS_MeshPrism.ixx create mode 100644 src/SMDS/SMDS_MeshPrism.jxx create mode 100644 src/SMDS/SMDS_MeshPrism.lxx create mode 100644 src/SMDS/SMDS_MeshPyramid.cdl create mode 100644 src/SMDS/SMDS_MeshPyramid.cxx create mode 100644 src/SMDS/SMDS_MeshPyramid.hxx create mode 100644 src/SMDS/SMDS_MeshPyramid.ixx create mode 100644 src/SMDS/SMDS_MeshPyramid.jxx create mode 100644 src/SMDS/SMDS_MeshPyramid.lxx create mode 100644 src/SMDS/SMDS_MeshQuadrangle.cdl create mode 100644 src/SMDS/SMDS_MeshQuadrangle.cxx create mode 100644 src/SMDS/SMDS_MeshQuadrangle.hxx create mode 100644 src/SMDS/SMDS_MeshQuadrangle.ixx create mode 100644 src/SMDS/SMDS_MeshQuadrangle.jxx create mode 100644 src/SMDS/SMDS_MeshQuadrangle.lxx create mode 100644 src/SMDS/SMDS_MeshTetrahedron.cdl create mode 100644 src/SMDS/SMDS_MeshTetrahedron.cxx create mode 100644 src/SMDS/SMDS_MeshTetrahedron.hxx create mode 100644 src/SMDS/SMDS_MeshTetrahedron.ixx create mode 100644 src/SMDS/SMDS_MeshTetrahedron.jxx create mode 100644 src/SMDS/SMDS_MeshTetrahedron.lxx create mode 100644 src/SMDS/SMDS_MeshTriangle.cdl create mode 100644 src/SMDS/SMDS_MeshTriangle.cxx create mode 100644 src/SMDS/SMDS_MeshTriangle.hxx create mode 100644 src/SMDS/SMDS_MeshTriangle.ixx create mode 100644 src/SMDS/SMDS_MeshTriangle.jxx create mode 100644 src/SMDS/SMDS_MeshTriangle.lxx create mode 100755 src/SMDS/SMDS_MeshVolume.cdl create mode 100644 src/SMDS/SMDS_MeshVolume.cxx create mode 100644 src/SMDS/SMDS_MeshVolume.hxx create mode 100644 src/SMDS/SMDS_MeshVolume.ixx create mode 100644 src/SMDS/SMDS_MeshVolume.jxx create mode 100644 src/SMDS/SMDS_MeshVolume.lxx create mode 100644 src/SMDS/SMDS_MeshVolumesIterator.cdl create mode 100644 src/SMDS/SMDS_MeshVolumesIterator.cxx create mode 100644 src/SMDS/SMDS_MeshVolumesIterator.hxx create mode 100644 src/SMDS/SMDS_MeshVolumesIterator.ixx create mode 100644 src/SMDS/SMDS_MeshVolumesIterator.jxx create mode 100644 src/SMDS/SMDS_PntHasher.cdl create mode 100644 src/SMDS/SMDS_PntHasher.cxx create mode 100644 src/SMDS/SMDS_PntHasher.hxx create mode 100644 src/SMDS/SMDS_PntHasher.ixx create mode 100644 src/SMDS/SMDS_PntHasher.jxx create mode 100644 src/SMDS/SMDS_PntHasher.lxx create mode 100644 src/SMDS/SMDS_Position.cdl create mode 100644 src/SMDS/SMDS_Position.cxx create mode 100644 src/SMDS/SMDS_Position.hxx create mode 100644 src/SMDS/SMDS_Position.ixx create mode 100644 src/SMDS/SMDS_Position.jxx create mode 100644 src/SMDS/SMDS_Position.lxx create mode 100644 src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx create mode 100644 src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_SequenceOfMesh.hxx create mode 100644 src/SMDS/SMDS_SequenceOfMesh_0.cxx create mode 100644 src/SMDS/SMDS_SpacePosition.cdl create mode 100644 src/SMDS/SMDS_SpacePosition.cxx create mode 100644 src/SMDS/SMDS_SpacePosition.hxx create mode 100644 src/SMDS/SMDS_SpacePosition.ixx create mode 100644 src/SMDS/SMDS_SpacePosition.jxx create mode 100644 src/SMDS/SMDS_SpacePosition.lxx create mode 100644 src/SMDS/SMDS_StdMapNode.gxx create mode 100644 src/SMDS/SMDS_StdMapNode.lxx create mode 100644 src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx create mode 100644 src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx create mode 100644 src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx create mode 100644 src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx create mode 100644 src/SMDS/SMDS_TypeOfPosition.hxx create mode 100644 src/SMDS/SMDS_VertexPosition.cdl create mode 100644 src/SMDS/SMDS_VertexPosition.cxx create mode 100644 src/SMDS/SMDS_VertexPosition.hxx create mode 100644 src/SMDS/SMDS_VertexPosition.ixx create mode 100644 src/SMDS/SMDS_VertexPosition.jxx diff --git a/src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx b/src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx new file mode 100644 index 000000000..25ec73d96 --- /dev/null +++ b/src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDSControl_BoundaryEdges_HeaderFile +#define _Handle_SMDSControl_BoundaryEdges_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile +#include "Handle_SMDSControl_MeshBoundary.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDSControl_MeshBoundary); +class SMDSControl_BoundaryEdges; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryEdges); + +class Handle(SMDSControl_BoundaryEdges) : public Handle(SMDSControl_MeshBoundary) { + 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); +// } + Handle(SMDSControl_BoundaryEdges)():Handle(SMDSControl_MeshBoundary)() {} + Handle(SMDSControl_BoundaryEdges)(const Handle(SMDSControl_BoundaryEdges)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle) + { + } + + Handle(SMDSControl_BoundaryEdges)(const SMDSControl_BoundaryEdges* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem) + { + } + + Handle(SMDSControl_BoundaryEdges)& operator=(const Handle(SMDSControl_BoundaryEdges)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDSControl_BoundaryEdges)& operator=(const SMDSControl_BoundaryEdges* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDSControl_BoundaryEdges* operator->() + { + return (SMDSControl_BoundaryEdges *)ControlAccess(); + } + + SMDSControl_BoundaryEdges* operator->() const + { + return (SMDSControl_BoundaryEdges *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDSControl_BoundaryEdges)(); + + Standard_EXPORT static const Handle(SMDSControl_BoundaryEdges) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx b/src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx new file mode 100644 index 000000000..77d757fb4 --- /dev/null +++ b/src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDSControl_BoundaryFaces_HeaderFile +#define _Handle_SMDSControl_BoundaryFaces_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile +#include "Handle_SMDSControl_MeshBoundary.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDSControl_MeshBoundary); +class SMDSControl_BoundaryFaces; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryFaces); + +class Handle(SMDSControl_BoundaryFaces) : public Handle(SMDSControl_MeshBoundary) { + 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); +// } + Handle(SMDSControl_BoundaryFaces)():Handle(SMDSControl_MeshBoundary)() {} + Handle(SMDSControl_BoundaryFaces)(const Handle(SMDSControl_BoundaryFaces)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle) + { + } + + Handle(SMDSControl_BoundaryFaces)(const SMDSControl_BoundaryFaces* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem) + { + } + + Handle(SMDSControl_BoundaryFaces)& operator=(const Handle(SMDSControl_BoundaryFaces)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDSControl_BoundaryFaces)& operator=(const SMDSControl_BoundaryFaces* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDSControl_BoundaryFaces* operator->() + { + return (SMDSControl_BoundaryFaces *)ControlAccess(); + } + + SMDSControl_BoundaryFaces* operator->() const + { + return (SMDSControl_BoundaryFaces *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDSControl_BoundaryFaces)(); + + Standard_EXPORT static const Handle(SMDSControl_BoundaryFaces) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDSControl_MeshBoundary.hxx b/src/SMDS/Handle_SMDSControl_MeshBoundary.hxx new file mode 100644 index 000000000..ecff553bc --- /dev/null +++ b/src/SMDS/Handle_SMDSControl_MeshBoundary.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile +#define _Handle_SMDSControl_MeshBoundary_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_MMgt_TShared_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(MMgt_TShared); +class SMDSControl_MeshBoundary; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_MeshBoundary); + +class Handle(SMDSControl_MeshBoundary) : public Handle(MMgt_TShared) { + 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); +// } + Handle(SMDSControl_MeshBoundary)():Handle(MMgt_TShared)() {} + Handle(SMDSControl_MeshBoundary)(const Handle(SMDSControl_MeshBoundary)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMDSControl_MeshBoundary)(const SMDSControl_MeshBoundary* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMDSControl_MeshBoundary)& operator=(const Handle(SMDSControl_MeshBoundary)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDSControl_MeshBoundary)& operator=(const SMDSControl_MeshBoundary* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDSControl_MeshBoundary* operator->() + { + return (SMDSControl_MeshBoundary *)ControlAccess(); + } + + SMDSControl_MeshBoundary* operator->() const + { + return (SMDSControl_MeshBoundary *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDSControl_MeshBoundary)(); + + Standard_EXPORT static const Handle(SMDSControl_MeshBoundary) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx b/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx new file mode 100644 index 000000000..473059607 --- /dev/null +++ b/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#define _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement); + +class Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)():Handle(TCollection_MapNode)() {} + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->() + { + return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess(); + } + + SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->() const + { + return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(); + + Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx b/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx new file mode 100644 index 000000000..3a622987a --- /dev/null +++ b/src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#define _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_DataMapNodeOfDataMapOfPntInteger; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger); + +class Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)():Handle(TCollection_MapNode)() {} + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_DataMapNodeOfDataMapOfPntInteger* operator->() + { + return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess(); + } + + SMDS_DataMapNodeOfDataMapOfPntInteger* operator->() const + { + return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(); + + Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_EdgePosition.hxx b/src/SMDS/Handle_SMDS_EdgePosition.hxx new file mode 100644 index 000000000..684be8bd9 --- /dev/null +++ b/src/SMDS/Handle_SMDS_EdgePosition.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_EdgePosition_HeaderFile +#define _Handle_SMDS_EdgePosition_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_Position_HeaderFile +#include "Handle_SMDS_Position.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_Position); +class SMDS_EdgePosition; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_EdgePosition); + +class Handle(SMDS_EdgePosition) : public Handle(SMDS_Position) { + 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); +// } + Handle(SMDS_EdgePosition)():Handle(SMDS_Position)() {} + Handle(SMDS_EdgePosition)(const Handle(SMDS_EdgePosition)& aHandle) : Handle(SMDS_Position)(aHandle) + { + } + + Handle(SMDS_EdgePosition)(const SMDS_EdgePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem) + { + } + + Handle(SMDS_EdgePosition)& operator=(const Handle(SMDS_EdgePosition)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_EdgePosition)& operator=(const SMDS_EdgePosition* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_EdgePosition* operator->() + { + return (SMDS_EdgePosition *)ControlAccess(); + } + + SMDS_EdgePosition* operator->() const + { + return (SMDS_EdgePosition *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_EdgePosition)(); + + Standard_EXPORT static const Handle(SMDS_EdgePosition) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_FacePosition.hxx b/src/SMDS/Handle_SMDS_FacePosition.hxx new file mode 100644 index 000000000..7c30be2a6 --- /dev/null +++ b/src/SMDS/Handle_SMDS_FacePosition.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_FacePosition_HeaderFile +#define _Handle_SMDS_FacePosition_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_Position_HeaderFile +#include "Handle_SMDS_Position.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_Position); +class SMDS_FacePosition; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_FacePosition); + +class Handle(SMDS_FacePosition) : public Handle(SMDS_Position) { + 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); +// } + Handle(SMDS_FacePosition)():Handle(SMDS_Position)() {} + Handle(SMDS_FacePosition)(const Handle(SMDS_FacePosition)& aHandle) : Handle(SMDS_Position)(aHandle) + { + } + + Handle(SMDS_FacePosition)(const SMDS_FacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem) + { + } + + Handle(SMDS_FacePosition)& operator=(const Handle(SMDS_FacePosition)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_FacePosition)& operator=(const SMDS_FacePosition* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_FacePosition* operator->() + { + return (SMDS_FacePosition *)ControlAccess(); + } + + SMDS_FacePosition* operator->() const + { + return (SMDS_FacePosition *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_FacePosition)(); + + Standard_EXPORT static const Handle(SMDS_FacePosition) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx b/src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx new file mode 100644 index 000000000..39ce54f19 --- /dev/null +++ b/src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_HSequenceOfMesh_HeaderFile +#define _Handle_SMDS_HSequenceOfMesh_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_MMgt_TShared_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(MMgt_TShared); +class SMDS_HSequenceOfMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_HSequenceOfMesh); + +class Handle(SMDS_HSequenceOfMesh) : public Handle(MMgt_TShared) { + 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); +// } + Handle(SMDS_HSequenceOfMesh)():Handle(MMgt_TShared)() {} + Handle(SMDS_HSequenceOfMesh)(const Handle(SMDS_HSequenceOfMesh)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMDS_HSequenceOfMesh)(const SMDS_HSequenceOfMesh* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMDS_HSequenceOfMesh)& operator=(const Handle(SMDS_HSequenceOfMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_HSequenceOfMesh)& operator=(const SMDS_HSequenceOfMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_HSequenceOfMesh* operator->() + { + return (SMDS_HSequenceOfMesh *)ControlAccess(); + } + + SMDS_HSequenceOfMesh* operator->() const + { + return (SMDS_HSequenceOfMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_HSequenceOfMesh)(); + + Standard_EXPORT static const Handle(SMDS_HSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx b/src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx new file mode 100644 index 000000000..a92eb7230 --- /dev/null +++ b/src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile +#define _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include "Handle_TCollection_MapNode.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_ListNodeOfListOfMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMesh); + +class Handle(SMDS_ListNodeOfListOfMesh) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_ListNodeOfListOfMesh)():Handle(TCollection_MapNode)() {} + Handle(SMDS_ListNodeOfListOfMesh)(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_ListNodeOfListOfMesh)(const SMDS_ListNodeOfListOfMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_ListNodeOfListOfMesh)& operator=(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_ListNodeOfListOfMesh)& operator=(const SMDS_ListNodeOfListOfMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_ListNodeOfListOfMesh* operator->() + { + return (SMDS_ListNodeOfListOfMesh *)ControlAccess(); + } + + SMDS_ListNodeOfListOfMesh* operator->() const + { + return (SMDS_ListNodeOfListOfMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMesh)(); + + Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx b/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx new file mode 100644 index 000000000..2420cfabc --- /dev/null +++ b/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile +#define _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_ListNodeOfListOfMeshElement; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement); + +class Handle(SMDS_ListNodeOfListOfMeshElement) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_ListNodeOfListOfMeshElement)():Handle(TCollection_MapNode)() {} + Handle(SMDS_ListNodeOfListOfMeshElement)(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_ListNodeOfListOfMeshElement)(const SMDS_ListNodeOfListOfMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const SMDS_ListNodeOfListOfMeshElement* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_ListNodeOfListOfMeshElement* operator->() + { + return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess(); + } + + SMDS_ListNodeOfListOfMeshElement* operator->() const + { + return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshElement)(); + + Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshElement) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx b/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx new file mode 100644 index 000000000..8419da0ff --- /dev/null +++ b/src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#define _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_ListNodeOfListOfMeshGroup; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup); + +class Handle(SMDS_ListNodeOfListOfMeshGroup) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_ListNodeOfListOfMeshGroup)():Handle(TCollection_MapNode)() {} + Handle(SMDS_ListNodeOfListOfMeshGroup)(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_ListNodeOfListOfMeshGroup)(const SMDS_ListNodeOfListOfMeshGroup* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const SMDS_ListNodeOfListOfMeshGroup* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_ListNodeOfListOfMeshGroup* operator->() + { + return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess(); + } + + SMDS_ListNodeOfListOfMeshGroup* operator->() const + { + return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshGroup)(); + + Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshGroup) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_Mesh.hxx b/src/SMDS/Handle_SMDS_Mesh.hxx new file mode 100644 index 000000000..cb78cd2a3 --- /dev/null +++ b/src/SMDS/Handle_SMDS_Mesh.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#define _Handle_SMDS_Mesh_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#include "Handle_SMDS_MeshObject.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshObject); +class SMDS_Mesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Mesh); + +class Handle(SMDS_Mesh) : public Handle(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); +// } + Handle(SMDS_Mesh)():Handle(SMDS_MeshObject)() {} + Handle(SMDS_Mesh)(const Handle(SMDS_Mesh)& aHandle) : Handle(SMDS_MeshObject)(aHandle) + { + } + + Handle(SMDS_Mesh)(const SMDS_Mesh* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem) + { + } + + Handle(SMDS_Mesh)& operator=(const Handle(SMDS_Mesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_Mesh)& operator=(const SMDS_Mesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_Mesh* operator->() + { + return (SMDS_Mesh *)ControlAccess(); + } + + SMDS_Mesh* operator->() const + { + return (SMDS_Mesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_Mesh)(); + + Standard_EXPORT static const Handle(SMDS_Mesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshEdge.hxx b/src/SMDS/Handle_SMDS_MeshEdge.hxx new file mode 100644 index 000000000..860568447 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshEdge.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshEdge_HeaderFile +#define _Handle_SMDS_MeshEdge_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshElement); +class SMDS_MeshEdge; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshEdge); + +class Handle(SMDS_MeshEdge) : public Handle(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); +// } + Handle(SMDS_MeshEdge)():Handle(SMDS_MeshElement)() {} + Handle(SMDS_MeshEdge)(const Handle(SMDS_MeshEdge)& aHandle) : Handle(SMDS_MeshElement)(aHandle) + { + } + + Handle(SMDS_MeshEdge)(const SMDS_MeshEdge* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem) + { + } + + Handle(SMDS_MeshEdge)& operator=(const Handle(SMDS_MeshEdge)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshEdge)& operator=(const SMDS_MeshEdge* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshEdge* operator->() + { + return (SMDS_MeshEdge *)ControlAccess(); + } + + SMDS_MeshEdge* operator->() const + { + return (SMDS_MeshEdge *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshEdge)(); + + Standard_EXPORT static const Handle(SMDS_MeshEdge) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshElement.hxx b/src/SMDS/Handle_SMDS_MeshElement.hxx new file mode 100644 index 000000000..f5108cf06 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshElement.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#define _Handle_SMDS_MeshElement_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#include "Handle_SMDS_MeshObject.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshObject); +class SMDS_MeshElement; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElement); + +class Handle(SMDS_MeshElement) : public Handle(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); +// } + Handle(SMDS_MeshElement)():Handle(SMDS_MeshObject)() {} + Handle(SMDS_MeshElement)(const Handle(SMDS_MeshElement)& aHandle) : Handle(SMDS_MeshObject)(aHandle) + { + } + + Handle(SMDS_MeshElement)(const SMDS_MeshElement* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem) + { + } + + Handle(SMDS_MeshElement)& operator=(const Handle(SMDS_MeshElement)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshElement)& operator=(const SMDS_MeshElement* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshElement* operator->() + { + return (SMDS_MeshElement *)ControlAccess(); + } + + SMDS_MeshElement* operator->() const + { + return (SMDS_MeshElement *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshElement)(); + + Standard_EXPORT static const Handle(SMDS_MeshElement) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx b/src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx new file mode 100644 index 000000000..d82a7bbdf --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile +#define _Handle_SMDS_MeshElementIDFactory_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile +#include "Handle_SMDS_MeshIDFactory.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshIDFactory); +class SMDS_MeshElementIDFactory; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElementIDFactory); + +class Handle(SMDS_MeshElementIDFactory) : public Handle(SMDS_MeshIDFactory) { + 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); +// } + Handle(SMDS_MeshElementIDFactory)():Handle(SMDS_MeshIDFactory)() {} + Handle(SMDS_MeshElementIDFactory)(const Handle(SMDS_MeshElementIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle) + { + } + + Handle(SMDS_MeshElementIDFactory)(const SMDS_MeshElementIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem) + { + } + + Handle(SMDS_MeshElementIDFactory)& operator=(const Handle(SMDS_MeshElementIDFactory)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshElementIDFactory)& operator=(const SMDS_MeshElementIDFactory* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshElementIDFactory* operator->() + { + return (SMDS_MeshElementIDFactory *)ControlAccess(); + } + + SMDS_MeshElementIDFactory* operator->() const + { + return (SMDS_MeshElementIDFactory *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshElementIDFactory)(); + + Standard_EXPORT static const Handle(SMDS_MeshElementIDFactory) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshFace.hxx b/src/SMDS/Handle_SMDS_MeshFace.hxx new file mode 100644 index 000000000..5e5a19002 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshFace.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshFace_HeaderFile +#define _Handle_SMDS_MeshFace_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshElement); +class SMDS_MeshFace; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshFace); + +class Handle(SMDS_MeshFace) : public Handle(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); +// } + Handle(SMDS_MeshFace)():Handle(SMDS_MeshElement)() {} + Handle(SMDS_MeshFace)(const Handle(SMDS_MeshFace)& aHandle) : Handle(SMDS_MeshElement)(aHandle) + { + } + + Handle(SMDS_MeshFace)(const SMDS_MeshFace* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem) + { + } + + Handle(SMDS_MeshFace)& operator=(const Handle(SMDS_MeshFace)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshFace)& operator=(const SMDS_MeshFace* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshFace* operator->() + { + return (SMDS_MeshFace *)ControlAccess(); + } + + SMDS_MeshFace* operator->() const + { + return (SMDS_MeshFace *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshFace)(); + + Standard_EXPORT static const Handle(SMDS_MeshFace) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshGroup.hxx b/src/SMDS/Handle_SMDS_MeshGroup.hxx new file mode 100644 index 000000000..46b9d1de3 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshGroup.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#define _Handle_SMDS_MeshGroup_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#include "Handle_SMDS_MeshObject.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshObject); +class SMDS_MeshGroup; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshGroup); + +class Handle(SMDS_MeshGroup) : public Handle(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); +// } + Handle(SMDS_MeshGroup)():Handle(SMDS_MeshObject)() {} + Handle(SMDS_MeshGroup)(const Handle(SMDS_MeshGroup)& aHandle) : Handle(SMDS_MeshObject)(aHandle) + { + } + + Handle(SMDS_MeshGroup)(const SMDS_MeshGroup* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem) + { + } + + Handle(SMDS_MeshGroup)& operator=(const Handle(SMDS_MeshGroup)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshGroup)& operator=(const SMDS_MeshGroup* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshGroup* operator->() + { + return (SMDS_MeshGroup *)ControlAccess(); + } + + SMDS_MeshGroup* operator->() const + { + return (SMDS_MeshGroup *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshGroup)(); + + Standard_EXPORT static const Handle(SMDS_MeshGroup) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshHexahedron.hxx b/src/SMDS/Handle_SMDS_MeshHexahedron.hxx new file mode 100644 index 000000000..3ce4ddb31 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshHexahedron.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshHexahedron_HeaderFile +#define _Handle_SMDS_MeshHexahedron_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#include "Handle_SMDS_MeshVolume.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshVolume); +class SMDS_MeshHexahedron; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshHexahedron); + +class Handle(SMDS_MeshHexahedron) : public Handle(SMDS_MeshVolume) { + 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); +// } + Handle(SMDS_MeshHexahedron)():Handle(SMDS_MeshVolume)() {} + Handle(SMDS_MeshHexahedron)(const Handle(SMDS_MeshHexahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle) + { + } + + Handle(SMDS_MeshHexahedron)(const SMDS_MeshHexahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem) + { + } + + Handle(SMDS_MeshHexahedron)& operator=(const Handle(SMDS_MeshHexahedron)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshHexahedron)& operator=(const SMDS_MeshHexahedron* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshHexahedron* operator->() + { + return (SMDS_MeshHexahedron *)ControlAccess(); + } + + SMDS_MeshHexahedron* operator->() const + { + return (SMDS_MeshHexahedron *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshHexahedron)(); + + Standard_EXPORT static const Handle(SMDS_MeshHexahedron) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshIDFactory.hxx b/src/SMDS/Handle_SMDS_MeshIDFactory.hxx new file mode 100644 index 000000000..9773a37d5 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshIDFactory.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile +#define _Handle_SMDS_MeshIDFactory_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#include "Handle_SMDS_MeshObject.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshObject); +class SMDS_MeshIDFactory; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshIDFactory); + +class Handle(SMDS_MeshIDFactory) : public Handle(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); +// } + Handle(SMDS_MeshIDFactory)():Handle(SMDS_MeshObject)() {} + Handle(SMDS_MeshIDFactory)(const Handle(SMDS_MeshIDFactory)& aHandle) : Handle(SMDS_MeshObject)(aHandle) + { + } + + Handle(SMDS_MeshIDFactory)(const SMDS_MeshIDFactory* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem) + { + } + + Handle(SMDS_MeshIDFactory)& operator=(const Handle(SMDS_MeshIDFactory)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshIDFactory)& operator=(const SMDS_MeshIDFactory* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshIDFactory* operator->() + { + return (SMDS_MeshIDFactory *)ControlAccess(); + } + + SMDS_MeshIDFactory* operator->() const + { + return (SMDS_MeshIDFactory *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshIDFactory)(); + + Standard_EXPORT static const Handle(SMDS_MeshIDFactory) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshNode.hxx b/src/SMDS/Handle_SMDS_MeshNode.hxx new file mode 100644 index 000000000..0533398d1 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshNode.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshNode_HeaderFile +#define _Handle_SMDS_MeshNode_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshElement); +class SMDS_MeshNode; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNode); + +class Handle(SMDS_MeshNode) : public Handle(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); +// } + Handle(SMDS_MeshNode)():Handle(SMDS_MeshElement)() {} + Handle(SMDS_MeshNode)(const Handle(SMDS_MeshNode)& aHandle) : Handle(SMDS_MeshElement)(aHandle) + { + } + + Handle(SMDS_MeshNode)(const SMDS_MeshNode* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem) + { + } + + Handle(SMDS_MeshNode)& operator=(const Handle(SMDS_MeshNode)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshNode)& operator=(const SMDS_MeshNode* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshNode* operator->() + { + return (SMDS_MeshNode *)ControlAccess(); + } + + SMDS_MeshNode* operator->() const + { + return (SMDS_MeshNode *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshNode)(); + + Standard_EXPORT static const Handle(SMDS_MeshNode) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx b/src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx new file mode 100644 index 000000000..268ae5eb0 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile +#define _Handle_SMDS_MeshNodeIDFactory_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile +#include "Handle_SMDS_MeshIDFactory.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshIDFactory); +class SMDS_MeshNodeIDFactory; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNodeIDFactory); + +class Handle(SMDS_MeshNodeIDFactory) : public Handle(SMDS_MeshIDFactory) { + 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); +// } + Handle(SMDS_MeshNodeIDFactory)():Handle(SMDS_MeshIDFactory)() {} + Handle(SMDS_MeshNodeIDFactory)(const Handle(SMDS_MeshNodeIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle) + { + } + + Handle(SMDS_MeshNodeIDFactory)(const SMDS_MeshNodeIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem) + { + } + + Handle(SMDS_MeshNodeIDFactory)& operator=(const Handle(SMDS_MeshNodeIDFactory)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshNodeIDFactory)& operator=(const SMDS_MeshNodeIDFactory* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshNodeIDFactory* operator->() + { + return (SMDS_MeshNodeIDFactory *)ControlAccess(); + } + + SMDS_MeshNodeIDFactory* operator->() const + { + return (SMDS_MeshNodeIDFactory *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshNodeIDFactory)(); + + Standard_EXPORT static const Handle(SMDS_MeshNodeIDFactory) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshObject.hxx b/src/SMDS/Handle_SMDS_MeshObject.hxx new file mode 100644 index 000000000..84589e839 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshObject.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#define _Handle_SMDS_MeshObject_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_MMgt_TShared_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(MMgt_TShared); +class SMDS_MeshObject; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshObject); + +class Handle(SMDS_MeshObject) : public Handle(MMgt_TShared) { + 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); +// } + Handle(SMDS_MeshObject)():Handle(MMgt_TShared)() {} + Handle(SMDS_MeshObject)(const Handle(SMDS_MeshObject)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMDS_MeshObject)(const SMDS_MeshObject* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMDS_MeshObject)& operator=(const Handle(SMDS_MeshObject)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshObject)& operator=(const SMDS_MeshObject* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshObject* operator->() + { + return (SMDS_MeshObject *)ControlAccess(); + } + + SMDS_MeshObject* operator->() const + { + return (SMDS_MeshObject *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshObject)(); + + Standard_EXPORT static const Handle(SMDS_MeshObject) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshPrism.hxx b/src/SMDS/Handle_SMDS_MeshPrism.hxx new file mode 100644 index 000000000..9725c8db6 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshPrism.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshPrism_HeaderFile +#define _Handle_SMDS_MeshPrism_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#include "Handle_SMDS_MeshVolume.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshVolume); +class SMDS_MeshPrism; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPrism); + +class Handle(SMDS_MeshPrism) : public Handle(SMDS_MeshVolume) { + 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); +// } + Handle(SMDS_MeshPrism)():Handle(SMDS_MeshVolume)() {} + Handle(SMDS_MeshPrism)(const Handle(SMDS_MeshPrism)& aHandle) : Handle(SMDS_MeshVolume)(aHandle) + { + } + + Handle(SMDS_MeshPrism)(const SMDS_MeshPrism* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem) + { + } + + Handle(SMDS_MeshPrism)& operator=(const Handle(SMDS_MeshPrism)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshPrism)& operator=(const SMDS_MeshPrism* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshPrism* operator->() + { + return (SMDS_MeshPrism *)ControlAccess(); + } + + SMDS_MeshPrism* operator->() const + { + return (SMDS_MeshPrism *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshPrism)(); + + Standard_EXPORT static const Handle(SMDS_MeshPrism) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshPyramid.hxx b/src/SMDS/Handle_SMDS_MeshPyramid.hxx new file mode 100644 index 000000000..16b6bad9c --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshPyramid.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshPyramid_HeaderFile +#define _Handle_SMDS_MeshPyramid_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#include "Handle_SMDS_MeshVolume.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshVolume); +class SMDS_MeshPyramid; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPyramid); + +class Handle(SMDS_MeshPyramid) : public Handle(SMDS_MeshVolume) { + 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); +// } + Handle(SMDS_MeshPyramid)():Handle(SMDS_MeshVolume)() {} + Handle(SMDS_MeshPyramid)(const Handle(SMDS_MeshPyramid)& aHandle) : Handle(SMDS_MeshVolume)(aHandle) + { + } + + Handle(SMDS_MeshPyramid)(const SMDS_MeshPyramid* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem) + { + } + + Handle(SMDS_MeshPyramid)& operator=(const Handle(SMDS_MeshPyramid)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshPyramid)& operator=(const SMDS_MeshPyramid* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshPyramid* operator->() + { + return (SMDS_MeshPyramid *)ControlAccess(); + } + + SMDS_MeshPyramid* operator->() const + { + return (SMDS_MeshPyramid *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshPyramid)(); + + Standard_EXPORT static const Handle(SMDS_MeshPyramid) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshQuadrangle.hxx b/src/SMDS/Handle_SMDS_MeshQuadrangle.hxx new file mode 100644 index 000000000..9a79fff3e --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshQuadrangle.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshQuadrangle_HeaderFile +#define _Handle_SMDS_MeshQuadrangle_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshFace_HeaderFile +#include "Handle_SMDS_MeshFace.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshFace); +class SMDS_MeshQuadrangle; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshQuadrangle); + +class Handle(SMDS_MeshQuadrangle) : public Handle(SMDS_MeshFace) { + 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); +// } + Handle(SMDS_MeshQuadrangle)():Handle(SMDS_MeshFace)() {} + Handle(SMDS_MeshQuadrangle)(const Handle(SMDS_MeshQuadrangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle) + { + } + + Handle(SMDS_MeshQuadrangle)(const SMDS_MeshQuadrangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem) + { + } + + Handle(SMDS_MeshQuadrangle)& operator=(const Handle(SMDS_MeshQuadrangle)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshQuadrangle)& operator=(const SMDS_MeshQuadrangle* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshQuadrangle* operator->() + { + return (SMDS_MeshQuadrangle *)ControlAccess(); + } + + SMDS_MeshQuadrangle* operator->() const + { + return (SMDS_MeshQuadrangle *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshQuadrangle)(); + + Standard_EXPORT static const Handle(SMDS_MeshQuadrangle) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshTetrahedron.hxx b/src/SMDS/Handle_SMDS_MeshTetrahedron.hxx new file mode 100644 index 000000000..d615d020c --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshTetrahedron.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshTetrahedron_HeaderFile +#define _Handle_SMDS_MeshTetrahedron_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#include "Handle_SMDS_MeshVolume.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshVolume); +class SMDS_MeshTetrahedron; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTetrahedron); + +class Handle(SMDS_MeshTetrahedron) : public Handle(SMDS_MeshVolume) { + 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); +// } + Handle(SMDS_MeshTetrahedron)():Handle(SMDS_MeshVolume)() {} + Handle(SMDS_MeshTetrahedron)(const Handle(SMDS_MeshTetrahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle) + { + } + + Handle(SMDS_MeshTetrahedron)(const SMDS_MeshTetrahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem) + { + } + + Handle(SMDS_MeshTetrahedron)& operator=(const Handle(SMDS_MeshTetrahedron)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshTetrahedron)& operator=(const SMDS_MeshTetrahedron* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshTetrahedron* operator->() + { + return (SMDS_MeshTetrahedron *)ControlAccess(); + } + + SMDS_MeshTetrahedron* operator->() const + { + return (SMDS_MeshTetrahedron *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshTetrahedron)(); + + Standard_EXPORT static const Handle(SMDS_MeshTetrahedron) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshTriangle.hxx b/src/SMDS/Handle_SMDS_MeshTriangle.hxx new file mode 100644 index 000000000..6f7465b0a --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshTriangle.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshTriangle_HeaderFile +#define _Handle_SMDS_MeshTriangle_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshFace_HeaderFile +#include "Handle_SMDS_MeshFace.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshFace); +class SMDS_MeshTriangle; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTriangle); + +class Handle(SMDS_MeshTriangle) : public Handle(SMDS_MeshFace) { + 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); +// } + Handle(SMDS_MeshTriangle)():Handle(SMDS_MeshFace)() {} + Handle(SMDS_MeshTriangle)(const Handle(SMDS_MeshTriangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle) + { + } + + Handle(SMDS_MeshTriangle)(const SMDS_MeshTriangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem) + { + } + + Handle(SMDS_MeshTriangle)& operator=(const Handle(SMDS_MeshTriangle)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshTriangle)& operator=(const SMDS_MeshTriangle* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshTriangle* operator->() + { + return (SMDS_MeshTriangle *)ControlAccess(); + } + + SMDS_MeshTriangle* operator->() const + { + return (SMDS_MeshTriangle *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshTriangle)(); + + Standard_EXPORT static const Handle(SMDS_MeshTriangle) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_MeshVolume.hxx b/src/SMDS/Handle_SMDS_MeshVolume.hxx new file mode 100644 index 000000000..629f52ea7 --- /dev/null +++ b/src/SMDS/Handle_SMDS_MeshVolume.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#define _Handle_SMDS_MeshVolume_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_MeshElement); +class SMDS_MeshVolume; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshVolume); + +class Handle(SMDS_MeshVolume) : public Handle(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); +// } + Handle(SMDS_MeshVolume)():Handle(SMDS_MeshElement)() {} + Handle(SMDS_MeshVolume)(const Handle(SMDS_MeshVolume)& aHandle) : Handle(SMDS_MeshElement)(aHandle) + { + } + + Handle(SMDS_MeshVolume)(const SMDS_MeshVolume* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem) + { + } + + Handle(SMDS_MeshVolume)& operator=(const Handle(SMDS_MeshVolume)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_MeshVolume)& operator=(const SMDS_MeshVolume* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_MeshVolume* operator->() + { + return (SMDS_MeshVolume *)ControlAccess(); + } + + SMDS_MeshVolume* operator->() const + { + return (SMDS_MeshVolume *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_MeshVolume)(); + + Standard_EXPORT static const Handle(SMDS_MeshVolume) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_Position.hxx b/src/SMDS/Handle_SMDS_Position.hxx new file mode 100644 index 000000000..3d32a83cd --- /dev/null +++ b/src/SMDS/Handle_SMDS_Position.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_Position_HeaderFile +#define _Handle_SMDS_Position_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_MMgt_TShared_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(MMgt_TShared); +class SMDS_Position; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Position); + +class Handle(SMDS_Position) : public Handle(MMgt_TShared) { + 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); +// } + Handle(SMDS_Position)():Handle(MMgt_TShared)() {} + Handle(SMDS_Position)(const Handle(SMDS_Position)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMDS_Position)(const SMDS_Position* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMDS_Position)& operator=(const Handle(SMDS_Position)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_Position)& operator=(const SMDS_Position* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_Position* operator->() + { + return (SMDS_Position *)ControlAccess(); + } + + SMDS_Position* operator->() const + { + return (SMDS_Position *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_Position)(); + + Standard_EXPORT static const Handle(SMDS_Position) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx b/src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx new file mode 100644 index 000000000..406b5327a --- /dev/null +++ b/src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile +#define _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_SeqNode_HeaderFile +#include +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_SeqNode); +class SMDS_SequenceNodeOfSequenceOfMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh); + +class Handle(SMDS_SequenceNodeOfSequenceOfMesh) : public Handle(TCollection_SeqNode) { + 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); +// } + Handle(SMDS_SequenceNodeOfSequenceOfMesh)():Handle(TCollection_SeqNode)() {} + Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle) : Handle(TCollection_SeqNode)(aHandle) + { + } + + Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const SMDS_SequenceNodeOfSequenceOfMesh* anItem) : Handle(TCollection_SeqNode)((TCollection_SeqNode *)anItem) + { + } + + Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const SMDS_SequenceNodeOfSequenceOfMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_SequenceNodeOfSequenceOfMesh* operator->() + { + return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess(); + } + + SMDS_SequenceNodeOfSequenceOfMesh* operator->() const + { + return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_SequenceNodeOfSequenceOfMesh)(); + + Standard_EXPORT static const Handle(SMDS_SequenceNodeOfSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_SpacePosition.hxx b/src/SMDS/Handle_SMDS_SpacePosition.hxx new file mode 100644 index 000000000..33402f423 --- /dev/null +++ b/src/SMDS/Handle_SMDS_SpacePosition.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_SpacePosition_HeaderFile +#define _Handle_SMDS_SpacePosition_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_Position_HeaderFile +#include "Handle_SMDS_Position.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_Position); +class SMDS_SpacePosition; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SpacePosition); + +class Handle(SMDS_SpacePosition) : public Handle(SMDS_Position) { + 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); +// } + Handle(SMDS_SpacePosition)():Handle(SMDS_Position)() {} + Handle(SMDS_SpacePosition)(const Handle(SMDS_SpacePosition)& aHandle) : Handle(SMDS_Position)(aHandle) + { + } + + Handle(SMDS_SpacePosition)(const SMDS_SpacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem) + { + } + + Handle(SMDS_SpacePosition)& operator=(const Handle(SMDS_SpacePosition)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_SpacePosition)& operator=(const SMDS_SpacePosition* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_SpacePosition* operator->() + { + return (SMDS_SpacePosition *)ControlAccess(); + } + + SMDS_SpacePosition* operator->() const + { + return (SMDS_SpacePosition *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_SpacePosition)(); + + Standard_EXPORT static const Handle(SMDS_SpacePosition) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx b/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx new file mode 100644 index 000000000..1be9999d2 --- /dev/null +++ b/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile +#define _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include "Handle_TCollection_MapNode.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_StdMapNodeOfExtendedMap; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap); + +class Handle(SMDS_StdMapNodeOfExtendedMap) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_StdMapNodeOfExtendedMap)():Handle(TCollection_MapNode)() {} + Handle(SMDS_StdMapNodeOfExtendedMap)(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_StdMapNodeOfExtendedMap)(const SMDS_StdMapNodeOfExtendedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const SMDS_StdMapNodeOfExtendedMap* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_StdMapNodeOfExtendedMap* operator->() + { + return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess(); + } + + SMDS_StdMapNodeOfExtendedMap* operator->() const + { + return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedMap)(); + + Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedMap) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx b/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx new file mode 100644 index 000000000..647478a51 --- /dev/null +++ b/src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#define _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_TCollection_MapNode_HeaderFile +#include "Handle_TCollection_MapNode.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(TCollection_MapNode); +class SMDS_StdMapNodeOfExtendedOrientedMap; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap); + +class Handle(SMDS_StdMapNodeOfExtendedOrientedMap) : public Handle(TCollection_MapNode) { + 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); +// } + Handle(SMDS_StdMapNodeOfExtendedOrientedMap)():Handle(TCollection_MapNode)() {} + Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_StdMapNodeOfExtendedOrientedMap* operator->() + { + return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess(); + } + + SMDS_StdMapNodeOfExtendedOrientedMap* operator->() const + { + return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(); + + Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedOrientedMap) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Handle_SMDS_VertexPosition.hxx b/src/SMDS/Handle_SMDS_VertexPosition.hxx new file mode 100644 index 000000000..514193605 --- /dev/null +++ b/src/SMDS/Handle_SMDS_VertexPosition.hxx @@ -0,0 +1,89 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _Handle_SMDS_VertexPosition_HeaderFile +#define _Handle_SMDS_VertexPosition_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_Position_HeaderFile +#include "Handle_SMDS_Position.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_Position); +class SMDS_VertexPosition; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_VertexPosition); + +class Handle(SMDS_VertexPosition) : public Handle(SMDS_Position) { + 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); +// } + Handle(SMDS_VertexPosition)():Handle(SMDS_Position)() {} + Handle(SMDS_VertexPosition)(const Handle(SMDS_VertexPosition)& aHandle) : Handle(SMDS_Position)(aHandle) + { + } + + Handle(SMDS_VertexPosition)(const SMDS_VertexPosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem) + { + } + + Handle(SMDS_VertexPosition)& operator=(const Handle(SMDS_VertexPosition)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMDS_VertexPosition)& operator=(const SMDS_VertexPosition* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMDS_VertexPosition* operator->() + { + return (SMDS_VertexPosition *)ControlAccess(); + } + + SMDS_VertexPosition* operator->() const + { + return (SMDS_VertexPosition *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMDS_VertexPosition)(); + + Standard_EXPORT static const Handle(SMDS_VertexPosition) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMDS/Makefile.in b/src/SMDS/Makefile.in new file mode 100644 index 000000000..0ef49c55f --- /dev/null +++ b/src/SMDS/Makefile.in @@ -0,0 +1,263 @@ +# -* Makefile *- +# +# Author : Patrick GOLDBRONN (CEA) +# Date : 29/06/2001 +# + +# source path +top_srcdir=@top_srcdir@ +top_builddir=../.. +srcdir=@srcdir@ +VPATH=.:@srcdir@:@top_srcdir@/idl + + +@COMMENCE@ + +# Libraries targets + +LIB = libSMDS.la +LIB_SRC = SMDS_BasicMap.lxx \ + SMDS_BasicMapIterator.lxx \ + SMDS_EdgePosition.cxx \ + SMDS_EdgePosition.lxx \ + SMDS_FacePosition.cxx \ + SMDS_FacePosition.lxx \ + SMDS_Map.gxx \ + SMDS_MapHasher.gxx \ + SMDS_MapIterator.gxx \ + SMDS_MapOfMeshElement.cxx \ + SMDS_MapOfMeshElement.lxx \ + SMDS_MapOfMeshOrientedElement.cxx \ + SMDS_MapOfMeshOrientedElement.lxx \ + SMDS_Mesh.cxx \ + SMDS_Mesh.lxx \ + SMDS_MeshEdge.cxx \ + SMDS_MeshEdge.lxx \ + SMDS_MeshEdgesIterator.cxx \ + SMDS_MeshElement.cxx \ + SMDS_MeshElement.lxx \ + SMDS_MeshElementIDFactory.cxx \ + SMDS_MeshElementIDFactory.lxx \ + SMDS_MeshElementMapHasher.cxx \ + SMDS_MeshElementMapHasher.lxx \ + SMDS_MeshElementsIterator.cxx \ + SMDS_MeshElementsIterator.lxx \ + SMDS_MeshFace.cxx \ + SMDS_MeshFace.lxx \ + SMDS_MeshFacesIterator.cxx \ + SMDS_MeshHexahedron.cxx \ + SMDS_MeshHexahedron.lxx \ + SMDS_MeshIDFactory.cxx \ + SMDS_MeshIDFactory.lxx \ + SMDS_MeshNode.cxx \ + SMDS_MeshNode.lxx \ + SMDS_MeshNodeIDFactory.cxx \ + SMDS_MeshNodeIDFactory.lxx \ + SMDS_MeshNodesIterator.cxx \ + SMDS_MeshObject.cxx \ + SMDS_MeshOrientedElementMapHasher.cxx \ + SMDS_MeshOrientedElementMapHasher.lxx \ + SMDS_MeshPrism.cxx \ + SMDS_MeshPrism.lxx \ + SMDS_MeshPyramid.cxx \ + SMDS_MeshPyramid.lxx \ + SMDS_MeshQuadrangle.cxx \ + SMDS_MeshQuadrangle.lxx \ + SMDS_MeshTetrahedron.cxx \ + SMDS_MeshTetrahedron.lxx \ + SMDS_MeshTriangle.cxx \ + SMDS_MeshTriangle.lxx \ + SMDS_MeshVolume.cxx \ + SMDS_MeshVolume.lxx \ + SMDS_MeshVolumesIterator.cxx \ + SMDS_PntHasher.cxx \ + SMDS_PntHasher.lxx \ + SMDS_Position.cxx \ + SMDS_Position.lxx \ + SMDS_SpacePosition.cxx \ + SMDS_SpacePosition.lxx \ + SMDS_StdMapNode.gxx \ + SMDS_StdMapNode.lxx \ + SMDS_VertexPosition.cxx \ + SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx \ + SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx \ + SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx \ + SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx \ + SMDS_DataMapOfIntegerMeshElement_0.cxx \ + SMDS_DataMapOfPntInteger_0.cxx \ + SMDS_ExtendedMap_0.cxx \ + SMDS_ExtendedOrientedMap_0.cxx \ + SMDS_ListIteratorOfListOfMeshElement_0.cxx \ + SMDS_ListIteratorOfListOfMesh_0.cxx \ + SMDS_ListNodeOfListOfMeshElement_0.cxx \ + SMDS_ListNodeOfListOfMesh_0.cxx \ + SMDS_ListOfMeshElement_0.cxx \ + SMDS_ListOfMesh_0.cxx \ + SMDS_MapIteratorOfExtendedMap_0.cxx \ + SMDS_MapIteratorOfExtendedOrientedMap_0.cxx \ + SMDS_StdMapNodeOfExtendedMap_0.cxx \ + SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx \ + SMDSControl.cxx \ + SMDSControl_BoundaryFaces.cxx \ + SMDSControl_BoundaryEdges.cxx \ + SMDSControl_MeshBoundary.cxx \ + SMDS_ListIteratorOfListOfMeshGroup_0.cxx \ + SMDS_ListOfMeshGroup_0.cxx \ + SMDS_ListNodeOfListOfMeshGroup_0.cxx \ + SMDS_MeshGroup.cxx \ + SMDSEdit_Transform.cxx \ + SMDS_HSequenceOfMesh_0.cxx \ + SMDS_SequenceNodeOfSequenceOfMesh_0.cxx \ + SMDS_SequenceOfMesh_0.cxx + + +LIB_CLIENT_IDL = +LIB_SERVER_IDL = + +# Executables targets +BIN = +BIN_SRC = +BIN_CLIENT_IDL = +BIN_SERVER_IDL = + +# header files +EXPORT_HEADERS= Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx \ + Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx \ + Handle_SMDS_EdgePosition.hxx \ + Handle_SMDS_FacePosition.hxx \ + Handle_SMDS_ListNodeOfListOfMesh.hxx \ + Handle_SMDS_ListNodeOfListOfMeshElement.hxx \ + Handle_SMDS_Mesh.hxx \ + Handle_SMDS_MeshEdge.hxx \ + Handle_SMDS_MeshElement.hxx \ + Handle_SMDS_MeshElementIDFactory.hxx \ + Handle_SMDS_MeshFace.hxx \ + Handle_SMDS_MeshHexahedron.hxx \ + Handle_SMDS_MeshIDFactory.hxx \ + Handle_SMDS_MeshNode.hxx \ + Handle_SMDS_MeshNodeIDFactory.hxx \ + Handle_SMDS_MeshObject.hxx \ + Handle_SMDS_MeshPrism.hxx \ + Handle_SMDS_MeshPyramid.hxx \ + Handle_SMDS_MeshQuadrangle.hxx \ + Handle_SMDS_MeshTetrahedron.hxx \ + Handle_SMDS_MeshTriangle.hxx \ + Handle_SMDS_MeshVolume.hxx \ + Handle_SMDS_Position.hxx \ + Handle_SMDS_SpacePosition.hxx \ + Handle_SMDS_StdMapNodeOfExtendedMap.hxx \ + Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx \ + Handle_SMDS_VertexPosition.hxx \ + SMDS_BasicMap.lxx \ + SMDS_BasicMapIterator.lxx \ + SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx \ + SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx \ + SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx \ + SMDS_DataMapNodeOfDataMapOfPntInteger.hxx \ + SMDS_DataMapOfIntegerMeshElement.hxx \ + SMDS_DataMapOfPntInteger.hxx \ + SMDS_EdgePosition.hxx \ + SMDS_EdgePosition.lxx \ + SMDS_ExtendedMap.hxx \ + SMDS_ExtendedOrientedMap.hxx \ + SMDS_FacePosition.hxx \ + SMDS_FacePosition.lxx \ + SMDS_ListIteratorOfListOfMesh.hxx \ + SMDS_ListIteratorOfListOfMeshElement.hxx \ + SMDS_ListNodeOfListOfMesh.hxx \ + SMDS_ListNodeOfListOfMeshElement.hxx \ + SMDS_ListOfMesh.hxx \ + SMDS_ListOfMeshElement.hxx \ + SMDS_MapIteratorOfExtendedMap.hxx \ + SMDS_MapIteratorOfExtendedOrientedMap.hxx \ + SMDS_MapNode.lxx \ + SMDS_MapOfMeshElement.hxx \ + SMDS_MapOfMeshElement.lxx \ + SMDS_MapOfMeshOrientedElement.hxx \ + SMDS_MapOfMeshOrientedElement.lxx \ + SMDS_Mesh.hxx \ + SMDS_Mesh.lxx \ + SMDS_MeshEdge.hxx \ + SMDS_MeshEdge.lxx \ + SMDS_MeshEdgesIterator.hxx \ + SMDS_MeshElement.hxx \ + SMDS_MeshElement.lxx \ + SMDS_MeshElementIDFactory.hxx \ + SMDS_MeshElementIDFactory.lxx \ + SMDS_MeshElementMapHasher.hxx \ + SMDS_MeshElementMapHasher.lxx \ + SMDS_MeshElementsIterator.hxx \ + SMDS_MeshElementsIterator.lxx \ + SMDS_MeshFace.hxx \ + SMDS_MeshFace.lxx \ + SMDS_MeshFacesIterator.hxx \ + SMDS_MeshHexahedron.hxx \ + SMDS_MeshHexahedron.lxx \ + SMDS_MeshIDFactory.hxx \ + SMDS_MeshIDFactory.lxx \ + SMDS_MeshNode.hxx \ + SMDS_MeshNode.lxx \ + SMDS_MeshNodeIDFactory.hxx \ + SMDS_MeshNodeIDFactory.lxx \ + SMDS_MeshNodesIterator.hxx \ + SMDS_MeshObject.hxx \ + SMDS_MeshOrientedElementMapHasher.hxx \ + SMDS_MeshOrientedElementMapHasher.lxx \ + SMDS_MeshPrism.hxx \ + SMDS_MeshPrism.lxx \ + SMDS_MeshPyramid.hxx \ + SMDS_MeshPyramid.lxx \ + SMDS_MeshQuadrangle.hxx \ + SMDS_MeshQuadrangle.lxx \ + SMDS_MeshTetrahedron.hxx \ + SMDS_MeshTetrahedron.lxx \ + SMDS_MeshTriangle.hxx \ + SMDS_MeshTriangle.lxx \ + SMDS_MeshVolume.hxx \ + SMDS_MeshVolume.lxx \ + SMDS_MeshVolumesIterator.hxx \ + SMDS_PntHasher.hxx \ + SMDS_PntHasher.lxx \ + SMDS_Position.hxx \ + SMDS_Position.lxx \ + SMDS_SpacePosition.hxx \ + SMDS_SpacePosition.lxx \ + SMDS_StdMapNode.lxx \ + SMDS_StdMapNodeOfExtendedMap.hxx \ + SMDS_StdMapNodeOfExtendedOrientedMap.hxx \ + SMDS_TypeOfPosition.hxx \ + SMDS_VertexPosition.hxx \ + Handle_SMDSControl_BoundaryEdges.hxx \ + SMDSEdit_Transform.hxx \ + Handle_SMDSControl_BoundaryFaces.hxx \ + SMDS_HSequenceOfMesh.hxx \ + Handle_SMDSControl_MeshBoundary.hxx \ + SMDS_ListIteratorOfListOfMeshGroup.hxx \ + Handle_SMDS_HSequenceOfMesh.hxx \ + SMDS_ListNodeOfListOfMeshGroup.hxx \ + Handle_SMDS_ListNodeOfListOfMeshGroup.hxx \ + SMDS_ListOfMeshGroup.hxx \ + Handle_SMDS_MeshGroup.hxx \ + SMDSAbs_ElementType.hxx \ + SMDSControl.hxx \ + SMDS_MeshGroup.hxx \ + SMDSControl_BoundaryEdges.hxx \ + SMDS_MeshGroup.lxx \ + SMDSControl_BoundaryFaces.hxx \ + SMDS_SequenceNodeOfSequenceOfMesh.hxx \ + SMDSControl_MeshBoundary.hxx \ + SMDS_SequenceOfMesh.hxx + + +# additionnal information to compil and link file +CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome +CXXFLAGS += $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome +LDFLAGS += $(OCC_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome + +# additional file to be cleaned +MOSTLYCLEAN = +CLEAN = +DISTCLEAN = + +@CONCLUDE@ + diff --git a/src/SMDS/SMDS.cdl b/src/SMDS/SMDS.cdl new file mode 100755 index 000000000..17b2407ae --- /dev/null +++ b/src/SMDS/SMDS.cdl @@ -0,0 +1,148 @@ +-- File: SMDS.cdl +-- Created: Wed Jan 23 11:53:00 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +package SMDS + + ---Purpose: This package provides the classes Mesh and MeshElement + -- + -- class Mesh: + -- - contains the main definition of the + -- mesh and have access to the MeshElement objects + -- + -- class MeshElement: + -- - defines the topological constituants of the Mesh (i.e + -- the Node, Edge, Face and Volume entities. + -- + -- These two last classes inherits from an abstract + -- class MeshObject. + +uses + SMDSAbs, + MMgt, + TCollection, + TColStd, + TColgp, + gp + + +is + + ---================================= + ---Category: enumerations + -- + ---================================= + + enumeration TypeOfPosition is + TOP_UNSPEC, + TOP_3DSPACE, + TOP_VERTEX, + TOP_EDGE, + TOP_FACE + end TypeOfPosition; + ---Purpose: defines the type of position of a node (see SMDS_Position) + -- TOP_UNSPEC : node position not specfied + -- TOP_3DSPACE : just a 3d point in space not related + -- to a CAD geometry + -- TOP_VERTEX : to characterize a node with a CAD vertex + -- TOP_EDGE : to characterize a node with a CAD edge + -- TOP_FACE : to characterize a node with a CAD face + + ---===================================== + ---Category: public classes + -- Mesh object related classes + ---===================================== + + class MeshOrientedElementMapHasher; + + class MeshElementMapHasher; + + class PntHasher; + + deferred class MeshObject; + + class Mesh; + + deferred class MeshElement; + class MeshNode; + class MeshEdge; + deferred class MeshFace; + class MeshTriangle; + class MeshQuadrangle; + deferred class MeshVolume; + class MeshTetrahedron; + class MeshPyramid; + class MeshPrism; + class MeshHexahedron; + + private deferred class MeshIDFactory; + private class MeshNodeIDFactory; + private class MeshElementIDFactory; + + deferred class MeshElementsIterator; + class MeshVolumesIterator; + class MeshFacesIterator; + class MeshEdgesIterator; + class MeshNodesIterator; + + + deferred class Position; + class SpacePosition; + class VertexPosition; + class EdgePosition; + class FacePosition; + + ---================================= + ---Category: public classes + -- Mesh group + ---================================= + + class MeshGroup; + + ---================================= + ---Category: public classes + -- Mesh collection classes + ---================================= + + class ExtendedMap + instantiates Map from TCollection (MeshElement from SMDS, + MeshElementMapHasher from SMDS); + + class ExtendedOrientedMap + instantiates Map from TCollection (MeshElement from SMDS, + MeshOrientedElementMapHasher from SMDS); + + class DataMapOfPntInteger + instantiates DataMap from TCollection (Pnt from gp, + Integer, + PntHasher from SMDS); + class DataMapOfIntegerMeshElement instantiates + DataMap from TCollection(Integer,MeshElement from SMDS, + MapIntegerHasher from TColStd); + + class ListOfMeshElement + instantiates List from TCollection (MeshElement from SMDS); + + class ListOfMesh + instantiates List from TCollection (Mesh from SMDS); + + class MapOfMeshElement; + + class MapOfMeshOrientedElement; + + class SequenceOfMesh + instantiates Sequence from TCollection (Mesh from SMDS); + + class HSequenceOfMesh + instantiates HSequence from TCollection (Mesh from SMDS, + SequenceOfMesh from SMDS); + + + class ListOfMeshGroup + instantiates List from TCollection(MeshGroup from SMDS); + +end SMDS; + diff --git a/src/SMDS/SMDSAbs.cdl b/src/SMDS/SMDSAbs.cdl new file mode 100644 index 000000000..49e3e11bb --- /dev/null +++ b/src/SMDS/SMDSAbs.cdl @@ -0,0 +1,24 @@ +-- File: SMDSAbs.cdl +-- Created: Mon Jun 3 11:57:33 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +package SMDSAbs + + ---Purpose: This package provides enumeration and resources + -- for SMDS mesh +is + + enumeration ElementType is + All, + Node, + Edge, + Face, + Volume + end ElementType; + ---Purpose: type of mesh elements + + +end SMDSAbs; diff --git a/src/SMDS/SMDSAbs_ElementType.hxx b/src/SMDS/SMDSAbs_ElementType.hxx new file mode 100644 index 000000000..4eb8161f0 --- /dev/null +++ b/src/SMDS/SMDSAbs_ElementType.hxx @@ -0,0 +1,31 @@ +// File generated by CPPExt (Enum) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDSAbs_ElementType_HeaderFile +#define _SMDSAbs_ElementType_HeaderFile + +enum SMDSAbs_ElementType { + SMDSAbs_All, +SMDSAbs_Node, +SMDSAbs_Edge, +SMDSAbs_Face, +SMDSAbs_Volume +}; + + +#ifndef _Standard_PrimitiveTypes_HeaderFile +#include +#endif + +#endif diff --git a/src/SMDS/SMDSControl.cdl b/src/SMDS/SMDSControl.cdl new file mode 100644 index 000000000..0ae8fc6db --- /dev/null +++ b/src/SMDS/SMDSControl.cdl @@ -0,0 +1,39 @@ +-- File: SMDSControl.cdl +-- Created: Fri Mar 15 11:05:03 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +package SMDSControl + + ---Purpose: provides classes for controlling the mesh + -- according to several criteria + +uses + + SMDS + +is + + ---Category: Classes + -- + + deferred class MeshBoundary; + class BoundaryEdges; + + class BoundaryFaces; + + ---Category: Package methods + -- + + ComputeNeighborFaces(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2: Integer) + returns Integer; + + ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3: Integer) + returns Integer; + + ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3,idnode4: Integer) + returns Integer; + +end SMDSControl; diff --git a/src/SMDS/SMDSControl.cxx b/src/SMDS/SMDSControl.cxx new file mode 100644 index 000000000..c115264f0 --- /dev/null +++ b/src/SMDS/SMDSControl.cxx @@ -0,0 +1,214 @@ +using namespace std; +// File: SMDSControl.cxx +// Created: Wed Feb 20 18:33:06 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDSControl.ixx" +#include "SMDS_Mesh.hxx" +#include "SMDS_MeshElement.hxx" +#include "SMDS_ListOfMeshElement.hxx" +#include "SMDS_ListIteratorOfListOfMeshElement.hxx" + +//======================================================================= +//function : ComputeNeighborFaces +//purpose : +//======================================================================= + +Standard_Integer SMDSControl::ComputeNeighborFaces(const Handle(SMDS_Mesh)& M, + const Handle(SMDS_MeshElement)& ME, + const Standard_Integer idnode1, + const Standard_Integer idnode2) +{ + const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1); + const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2); + const SMDS_ListOfMeshElement& lstInvFaces1 = node1->InverseElements(); + const SMDS_ListOfMeshElement& lstInvFaces2 = node2->InverseElements(); + Standard_Integer neighbor=0; + + SMDS_ListIteratorOfListOfMeshElement it1(lstInvFaces1); + for (;it1.More();it1.Next()) { + const Handle(SMDS_MeshElement)& face = it1.Value(); + if (M->Contains(face) && !face->IsSame(ME)) { + if (face->IsNodeInElement(idnode1) && face->IsNodeInElement(idnode2)) { + neighbor++; + } + } + } + + if (neighbor > 0) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it2(lstInvFaces2); + for (;it2.More();it2.Next()) { + const Handle(SMDS_MeshElement)& face = it2.Value(); + if (M->Contains(face) && !face->IsSame(ME)) { + if (face->IsNodeInElement(idnode1) && face->IsNodeInElement(idnode2)) { + neighbor++; + } + } + } + + return neighbor; +} + +//======================================================================= +//function : ComputeNeighborVolumes +//purpose : +//======================================================================= + +Standard_Integer SMDSControl::ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M, + const Handle(SMDS_MeshElement)& ME, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + + const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1); + const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2); + const Handle(SMDS_MeshElement)& node3 = M->FindNode(idnode3); + const SMDS_ListOfMeshElement& lstInvVol1 = node1->InverseElements(); + const SMDS_ListOfMeshElement& lstInvVol2 = node2->InverseElements(); + const SMDS_ListOfMeshElement& lstInvVol3 = node3->InverseElements(); + + Standard_Integer neighbor=0; + + SMDS_ListIteratorOfListOfMeshElement it1(lstInvVol1); + for (;it1.More() && neighbor == 0;it1.Next()) { + const Handle(SMDS_MeshElement)& vol = it1.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if (vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3)) { + neighbor++; + } + } + } + + if (neighbor > 0) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it2(lstInvVol2); + for (;it2.More() && neighbor == 0;it2.Next()) { + const Handle(SMDS_MeshElement)& vol = it2.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if (vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3)) { + neighbor++; + } + } + } + + if (neighbor > 0) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it3(lstInvVol3); + for (;it3.More() && neighbor == 0;it3.Next()) { + const Handle(SMDS_MeshElement)& vol = it3.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if (vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3)) { + neighbor++; + } + } + } + + return neighbor; + +} + +//======================================================================= +//function : ComputeNeighborVolumes +//purpose : +//======================================================================= + +Standard_Integer SMDSControl::ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M, + const Handle(SMDS_MeshElement)& ME, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + + const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1); + const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2); + const Handle(SMDS_MeshElement)& node3 = M->FindNode(idnode3); + const Handle(SMDS_MeshElement)& node4 = M->FindNode(idnode4); + const SMDS_ListOfMeshElement& lstInvVol1 = node1->InverseElements(); + const SMDS_ListOfMeshElement& lstInvVol2 = node2->InverseElements(); + const SMDS_ListOfMeshElement& lstInvVol3 = node3->InverseElements(); + const SMDS_ListOfMeshElement& lstInvVol4 = node4->InverseElements(); + Standard_Integer neighbor=0; + + SMDS_ListIteratorOfListOfMeshElement it1(lstInvVol1); + for (;it1.More();it1.Next()) { + const Handle(SMDS_MeshElement)& vol = it1.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if ( vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3) + && vol->IsNodeInElement(idnode4)) { + neighbor++; + } + } + } + + if (neighbor >= 2) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it2(lstInvVol2); + for (;it2.More();it2.Next()) { + const Handle(SMDS_MeshElement)& vol = it2.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if ( vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3) + && vol->IsNodeInElement(idnode4)) { + neighbor++; + } + } + } + + if (neighbor >= 2) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it3(lstInvVol3); + for (;it3.More();it3.Next()) { + const Handle(SMDS_MeshElement)& vol = it3.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if ( vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3) + && vol->IsNodeInElement(idnode4)) { + neighbor++; + } + } + } + + if (neighbor >= 2) { + return neighbor; + } + + SMDS_ListIteratorOfListOfMeshElement it4(lstInvVol4); + for (;it4.More();it4.Next()) { + const Handle(SMDS_MeshElement)& vol = it4.Value(); + if (M->Contains(vol) && !vol->IsSame(ME)) { + if ( vol->IsNodeInElement(idnode1) + && vol->IsNodeInElement(idnode2) + && vol->IsNodeInElement(idnode3) + && vol->IsNodeInElement(idnode4)) { + neighbor++; + } + } + } + + return neighbor; +} diff --git a/src/SMDS/SMDSControl.hxx b/src/SMDS/SMDSControl.hxx new file mode 100644 index 000000000..0ad0d408d --- /dev/null +++ b/src/SMDS/SMDSControl.hxx @@ -0,0 +1,104 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDSControl_HeaderFile +#define _SMDSControl_HeaderFile + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +class SMDS_Mesh; +class SMDS_MeshElement; +class SMDSControl_MeshBoundary; +class SMDSControl_BoundaryEdges; +class SMDSControl_BoundaryFaces; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDSControl { + +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 static Standard_Integer ComputeNeighborFaces(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2) ; +Standard_EXPORT static Standard_Integer ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; +Standard_EXPORT static Standard_Integer ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + +friend class SMDSControl_MeshBoundary; +friend class SMDSControl_BoundaryEdges; +friend class SMDSControl_BoundaryFaces; + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDSControl.ixx b/src/SMDS/SMDSControl.ixx new file mode 100644 index 000000000..fb49a669e --- /dev/null +++ b/src/SMDS/SMDSControl.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDSControl.jxx" + + + + diff --git a/src/SMDS/SMDSControl.jxx b/src/SMDS/SMDSControl.jxx new file mode 100644 index 000000000..e5f64bd1d --- /dev/null +++ b/src/SMDS/SMDSControl.jxx @@ -0,0 +1,9 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDSControl_HeaderFile +#include "SMDSControl.hxx" +#endif diff --git a/src/SMDS/SMDSControl_BoundaryEdges.cdl b/src/SMDS/SMDSControl_BoundaryEdges.cdl new file mode 100644 index 000000000..e20e8a7d0 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryEdges.cdl @@ -0,0 +1,29 @@ +-- File: SMDSControl_BoundaryEdges.cdl +-- Created: Wed Feb 20 19:17:20 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class BoundaryEdges from SMDSControl inherits MeshBoundary from SMDSControl + + ---Purpose: compute the boudary edges of a mesh that is the + -- edges that are shared by only one face the result + -- is a new mesh created in the same factory as the + -- original mesh that contains only edges + +uses + + Mesh from SMDS, + MapOfMeshElement from SMDS +is + + Create(M: Mesh from SMDS) returns BoundaryEdges from SMDSControl; + + Compute(me: mutable) is redefined virtual; + +fields + + myBoundaryEdges : MapOfMeshElement from SMDS; + +end BoundaryEdges; diff --git a/src/SMDS/SMDSControl_BoundaryEdges.cxx b/src/SMDS/SMDSControl_BoundaryEdges.cxx new file mode 100644 index 000000000..4215c0d8c --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryEdges.cxx @@ -0,0 +1,59 @@ +using namespace std; +// File: SMDSControl_BoundaryEdges.cxx +// Created: Wed Feb 20 19:28:42 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDSControl_BoundaryEdges.ixx" +#include "SMDSControl.hxx" + +#include "SMDS_MeshFacesIterator.hxx" +#include "SMDS_MeshElement.hxx" +#include "SMDS_MeshEdge.hxx" +#include "SMDS_MapIteratorOfExtendedMap.hxx" + +//======================================================================= +//function : SMDSControl_BoundaryEdges +//purpose : +//======================================================================= + +SMDSControl_BoundaryEdges::SMDSControl_BoundaryEdges(const Handle(SMDS_Mesh)& M) + :SMDSControl_MeshBoundary(M) +{ +} + +//======================================================================= +//function : Compute +//purpose : +//======================================================================= + +void SMDSControl_BoundaryEdges::Compute() +{ + Standard_Integer idnode1; + Standard_Integer idnode2; + Standard_Integer nbedg; + + myBoundaryMesh = myMesh->AddSubMesh(); + SMDS_MeshFacesIterator itface(myMesh); + + for (;itface.More();itface.Next()) { + Handle(SMDS_MeshElement) ME = itface.Value(); + + nbedg = ME->NbEdges(); + + for (Standard_Integer iedge=1; iedge<=nbedg; ++iedge) { + ME->GetEdgeDefinedByNodes(iedge,idnode1,idnode2); + Handle(SMDS_MeshElement) edge = new SMDS_MeshEdge(0,idnode1,idnode2); + if (!myBoundaryEdges.Add(edge)) + myBoundaryEdges.Remove(edge); + } + } + + SMDS_MapIteratorOfExtendedMap itbound(myBoundaryEdges); + + for (;itbound.More();itbound.Next()) { + const Handle(SMDS_MeshElement)& edge = itbound.Key(); + myBoundaryMesh->AddEdge(edge->GetConnection(1),edge->GetConnection(2)); + } +} diff --git a/src/SMDS/SMDSControl_BoundaryEdges.hxx b/src/SMDS/SMDSControl_BoundaryEdges.hxx new file mode 100644 index 000000000..415ebbfe9 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryEdges.hxx @@ -0,0 +1,104 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDSControl_BoundaryEdges_HeaderFile +#define _SMDSControl_BoundaryEdges_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDSControl_BoundaryEdges_HeaderFile +#include "Handle_SMDSControl_BoundaryEdges.hxx" +#endif + +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _SMDSControl_MeshBoundary_HeaderFile +#include "SMDSControl_MeshBoundary.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class SMDS_Mesh; + + +class SMDSControl_BoundaryEdges : public SMDSControl_MeshBoundary { + +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 SMDSControl_BoundaryEdges(const Handle(SMDS_Mesh)& M); +Standard_EXPORT virtual void Compute() ; +Standard_EXPORT ~SMDSControl_BoundaryEdges(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDSControl_BoundaryEdges_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 + // +SMDS_MapOfMeshElement myBoundaryEdges; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDSControl_BoundaryEdges.ixx b/src/SMDS/SMDSControl_BoundaryEdges.ixx new file mode 100644 index 000000000..3cfa7ae95 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryEdges.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDSControl_BoundaryEdges::~SMDSControl_BoundaryEdges() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDSControl_BoundaryEdges_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_BoundaryEdges", + sizeof(SMDSControl_BoundaryEdges), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDSControl_BoundaryEdges) Handle(SMDSControl_BoundaryEdges)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDSControl_BoundaryEdges) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_BoundaryEdges))) { + _anOtherObject = Handle(SMDSControl_BoundaryEdges)((Handle(SMDSControl_BoundaryEdges)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDSControl_BoundaryEdges::DynamicType() const +{ + return STANDARD_TYPE(SMDSControl_BoundaryEdges) ; +} +Standard_Boolean SMDSControl_BoundaryEdges::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDSControl_BoundaryEdges) == AType || SMDSControl_MeshBoundary::IsKind(AType)); +} +Handle_SMDSControl_BoundaryEdges::~Handle_SMDSControl_BoundaryEdges() {} + diff --git a/src/SMDS/SMDSControl_BoundaryEdges.jxx b/src/SMDS/SMDSControl_BoundaryEdges.jxx new file mode 100644 index 000000000..70afd8b2c --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryEdges.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDSControl_BoundaryEdges_HeaderFile +#include "SMDSControl_BoundaryEdges.hxx" +#endif diff --git a/src/SMDS/SMDSControl_BoundaryFaces.cdl b/src/SMDS/SMDSControl_BoundaryFaces.cdl new file mode 100644 index 000000000..04546dd92 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryFaces.cdl @@ -0,0 +1,31 @@ +-- File: SMDSControl_BoundaryFaces.cdl +-- Created: Tue Mar 12 23:31:59 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class BoundaryFaces from SMDSControl inherits MeshBoundary from SMDSControl + + ---Purpose: compute the boudary faces of a mesh that is the + -- faces that are shared by only one volume the result + -- is a new mesh created in the same factory as the + -- original mesh that contains only faces + +uses + + Mesh from SMDS, + MapOfMeshElement from SMDS + +is + + Create(M: Mesh from SMDS) returns BoundaryFaces from SMDSControl; + + Compute(me: mutable) is redefined virtual; + + +fields + + myBoundaryFaces : MapOfMeshElement from SMDS; + +end BoundaryFaces; diff --git a/src/SMDS/SMDSControl_BoundaryFaces.cxx b/src/SMDS/SMDSControl_BoundaryFaces.cxx new file mode 100644 index 000000000..398025bc3 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryFaces.cxx @@ -0,0 +1,82 @@ +using namespace std; +// File: SMDSControl_BoundaryFaces.cxx +// Created: Tue Mar 12 23:46:24 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDSControl_BoundaryFaces.ixx" +#include "SMDSControl.hxx" + +#include "SMDS_MeshVolumesIterator.hxx" +#include "SMDS_MeshElement.hxx" +#include "SMDS_MeshFace.hxx" +#include "SMDS_MeshTriangle.hxx" +#include "SMDS_MeshQuadrangle.hxx" +#include "SMDS_MapIteratorOfExtendedMap.hxx" + +//======================================================================= +//function : SMDSControl_BoundaryFaces +//purpose : +//======================================================================= + +SMDSControl_BoundaryFaces::SMDSControl_BoundaryFaces(const Handle(SMDS_Mesh)& M) + :SMDSControl_MeshBoundary(M) +{ +} + +//======================================================================= +//function : Compute +//purpose : +//======================================================================= + +void SMDSControl_BoundaryFaces::Compute() +{ + myBoundaryMesh = myMesh->AddSubMesh(); + SMDS_MeshVolumesIterator itvol(myMesh); + + Standard_Integer idnode[4]; // max number of nodes for a face + Standard_Integer nbnode; + + for (;itvol.More();itvol.Next()) { + Handle(SMDS_MeshElement) ME = itvol.Value(); + + + Standard_Integer nbfaces = ME->NbFaces(); + + for (Standard_Integer iface=1; iface<=nbfaces; ++iface) { + + ME->GetFaceDefinedByNodes(iface,idnode,nbnode); + // Triangle + if (nbnode == 3) { + Handle(SMDS_MeshElement) face = new SMDS_MeshTriangle(0,idnode[0],idnode[1],idnode[2]); + if (!myBoundaryFaces.Add(face)) + myBoundaryFaces.Remove(face); + + + } else { + // Quadrangle + + Handle(SMDS_MeshElement) face = new SMDS_MeshQuadrangle(0,idnode[0],idnode[1],idnode[2],idnode[3]); + if (!myBoundaryFaces.Add(face)) + myBoundaryFaces.Remove(face); + + } + } // end iface + + } // end itvol + + SMDS_MapIteratorOfExtendedMap itbound(myBoundaryFaces); + + for (;itbound.More();itbound.Next()) { + const Handle(SMDS_MeshElement)& face = itbound.Key(); + if (face->NbNodes() == 3) + myBoundaryMesh->AddFace(face->GetConnection(1),face->GetConnection(2),face->GetConnection(3)); + else + myBoundaryMesh->AddFace(face->GetConnection(1),face->GetConnection(2),face->GetConnection(3), + face->GetConnection(4)); + } + +} + + diff --git a/src/SMDS/SMDSControl_BoundaryFaces.hxx b/src/SMDS/SMDSControl_BoundaryFaces.hxx new file mode 100644 index 000000000..dac6b7f47 --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryFaces.hxx @@ -0,0 +1,104 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDSControl_BoundaryFaces_HeaderFile +#define _SMDSControl_BoundaryFaces_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDSControl_BoundaryFaces_HeaderFile +#include +#endif + +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _SMDSControl_MeshBoundary_HeaderFile +#include "SMDSControl_MeshBoundary.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class SMDS_Mesh; + + +class SMDSControl_BoundaryFaces : public SMDSControl_MeshBoundary { + +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 SMDSControl_BoundaryFaces(const Handle(SMDS_Mesh)& M); +Standard_EXPORT virtual void Compute() ; +Standard_EXPORT ~SMDSControl_BoundaryFaces(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDSControl_BoundaryFaces_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 + // +SMDS_MapOfMeshElement myBoundaryFaces; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDSControl_BoundaryFaces.ixx b/src/SMDS/SMDSControl_BoundaryFaces.ixx new file mode 100644 index 000000000..7f529568a --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryFaces.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDSControl_BoundaryFaces.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDSControl_BoundaryFaces::~SMDSControl_BoundaryFaces() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDSControl_BoundaryFaces_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_BoundaryFaces", + sizeof(SMDSControl_BoundaryFaces), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDSControl_BoundaryFaces) Handle(SMDSControl_BoundaryFaces)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDSControl_BoundaryFaces) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_BoundaryFaces))) { + _anOtherObject = Handle(SMDSControl_BoundaryFaces)((Handle(SMDSControl_BoundaryFaces)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDSControl_BoundaryFaces::DynamicType() const +{ + return STANDARD_TYPE(SMDSControl_BoundaryFaces) ; +} +Standard_Boolean SMDSControl_BoundaryFaces::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDSControl_BoundaryFaces) == AType || SMDSControl_MeshBoundary::IsKind(AType)); +} +Handle_SMDSControl_BoundaryFaces::~Handle_SMDSControl_BoundaryFaces() {} + diff --git a/src/SMDS/SMDSControl_BoundaryFaces.jxx b/src/SMDS/SMDSControl_BoundaryFaces.jxx new file mode 100644 index 000000000..6053a8fef --- /dev/null +++ b/src/SMDS/SMDSControl_BoundaryFaces.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDSControl_BoundaryFaces_HeaderFile +#include "SMDSControl_BoundaryFaces.hxx" +#endif diff --git a/src/SMDS/SMDSControl_MeshBoundary.cdl b/src/SMDS/SMDSControl_MeshBoundary.cdl new file mode 100644 index 000000000..17d83bf6d --- /dev/null +++ b/src/SMDS/SMDSControl_MeshBoundary.cdl @@ -0,0 +1,35 @@ +-- File: SMDSControl_MeshBoundary.cdl +-- Created: Tue Mar 12 23:36:11 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshBoundary from SMDSControl inherits TShared from MMgt + + ---Purpose: common interface for classes which extract + -- boundaries from a mesh + +uses + + Mesh from SMDS + +is + Initialize; + ---Purpose: Initialize an empty MeshBoundary + + + Initialize (M : Mesh from SMDS); + ---Purpose: Initialize a MeshBoundary. + + + Compute(me: mutable) is deferred; + + ResultMesh(me: mutable) returns Mesh from SMDS; + + +fields + myMesh : Mesh from SMDS is protected; + myBoundaryMesh : Mesh from SMDS is protected; + +end MeshBoundary; diff --git a/src/SMDS/SMDSControl_MeshBoundary.cxx b/src/SMDS/SMDSControl_MeshBoundary.cxx new file mode 100644 index 000000000..b18b00edc --- /dev/null +++ b/src/SMDS/SMDSControl_MeshBoundary.cxx @@ -0,0 +1,40 @@ +using namespace std; +// File: SMDSControl_MeshBoundary.cxx +// Created: Tue Mar 12 23:42:53 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDSControl_MeshBoundary.ixx" + +//======================================================================= +//function : SMDSControl_MeshBoundary +//purpose : +//======================================================================= + +SMDSControl_MeshBoundary::SMDSControl_MeshBoundary() +{ +} + +//======================================================================= +//function : SMDSControl_MeshBoundary +//purpose : +//======================================================================= + +SMDSControl_MeshBoundary::SMDSControl_MeshBoundary(const Handle(SMDS_Mesh)& M) + :myMesh(M) +{ +} + +//======================================================================= +//function : ResultMesh +//purpose : +//======================================================================= + +Handle(SMDS_Mesh) SMDSControl_MeshBoundary::ResultMesh() +{ + if (myBoundaryMesh.IsNull()) + Compute(); + return myBoundaryMesh; +} + diff --git a/src/SMDS/SMDSControl_MeshBoundary.hxx b/src/SMDS/SMDSControl_MeshBoundary.hxx new file mode 100644 index 000000000..ff1d222de --- /dev/null +++ b/src/SMDS/SMDSControl_MeshBoundary.hxx @@ -0,0 +1,104 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDSControl_MeshBoundary_HeaderFile +#define _SMDSControl_MeshBoundary_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile +#include "Handle_SMDSControl_MeshBoundary.hxx" +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +class SMDS_Mesh; + + +class SMDSControl_MeshBoundary : public MMgt_TShared { + +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 Compute() = 0; +Standard_EXPORT Handle_SMDS_Mesh ResultMesh() ; +Standard_EXPORT ~SMDSControl_MeshBoundary(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDSControl_MeshBoundary_Type_(); + Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; + Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; + +protected: + + // Methods PROTECTED + // +Standard_EXPORT SMDSControl_MeshBoundary(); +Standard_EXPORT SMDSControl_MeshBoundary(const Handle(SMDS_Mesh)& M); + + + // Fields PROTECTED + // +Handle_SMDS_Mesh myMesh; +Handle_SMDS_Mesh myBoundaryMesh; + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDSControl_MeshBoundary.ixx b/src/SMDS/SMDSControl_MeshBoundary.ixx new file mode 100644 index 000000000..eae31f949 --- /dev/null +++ b/src/SMDS/SMDSControl_MeshBoundary.ixx @@ -0,0 +1,69 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDSControl_MeshBoundary.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include "Standard_TypeMismatch.hxx" +#endif + +SMDSControl_MeshBoundary::~SMDSControl_MeshBoundary() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDSControl_MeshBoundary_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_MeshBoundary", + sizeof(SMDSControl_MeshBoundary), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDSControl_MeshBoundary) Handle(SMDSControl_MeshBoundary)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDSControl_MeshBoundary) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_MeshBoundary))) { + _anOtherObject = Handle(SMDSControl_MeshBoundary)((Handle(SMDSControl_MeshBoundary)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDSControl_MeshBoundary::DynamicType() const +{ + return STANDARD_TYPE(SMDSControl_MeshBoundary) ; +} +Standard_Boolean SMDSControl_MeshBoundary::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDSControl_MeshBoundary) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMDSControl_MeshBoundary::~Handle_SMDSControl_MeshBoundary() {} + diff --git a/src/SMDS/SMDSControl_MeshBoundary.jxx b/src/SMDS/SMDSControl_MeshBoundary.jxx new file mode 100644 index 000000000..1b0b42271 --- /dev/null +++ b/src/SMDS/SMDSControl_MeshBoundary.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDSControl_MeshBoundary_HeaderFile +#include "SMDSControl_MeshBoundary.hxx" +#endif diff --git a/src/SMDS/SMDSEdit.cdl b/src/SMDS/SMDSEdit.cdl new file mode 100644 index 000000000..6dae7d6cc --- /dev/null +++ b/src/SMDS/SMDSEdit.cdl @@ -0,0 +1,24 @@ +-- File: SMDSEdit.cdl +-- Created: Wed May 15 21:35:28 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +package SMDSEdit + + ---Level : Public. + -- All methods of all classes will be public. + + ---Purpose: This package provides tool classes to edit or modify + -- Meshes or MeshElements + -- + +uses + SMDS, + gp +is + class Transform; + ---Purpose: tool class to modify a Mesh or MeshElements by a Transformation + +end SMDSEdit; diff --git a/src/SMDS/SMDSEdit_Transform.cdl b/src/SMDS/SMDSEdit_Transform.cdl new file mode 100644 index 000000000..aaace08c0 --- /dev/null +++ b/src/SMDS/SMDSEdit_Transform.cdl @@ -0,0 +1,47 @@ +-- File: SMDSEdit_Transform.cdl +-- Created: Wed May 15 21:45:47 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class Transform from SMDSEdit + + ---Purpose: tool to modify a Mesh or MeshElements by applying + -- a transformation + +uses + Mesh from SMDS, + ListOfMeshElement from SMDS, + Trsf from gp + +is + Create (aMesh : Mesh from SMDS; aTrsf: Trsf from gp) + returns Transform from SMDSEdit; + ---Purpose: create a transform tool on a whole mesh + + Create (aMesh : Mesh from SMDS; aListOfME : ListOfMeshElement from SMDS; + aTrsf : Trsf from gp) + returns Transform from SMDSEdit; + ---Purpose: create a transform tool to be applied on a list of + -- meshelements from the mesh aMesh. MeshElements from the + -- list that do not belong to the mesh will not be treated + + Perform (me: in out); + ---Purpose: Perform the current transformation on the Mesh or on + -- the list of meshelements if it is not empty + + SetTrsf(me: in out; aTrsf: Trsf from gp); + ---Purpose: replace the field myTrsf by the one given in argument + -- This can be used to apply another transformation on a mesh + -- without creating another instance of SMDSEdit_Transform + + GetTrsf(me) returns Trsf from gp; + ---Purpose: returns the stored Trsf + + +fields + myMesh : Mesh from SMDS; + myTrsf : Trsf from gp; + myListOfME : ListOfMeshElement from SMDS; +end Transform; diff --git a/src/SMDS/SMDSEdit_Transform.cxx b/src/SMDS/SMDSEdit_Transform.cxx new file mode 100644 index 000000000..ca0f70f19 --- /dev/null +++ b/src/SMDS/SMDSEdit_Transform.cxx @@ -0,0 +1,100 @@ +using namespace std; +// File: SMDSEdit_Transform.cxx +// Created: Wed May 15 21:57:17 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDSEdit_Transform.ixx" +#include "SMDS_MeshNode.hxx" +#include "SMDS_MeshElement.hxx" +#include "SMDS_MeshNodesIterator.hxx" +#include "SMDS_ListIteratorOfListOfMeshElement.hxx" +#include "TColStd_MapOfInteger.hxx" + + +//======================================================================= +//function : SMDSEdit_Transform +//purpose : +//======================================================================= + +SMDSEdit_Transform::SMDSEdit_Transform(const Handle(SMDS_Mesh)& aMesh,const gp_Trsf& aTrsf) + :myMesh(aMesh),myTrsf(aTrsf) +{ +} + +//======================================================================= +//function : SMDSEdit_Transform +//purpose : +//======================================================================= + +SMDSEdit_Transform::SMDSEdit_Transform(const Handle(SMDS_Mesh)& aMesh, + const SMDS_ListOfMeshElement& aListOfME, + const gp_Trsf& aTrsf) + :myMesh(aMesh),myTrsf(aTrsf) +{ + myListOfME = aListOfME; +} + +//======================================================================= +//function : SetTrsf +//purpose : +//======================================================================= + +void SMDSEdit_Transform::SetTrsf(const gp_Trsf& aTrsf) +{ + myTrsf = aTrsf; +} + +//======================================================================= +//function : GetTrsf +//purpose : +//======================================================================= + +gp_Trsf SMDSEdit_Transform::GetTrsf() const +{ + return myTrsf; +} + +//======================================================================= +//function : Perform +//purpose : +//======================================================================= + +void SMDSEdit_Transform::Perform() +{ + if (myListOfME.IsEmpty()) { + // transform the whole mesh + SMDS_MeshNodesIterator itNodes(myMesh); + + for (;itNodes.More();itNodes.Next()) { + const Handle(SMDS_MeshElement)& elem = itNodes.Value(); + Handle(SMDS_MeshNode) node = *((Handle(SMDS_MeshNode)*)&elem); + + gp_Pnt P = node->Pnt(); + P.Transform(myTrsf); + node->SetPnt(P); + } + + } else { + TColStd_MapOfInteger mapnode; + Standard_Integer nbnodes,inode; + + SMDS_ListIteratorOfListOfMeshElement itME(myListOfME); + for (;itME.More();itME.Next()) { + const Handle(SMDS_MeshElement)& elem = itME.Value(); + nbnodes = elem->NbNodes(); + + for (inode = 1; inode <= nbnodes; ++inode) { + const Handle(SMDS_MeshNode)& node = myMesh->GetNode(inode,elem); + if (mapnode.Add(node->GetID())) { + gp_Pnt P = node->Pnt(); + P.Transform(myTrsf); + node->SetPnt(P); + } + } + + } + } +} + diff --git a/src/SMDS/SMDSEdit_Transform.hxx b/src/SMDS/SMDSEdit_Transform.hxx new file mode 100644 index 000000000..5c8663647 --- /dev/null +++ b/src/SMDS/SMDSEdit_Transform.hxx @@ -0,0 +1,104 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDSEdit_Transform_HeaderFile +#define _SMDSEdit_Transform_HeaderFile + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _gp_Trsf_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +class SMDS_Mesh; +class gp_Trsf; +class SMDS_ListOfMeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDSEdit_Transform { + +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 SMDSEdit_Transform(const Handle(SMDS_Mesh)& aMesh,const gp_Trsf& aTrsf); +Standard_EXPORT SMDSEdit_Transform(const Handle(SMDS_Mesh)& aMesh,const SMDS_ListOfMeshElement& aListOfME,const gp_Trsf& aTrsf); +Standard_EXPORT void Perform() ; +Standard_EXPORT void SetTrsf(const gp_Trsf& aTrsf) ; +Standard_EXPORT gp_Trsf GetTrsf() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Handle_SMDS_Mesh myMesh; +gp_Trsf myTrsf; +SMDS_ListOfMeshElement myListOfME; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDSEdit_Transform.ixx b/src/SMDS/SMDSEdit_Transform.ixx new file mode 100644 index 000000000..b355c3c3b --- /dev/null +++ b/src/SMDS/SMDSEdit_Transform.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDSEdit_Transform.jxx" + + + + diff --git a/src/SMDS/SMDSEdit_Transform.jxx b/src/SMDS/SMDSEdit_Transform.jxx new file mode 100644 index 000000000..ae63c6df7 --- /dev/null +++ b/src/SMDS/SMDSEdit_Transform.jxx @@ -0,0 +1,12 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _gp_Trsf_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +#ifndef _SMDSEdit_Transform_HeaderFile +#include "SMDSEdit_Transform.hxx" +#endif diff --git a/src/SMDS/SMDS_BasicMap.lxx b/src/SMDS/SMDS_BasicMap.lxx new file mode 100644 index 000000000..3122adb0a --- /dev/null +++ b/src/SMDS/SMDS_BasicMap.lxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_BasicMap.lxx has disappeared diff --git a/src/SMDS/SMDS_BasicMapIterator.lxx b/src/SMDS/SMDS_BasicMapIterator.lxx new file mode 100644 index 000000000..167f4e428 --- /dev/null +++ b/src/SMDS/SMDS_BasicMapIterator.lxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_BasicMapIterator.lxx has disappeared diff --git a/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx new file mode 100644 index 000000000..f06cc435c --- /dev/null +++ b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx @@ -0,0 +1,106 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile +#define _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" +#endif +class Standard_NoSuchObject; +class SMDS_MeshElement; +class TColStd_MapIntegerHasher; +class SMDS_DataMapOfIntegerMeshElement; +class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement : public TCollection_BasicMapIterator { + +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_DataMapIteratorOfDataMapOfIntegerMeshElement(); +Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement(const SMDS_DataMapOfIntegerMeshElement& aMap); +Standard_EXPORT void Initialize(const SMDS_DataMapOfIntegerMeshElement& aMap) ; +Standard_EXPORT const Standard_Integer& Key() const; +Standard_EXPORT const Handle_SMDS_MeshElement& Value() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx new file mode 100644 index 000000000..a7f2b991b --- /dev/null +++ b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx @@ -0,0 +1,50 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapOfIntegerMeshElement.hxx" +#endif +#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMDS_MeshElement +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_() +#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx new file mode 100644 index 000000000..4ecb233e0 --- /dev/null +++ b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx @@ -0,0 +1,103 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile +#define _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" +#endif +class Standard_NoSuchObject; +class gp_Pnt; +class SMDS_PntHasher; +class SMDS_DataMapOfPntInteger; +class SMDS_DataMapNodeOfDataMapOfPntInteger; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_DataMapIteratorOfDataMapOfPntInteger : public TCollection_BasicMapIterator { + +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_DataMapIteratorOfDataMapOfPntInteger(); +Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfPntInteger(const SMDS_DataMapOfPntInteger& aMap); +Standard_EXPORT void Initialize(const SMDS_DataMapOfPntInteger& aMap) ; +Standard_EXPORT const gp_Pnt& Key() const; +Standard_EXPORT const Standard_Integer& Value() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx new file mode 100644 index 000000000..e191fda91 --- /dev/null +++ b/src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx @@ -0,0 +1,50 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_PntHasher_HeaderFile +#include "SMDS_PntHasher.hxx" +#endif +#ifndef _SMDS_DataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapOfPntInteger.hxx" +#endif +#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" +#endif + + +#define TheKey gp_Pnt +#define TheKey_hxx +#define TheItem Standard_Integer +#define TheItem_hxx +#define Hasher SMDS_PntHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_() +#define TCollection_DataMap SMDS_DataMapOfPntInteger +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx b/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx new file mode 100644 index 000000000..00000616c --- /dev/null +++ b/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx @@ -0,0 +1,141 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#define _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_MeshElement; +class TColStd_MapIntegerHasher; +class SMDS_DataMapOfIntegerMeshElement; +class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement; + + +class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement : public TCollection_MapNode { + +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 SMDS_DataMapNodeOfDataMapOfIntegerMeshElement(const Standard_Integer& K,const Handle(SMDS_MeshElement)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Standard_Integer& Key() const; +Standard_EXPORT inline Handle_SMDS_MeshElement& Value() const; +Standard_EXPORT ~SMDS_DataMapNodeOfDataMapOfIntegerMeshElement(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_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 + // +Standard_Integer myKey; +Handle_SMDS_MeshElement myValue; + + +}; + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMDS_MeshElement +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_() +#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement +#define TCollection_DataMap_hxx + +#include + +#undef TheKey +#undef TheKey_hxx +#undef TheItem +#undef TheItem_hxx +#undef Hasher +#undef Hasher_hxx +#undef TCollection_DataMapNode +#undef TCollection_DataMapNode_hxx +#undef TCollection_DataMapIterator +#undef TCollection_DataMapIterator_hxx +#undef Handle_TCollection_DataMapNode +#undef TCollection_DataMapNode_Type_ +#undef TCollection_DataMap +#undef TCollection_DataMap_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx b/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx new file mode 100644 index 000000000..6efc11da5 --- /dev/null +++ b/src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx @@ -0,0 +1,99 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapOfIntegerMeshElement.hxx" +#endif +#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx" +#endif +SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::~SMDS_DataMapNodeOfDataMapOfIntegerMeshElement() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_DataMapNodeOfDataMapOfIntegerMeshElement", + sizeof(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement))) { + _anOtherObject = Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)((Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::DynamicType() const +{ + return STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) ; +} +Standard_Boolean SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::~Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement() {} +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMDS_MeshElement +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_() +#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx b/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx new file mode 100644 index 000000000..1c824f2a2 --- /dev/null +++ b/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx @@ -0,0 +1,141 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#define _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" +#endif + +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class gp_Pnt; +class SMDS_PntHasher; +class SMDS_DataMapOfPntInteger; +class SMDS_DataMapIteratorOfDataMapOfPntInteger; + + +class SMDS_DataMapNodeOfDataMapOfPntInteger : public TCollection_MapNode { + +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 SMDS_DataMapNodeOfDataMapOfPntInteger(const gp_Pnt& K,const Standard_Integer& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline gp_Pnt& Key() const; +Standard_EXPORT inline Standard_Integer& Value() const; +Standard_EXPORT ~SMDS_DataMapNodeOfDataMapOfPntInteger(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfPntInteger_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 myKey; +Standard_Integer myValue; + + +}; + +#define TheKey gp_Pnt +#define TheKey_hxx +#define TheItem Standard_Integer +#define TheItem_hxx +#define Hasher SMDS_PntHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_() +#define TCollection_DataMap SMDS_DataMapOfPntInteger +#define TCollection_DataMap_hxx + +#include + +#undef TheKey +#undef TheKey_hxx +#undef TheItem +#undef TheItem_hxx +#undef Hasher +#undef Hasher_hxx +#undef TCollection_DataMapNode +#undef TCollection_DataMapNode_hxx +#undef TCollection_DataMapIterator +#undef TCollection_DataMapIterator_hxx +#undef Handle_TCollection_DataMapNode +#undef TCollection_DataMapNode_Type_ +#undef TCollection_DataMap +#undef TCollection_DataMap_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx b/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx new file mode 100644 index 000000000..4205ef2c6 --- /dev/null +++ b/src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx @@ -0,0 +1,99 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_PntHasher_HeaderFile +#include "SMDS_PntHasher.hxx" +#endif +#ifndef _SMDS_DataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapOfPntInteger.hxx" +#endif +#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx" +#endif +SMDS_DataMapNodeOfDataMapOfPntInteger::~SMDS_DataMapNodeOfDataMapOfPntInteger() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfPntInteger_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_DataMapNodeOfDataMapOfPntInteger", + sizeof(SMDS_DataMapNodeOfDataMapOfPntInteger), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger))) { + _anOtherObject = Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)((Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_DataMapNodeOfDataMapOfPntInteger::DynamicType() const +{ + return STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger) ; +} +Standard_Boolean SMDS_DataMapNodeOfDataMapOfPntInteger::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_DataMapNodeOfDataMapOfPntInteger::~Handle_SMDS_DataMapNodeOfDataMapOfPntInteger() {} +#define TheKey gp_Pnt +#define TheKey_hxx +#define TheItem Standard_Integer +#define TheItem_hxx +#define Hasher SMDS_PntHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_() +#define TCollection_DataMap SMDS_DataMapOfPntInteger +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx b/src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx new file mode 100644 index 000000000..764f973ae --- /dev/null +++ b/src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx @@ -0,0 +1,135 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile +#define _SMDS_DataMapOfIntegerMeshElement_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class SMDS_MeshElement; +class TColStd_MapIntegerHasher; +class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement; +class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_DataMapOfIntegerMeshElement : public TCollection_BasicMap { + +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_DataMapOfIntegerMeshElement(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMDS_DataMapOfIntegerMeshElement& Assign(const SMDS_DataMapOfIntegerMeshElement& Other) ; + SMDS_DataMapOfIntegerMeshElement& operator =(const SMDS_DataMapOfIntegerMeshElement& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMDS_DataMapOfIntegerMeshElement() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const Standard_Integer& K,const Handle(SMDS_MeshElement)& I) ; +Standard_EXPORT Standard_Boolean IsBound(const Standard_Integer& K) const; +Standard_EXPORT Standard_Boolean UnBind(const Standard_Integer& K) ; +Standard_EXPORT const Handle_SMDS_MeshElement& Find(const Standard_Integer& K) const; + const Handle_SMDS_MeshElement& operator()(const Standard_Integer& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMDS_MeshElement& ChangeFind(const Standard_Integer& K) ; + Handle_SMDS_MeshElement& operator()(const Standard_Integer& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_DataMapOfIntegerMeshElement(const SMDS_DataMapOfIntegerMeshElement& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx b/src/SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx new file mode 100644 index 000000000..629172da1 --- /dev/null +++ b/src/SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx @@ -0,0 +1,53 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapOfIntegerMeshElement.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx" +#endif +#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMDS_MeshElement +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_() +#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_DataMapOfPntInteger.hxx b/src/SMDS/SMDS_DataMapOfPntInteger.hxx new file mode 100644 index 000000000..4f67f6404 --- /dev/null +++ b/src/SMDS/SMDS_DataMapOfPntInteger.hxx @@ -0,0 +1,132 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_DataMapOfPntInteger_HeaderFile +#define _SMDS_DataMapOfPntInteger_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class gp_Pnt; +class SMDS_PntHasher; +class SMDS_DataMapNodeOfDataMapOfPntInteger; +class SMDS_DataMapIteratorOfDataMapOfPntInteger; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_DataMapOfPntInteger : public TCollection_BasicMap { + +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_DataMapOfPntInteger(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMDS_DataMapOfPntInteger& Assign(const SMDS_DataMapOfPntInteger& Other) ; + SMDS_DataMapOfPntInteger& operator =(const SMDS_DataMapOfPntInteger& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMDS_DataMapOfPntInteger() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const gp_Pnt& K,const Standard_Integer& I) ; +Standard_EXPORT Standard_Boolean IsBound(const gp_Pnt& K) const; +Standard_EXPORT Standard_Boolean UnBind(const gp_Pnt& K) ; +Standard_EXPORT const Standard_Integer& Find(const gp_Pnt& K) const; + const Standard_Integer& operator()(const gp_Pnt& K) const +{ + return Find(K); +} + +Standard_EXPORT Standard_Integer& ChangeFind(const gp_Pnt& K) ; + Standard_Integer& operator()(const gp_Pnt& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_DataMapOfPntInteger(const SMDS_DataMapOfPntInteger& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_DataMapOfPntInteger_0.cxx b/src/SMDS/SMDS_DataMapOfPntInteger_0.cxx new file mode 100644 index 000000000..e281408cd --- /dev/null +++ b/src/SMDS/SMDS_DataMapOfPntInteger_0.cxx @@ -0,0 +1,53 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_DataMapOfPntInteger.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_PntHasher_HeaderFile +#include "SMDS_PntHasher.hxx" +#endif +#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx" +#endif +#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile +#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx" +#endif + + +#define TheKey gp_Pnt +#define TheKey_hxx +#define TheItem Standard_Integer +#define TheItem_hxx +#define Hasher SMDS_PntHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger +#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_() +#define TCollection_DataMap SMDS_DataMapOfPntInteger +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMDS/SMDS_EdgePosition.cdl b/src/SMDS/SMDS_EdgePosition.cdl new file mode 100644 index 000000000..d606c6c1d --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.cdl @@ -0,0 +1,36 @@ +-- File: SMDS_EdgePosition.cdl +-- Created: Mon May 13 14:44:40 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class EdgePosition from SMDS inherits Position from SMDS + + ---Purpose: used to characterize a MeshNode with a CAD edge + +uses + Pnt from gp + +is + + Create returns mutable EdgePosition; + ---Purpose: empty constructor. the edge is not set + + Create(aEdgeId : Integer; aUParam : Real) returns mutable EdgePosition; + + Coords(me) returns Pnt from gp is redefined virtual; + ---Purpose: returns the resulting 3d point to be set + -- in the MeshNode instance + + SetUParameter(me: mutable; aUparam : Real); + ---C++: inline + + GetUParameter(me) returns Real; + ---C++: inline + +fields + + myUParameter : Real; + +end EdgePosition; diff --git a/src/SMDS/SMDS_EdgePosition.cxx b/src/SMDS/SMDS_EdgePosition.cxx new file mode 100644 index 000000000..7b3751dfd --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.cxx @@ -0,0 +1,41 @@ +using namespace std; +// File: SMDS_EdgePosition.cxx +// Created: Mon May 13 14:49:28 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_EdgePosition.ixx" +#include "utilities.h" + +//======================================================================= +//function : SMDS_EdgePosition +//purpose : +//======================================================================= + +SMDS_EdgePosition::SMDS_EdgePosition() + :SMDS_Position(0,SMDS_TOP_EDGE),myUParameter(0.) +{ +} + +//======================================================================= +//function : SMDS_EdgePosition +//purpose : +//======================================================================= + +SMDS_EdgePosition::SMDS_EdgePosition(const Standard_Integer aEdgeId, + const Standard_Real aUParam) + :SMDS_Position(aEdgeId,SMDS_TOP_EDGE),myUParameter(aUParam) +{ +} + +//======================================================================= +//function : Coords +//purpose : +//======================================================================= + +gp_Pnt SMDS_EdgePosition::Coords() const +{ + MESSAGE( "SMDS_EdgePosition::Coords not implemented" ); + return gp_Pnt(0,0,0); +} diff --git a/src/SMDS/SMDS_EdgePosition.hxx b/src/SMDS/SMDS_EdgePosition.hxx new file mode 100644 index 000000000..25d5a6447 --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.hxx @@ -0,0 +1,108 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_EdgePosition_HeaderFile +#define _SMDS_EdgePosition_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_EdgePosition_HeaderFile +#include "Handle_SMDS_EdgePosition.hxx" +#endif + +#ifndef _Standard_Real_HeaderFile +#include +#endif +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class gp_Pnt; + + +class SMDS_EdgePosition : public SMDS_Position { + +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_EdgePosition(); +Standard_EXPORT SMDS_EdgePosition(const Standard_Integer aEdgeId,const Standard_Real aUParam); +Standard_EXPORT virtual gp_Pnt Coords() const; +Standard_EXPORT inline void SetUParameter(const Standard_Real aUparam) ; +Standard_EXPORT inline Standard_Real GetUParameter() const; +Standard_EXPORT ~SMDS_EdgePosition(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_EdgePosition_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 + // +Standard_Real myUParameter; + + +}; + + +#include "SMDS_EdgePosition.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_EdgePosition.ixx b/src/SMDS/SMDS_EdgePosition.ixx new file mode 100644 index 000000000..ecdb4365e --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_EdgePosition.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_EdgePosition::~SMDS_EdgePosition() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_EdgePosition_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_EdgePosition", + sizeof(SMDS_EdgePosition), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_EdgePosition) Handle(SMDS_EdgePosition)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_EdgePosition) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_EdgePosition))) { + _anOtherObject = Handle(SMDS_EdgePosition)((Handle(SMDS_EdgePosition)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_EdgePosition::DynamicType() const +{ + return STANDARD_TYPE(SMDS_EdgePosition) ; +} +Standard_Boolean SMDS_EdgePosition::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_EdgePosition) == AType || SMDS_Position::IsKind(AType)); +} +Handle_SMDS_EdgePosition::~Handle_SMDS_EdgePosition() {} + diff --git a/src/SMDS/SMDS_EdgePosition.jxx b/src/SMDS/SMDS_EdgePosition.jxx new file mode 100644 index 000000000..ec7254d7b --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_EdgePosition_HeaderFile +#include "SMDS_EdgePosition.hxx" +#endif diff --git a/src/SMDS/SMDS_EdgePosition.lxx b/src/SMDS/SMDS_EdgePosition.lxx new file mode 100644 index 000000000..0e606540e --- /dev/null +++ b/src/SMDS/SMDS_EdgePosition.lxx @@ -0,0 +1,24 @@ +// File: SMDS_EdgePosition.lxx +// Created: Mon May 13 14:47:40 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : SetUParameter +//purpose : +//======================================================================= + +inline void SMDS_EdgePosition::SetUParameter(const Standard_Real aUparam) +{ + myUParameter = aUparam; +} + +//======================================================================= +//function : GetUParameter +//purpose : +//======================================================================= + +inline Standard_Real SMDS_EdgePosition::GetUParameter() const +{ + return myUParameter; +} diff --git a/src/SMDS/SMDS_ExtendedMap.hxx b/src/SMDS/SMDS_ExtendedMap.hxx new file mode 100644 index 000000000..0e7d8dcb4 --- /dev/null +++ b/src/SMDS/SMDS_ExtendedMap.hxx @@ -0,0 +1,122 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ExtendedMap_HeaderFile +#define _SMDS_ExtendedMap_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedMap.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class SMDS_MeshElement; +class SMDS_MeshElementMapHasher; +class SMDS_StdMapNodeOfExtendedMap; +class SMDS_MapIteratorOfExtendedMap; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ExtendedMap : public TCollection_BasicMap { + +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_ExtendedMap(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMDS_ExtendedMap& Assign(const SMDS_ExtendedMap& Other) ; + SMDS_ExtendedMap& operator =(const SMDS_ExtendedMap& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMDS_ExtendedMap() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Add(const Handle(SMDS_MeshElement)& aKey) ; +Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& aKey) const; +Standard_EXPORT Standard_Boolean Remove(const Handle(SMDS_MeshElement)& aKey) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_ExtendedMap(const SMDS_ExtendedMap& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ExtendedMap_0.cxx b/src/SMDS/SMDS_ExtendedMap_0.cxx new file mode 100644 index 000000000..1666b02f7 --- /dev/null +++ b/src/SMDS/SMDS_ExtendedMap_0.cxx @@ -0,0 +1,48 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ExtendedMap.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_() +#define TCollection_Map SMDS_ExtendedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_ExtendedOrientedMap.hxx b/src/SMDS/SMDS_ExtendedOrientedMap.hxx new file mode 100644 index 000000000..528a0026b --- /dev/null +++ b/src/SMDS/SMDS_ExtendedOrientedMap.hxx @@ -0,0 +1,122 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ExtendedOrientedMap_HeaderFile +#define _SMDS_ExtendedOrientedMap_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class SMDS_MeshElement; +class SMDS_MeshOrientedElementMapHasher; +class SMDS_StdMapNodeOfExtendedOrientedMap; +class SMDS_MapIteratorOfExtendedOrientedMap; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ExtendedOrientedMap : public TCollection_BasicMap { + +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_ExtendedOrientedMap(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMDS_ExtendedOrientedMap& Assign(const SMDS_ExtendedOrientedMap& Other) ; + SMDS_ExtendedOrientedMap& operator =(const SMDS_ExtendedOrientedMap& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMDS_ExtendedOrientedMap() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Add(const Handle(SMDS_MeshElement)& aKey) ; +Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& aKey) const; +Standard_EXPORT Standard_Boolean Remove(const Handle(SMDS_MeshElement)& aKey) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_ExtendedOrientedMap(const SMDS_ExtendedOrientedMap& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ExtendedOrientedMap_0.cxx b/src/SMDS/SMDS_ExtendedOrientedMap_0.cxx new file mode 100644 index 000000000..d730d6b38 --- /dev/null +++ b/src/SMDS/SMDS_ExtendedOrientedMap_0.cxx @@ -0,0 +1,48 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ExtendedOrientedMap.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile +#include "SMDS_MeshOrientedElementMapHasher.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshOrientedElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +#define TCollection_Map SMDS_ExtendedOrientedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_FacePosition.cdl b/src/SMDS/SMDS_FacePosition.cdl new file mode 100644 index 000000000..a629866a3 --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.cdl @@ -0,0 +1,44 @@ +-- File: SMDS_FacePosition.cdl +-- Created: Mon May 13 14:53:10 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class FacePosition from SMDS inherits Position from SMDS + + ---Purpose: used to characterize a MeshNode with a CAD face + +uses + Pnt from gp + +is + + Create returns mutable FacePosition; + ---Purpose: empty constructor. the face is not set + + Create(aFaceId : Integer; aUParam,aVParam : Real) + returns mutable FacePosition; + + Coords(me) returns Pnt from gp is redefined virtual; + ---Purpose: returns the resulting 3d point to be set + -- in the MeshNode instance + + SetUParameter(me: mutable; aUparam : Real); + ---C++: inline + + SetVParameter(me: mutable; aVparam : Real); + ---C++: inline + + GetUParameter(me) returns Real; + ---C++: inline + + GetVParameter(me) returns Real; + ---C++: inline + +fields + + myUParameter : Real; + myVParameter : Real; + +end FacePosition; diff --git a/src/SMDS/SMDS_FacePosition.cxx b/src/SMDS/SMDS_FacePosition.cxx new file mode 100644 index 000000000..f0c9d24fe --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.cxx @@ -0,0 +1,43 @@ +using namespace std; +// File: SMDS_FacePosition.cxx +// Created: Mon May 13 14:56:28 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_FacePosition.ixx" +#include "utilities.h" + +//======================================================================= +//function : SMDS_FacePosition +//purpose : +//======================================================================= + +SMDS_FacePosition::SMDS_FacePosition() + :SMDS_Position(0,SMDS_TOP_FACE),myUParameter(0.),myVParameter(0.) +{ +} + +//======================================================================= +//function : SMDS_FacePosition +//purpose : +//======================================================================= + +SMDS_FacePosition::SMDS_FacePosition(const Standard_Integer aEdgeId, + const Standard_Real aUParam, + const Standard_Real aVParam) + :SMDS_Position(aEdgeId,SMDS_TOP_FACE), + myUParameter(aUParam),myVParameter(aVParam) +{ +} + +//======================================================================= +//function : Coords +//purpose : +//======================================================================= + +gp_Pnt SMDS_FacePosition::Coords() const +{ + MESSAGE( "SMDS_FacePosition::Coords not implemented" ); + return gp_Pnt(0,0,0); +} diff --git a/src/SMDS/SMDS_FacePosition.hxx b/src/SMDS/SMDS_FacePosition.hxx new file mode 100644 index 000000000..015694e9e --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.hxx @@ -0,0 +1,111 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_FacePosition_HeaderFile +#define _SMDS_FacePosition_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_FacePosition_HeaderFile +#include "Handle_SMDS_FacePosition.hxx" +#endif + +#ifndef _Standard_Real_HeaderFile +#include +#endif +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class gp_Pnt; + + +class SMDS_FacePosition : public SMDS_Position { + +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_FacePosition(); +Standard_EXPORT SMDS_FacePosition(const Standard_Integer aFaceId,const Standard_Real aUParam,const Standard_Real aVParam); +Standard_EXPORT virtual gp_Pnt Coords() const; +Standard_EXPORT inline void SetUParameter(const Standard_Real aUparam) ; +Standard_EXPORT inline void SetVParameter(const Standard_Real aVparam) ; +Standard_EXPORT inline Standard_Real GetUParameter() const; +Standard_EXPORT inline Standard_Real GetVParameter() const; +Standard_EXPORT ~SMDS_FacePosition(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_FacePosition_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 + // +Standard_Real myUParameter; +Standard_Real myVParameter; + + +}; + + +#include "SMDS_FacePosition.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_FacePosition.ixx b/src/SMDS/SMDS_FacePosition.ixx new file mode 100644 index 000000000..088665748 --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_FacePosition.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_FacePosition::~SMDS_FacePosition() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_FacePosition_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_FacePosition", + sizeof(SMDS_FacePosition), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_FacePosition) Handle(SMDS_FacePosition)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_FacePosition) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_FacePosition))) { + _anOtherObject = Handle(SMDS_FacePosition)((Handle(SMDS_FacePosition)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_FacePosition::DynamicType() const +{ + return STANDARD_TYPE(SMDS_FacePosition) ; +} +Standard_Boolean SMDS_FacePosition::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_FacePosition) == AType || SMDS_Position::IsKind(AType)); +} +Handle_SMDS_FacePosition::~Handle_SMDS_FacePosition() {} + diff --git a/src/SMDS/SMDS_FacePosition.jxx b/src/SMDS/SMDS_FacePosition.jxx new file mode 100644 index 000000000..f92d19aa4 --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_FacePosition_HeaderFile +#include "SMDS_FacePosition.hxx" +#endif diff --git a/src/SMDS/SMDS_FacePosition.lxx b/src/SMDS/SMDS_FacePosition.lxx new file mode 100644 index 000000000..d64974588 --- /dev/null +++ b/src/SMDS/SMDS_FacePosition.lxx @@ -0,0 +1,44 @@ +// File: SMDS_FacePosition.lxx +// Created: Mon May 13 14:55:03 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : SetUParameter +//purpose : +//======================================================================= + +inline void SMDS_FacePosition::SetUParameter(const Standard_Real aUparam) +{ + myUParameter = aUparam; +} + +//======================================================================= +//function : SetVParameter +//purpose : +//======================================================================= + +inline void SMDS_FacePosition::SetVParameter(const Standard_Real aVparam) +{ + myVParameter = aVparam; +} + +//======================================================================= +//function : GetUParameter +//purpose : +//======================================================================= + +inline Standard_Real SMDS_FacePosition::GetUParameter() const +{ + return myUParameter; +} + +//======================================================================= +//function : GetVParameter +//purpose : +//======================================================================= + +inline Standard_Real SMDS_FacePosition::GetVParameter() const +{ + return myVParameter; +} diff --git a/src/SMDS/SMDS_HSequenceOfMesh.hxx b/src/SMDS/SMDS_HSequenceOfMesh.hxx new file mode 100644 index 000000000..cbfb0b9c6 --- /dev/null +++ b/src/SMDS/SMDS_HSequenceOfMesh.hxx @@ -0,0 +1,155 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_HSequenceOfMesh_HeaderFile +#define _SMDS_HSequenceOfMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_HSequenceOfMesh_HeaderFile +#include "Handle_SMDS_HSequenceOfMesh.hxx" +#endif + +#ifndef _SMDS_SequenceOfMesh_HeaderFile +#include "SMDS_SequenceOfMesh.hxx" +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class Standard_OutOfRange; +class SMDS_Mesh; +class SMDS_SequenceOfMesh; + + +class SMDS_HSequenceOfMesh : public MMgt_TShared { + +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 SMDS_HSequenceOfMesh(); +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT inline Standard_Integer Length() const; +Standard_EXPORT void Clear() ; +Standard_EXPORT void Append(const Handle(SMDS_Mesh)& anItem) ; +Standard_EXPORT void Append(const Handle(SMDS_HSequenceOfMesh)& aSequence) ; +Standard_EXPORT void Prepend(const Handle(SMDS_Mesh)& anItem) ; +Standard_EXPORT void Prepend(const Handle(SMDS_HSequenceOfMesh)& aSequence) ; +Standard_EXPORT void Reverse() ; +Standard_EXPORT void InsertBefore(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ; +Standard_EXPORT void InsertBefore(const Standard_Integer anIndex,const Handle(SMDS_HSequenceOfMesh)& aSequence) ; +Standard_EXPORT void InsertAfter(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ; +Standard_EXPORT void InsertAfter(const Standard_Integer anIndex,const Handle(SMDS_HSequenceOfMesh)& aSequence) ; +Standard_EXPORT void Exchange(const Standard_Integer anIndex,const Standard_Integer anOtherIndex) ; +Standard_EXPORT Handle_SMDS_HSequenceOfMesh Split(const Standard_Integer anIndex) ; +Standard_EXPORT void SetValue(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ; +Standard_EXPORT const Handle_SMDS_Mesh& Value(const Standard_Integer anIndex) const; +Standard_EXPORT Handle_SMDS_Mesh& ChangeValue(const Standard_Integer anIndex) ; +Standard_EXPORT void Remove(const Standard_Integer anIndex) ; +Standard_EXPORT void Remove(const Standard_Integer fromIndex,const Standard_Integer toIndex) ; +Standard_EXPORT inline const SMDS_SequenceOfMesh& Sequence() const; +Standard_EXPORT inline SMDS_SequenceOfMesh& ChangeSequence() ; +Standard_EXPORT Handle_SMDS_HSequenceOfMesh ShallowCopy() const; +Standard_EXPORT ~SMDS_HSequenceOfMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_HSequenceOfMesh_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 + // +SMDS_SequenceOfMesh mySequence; + + +}; + +#define Item Handle_SMDS_Mesh +#define Item_hxx "SMDS_Mesh.hxx" +#define TheSequence SMDS_SequenceOfMesh +#define TheSequence_hxx "SMDS_SequenceOfMesh.hxx" +#define TCollection_HSequence SMDS_HSequenceOfMesh +#define TCollection_HSequence_hxx "SMDS_HSequenceOfMesh.hxx" +#define Handle_TCollection_HSequence Handle_SMDS_HSequenceOfMesh +#define TCollection_HSequence_Type_() SMDS_HSequenceOfMesh_Type_() + +#include + +#undef Item +#undef Item_hxx +#undef TheSequence +#undef TheSequence_hxx +#undef TCollection_HSequence +#undef TCollection_HSequence_hxx +#undef Handle_TCollection_HSequence +#undef TCollection_HSequence_Type_ + + +// other inline functions and methods (like "C++: function call" methods) +// +inline Handle_SMDS_HSequenceOfMesh ShallowCopy(const Handle_SMDS_HSequenceOfMesh& me) { + return me->ShallowCopy(); +} + + + +#endif diff --git a/src/SMDS/SMDS_HSequenceOfMesh_0.cxx b/src/SMDS/SMDS_HSequenceOfMesh_0.cxx new file mode 100644 index 000000000..3d323bd26 --- /dev/null +++ b/src/SMDS/SMDS_HSequenceOfMesh_0.cxx @@ -0,0 +1,91 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_HSequenceOfMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _Standard_OutOfRange_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_SequenceOfMesh_HeaderFile +#include "SMDS_SequenceOfMesh.hxx" +#endif +SMDS_HSequenceOfMesh::~SMDS_HSequenceOfMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_HSequenceOfMesh_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_HSequenceOfMesh", + sizeof(SMDS_HSequenceOfMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_HSequenceOfMesh) Handle(SMDS_HSequenceOfMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_HSequenceOfMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_HSequenceOfMesh))) { + _anOtherObject = Handle(SMDS_HSequenceOfMesh)((Handle(SMDS_HSequenceOfMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_HSequenceOfMesh::DynamicType() const +{ + return STANDARD_TYPE(SMDS_HSequenceOfMesh) ; +} +Standard_Boolean SMDS_HSequenceOfMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_HSequenceOfMesh) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMDS_HSequenceOfMesh::~Handle_SMDS_HSequenceOfMesh() {} +#define Item Handle_SMDS_Mesh +#define Item_hxx "SMDS_Mesh.hxx" +#define TheSequence SMDS_SequenceOfMesh +#define TheSequence_hxx "SMDS_SequenceOfMesh.hxx" +#define TCollection_HSequence SMDS_HSequenceOfMesh +#define TCollection_HSequence_hxx "SMDS_HSequenceOfMesh.hxx" +#define Handle_TCollection_HSequence Handle_SMDS_HSequenceOfMesh +#define TCollection_HSequence_Type_() SMDS_HSequenceOfMesh_Type_() +#include + diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx b/src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx new file mode 100644 index 000000000..3a40dd315 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx @@ -0,0 +1,131 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile +#define _SMDS_ListIteratorOfListOfMesh_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_ListOfMesh; +class SMDS_Mesh; +class SMDS_ListNodeOfListOfMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListIteratorOfListOfMesh { + +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_ListIteratorOfListOfMesh(); +Standard_EXPORT SMDS_ListIteratorOfListOfMesh(const SMDS_ListOfMesh& L); +Standard_EXPORT void Initialize(const SMDS_ListOfMesh& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT Handle_SMDS_Mesh& Value() const; + + +friend class SMDS_ListOfMesh; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx b/src/SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx new file mode 100644 index 000000000..68b2a4f04 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx @@ -0,0 +1,131 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile +#define _SMDS_ListIteratorOfListOfMeshElement_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_ListOfMeshElement; +class SMDS_MeshElement; +class SMDS_ListNodeOfListOfMeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListIteratorOfListOfMeshElement { + +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_ListIteratorOfListOfMeshElement(); +Standard_EXPORT SMDS_ListIteratorOfListOfMeshElement(const SMDS_ListOfMeshElement& L); +Standard_EXPORT void Initialize(const SMDS_ListOfMeshElement& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT Handle_SMDS_MeshElement& Value() const; + + +friend class SMDS_ListOfMeshElement; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx b/src/SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx new file mode 100644 index 000000000..c6b926bd5 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx @@ -0,0 +1,46 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListIteratorOfListOfMeshElement.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile +#include "SMDS_ListNodeOfListOfMeshElement.hxx" +#endif + + +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx b/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx new file mode 100644 index 000000000..230cef572 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx @@ -0,0 +1,131 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile +#define _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#include "Handle_SMDS_MeshGroup.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_ListOfMeshGroup; +class SMDS_MeshGroup; +class SMDS_ListNodeOfListOfMeshGroup; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListIteratorOfListOfMeshGroup { + +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_ListIteratorOfListOfMeshGroup(); +Standard_EXPORT SMDS_ListIteratorOfListOfMeshGroup(const SMDS_ListOfMeshGroup& L); +Standard_EXPORT void Initialize(const SMDS_ListOfMeshGroup& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT Handle_SMDS_MeshGroup& Value() const; + + +friend class SMDS_ListOfMeshGroup; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx b/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx new file mode 100644 index 000000000..cbcde7f61 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx @@ -0,0 +1,46 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListIteratorOfListOfMeshGroup.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMeshGroup_HeaderFile +#include "SMDS_ListOfMeshGroup.hxx" +#endif +#ifndef _SMDS_MeshGroup_HeaderFile +#include "SMDS_MeshGroup.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#include "SMDS_ListNodeOfListOfMeshGroup.hxx" +#endif + + +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" +#include + diff --git a/src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx b/src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx new file mode 100644 index 000000000..69b30f131 --- /dev/null +++ b/src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx @@ -0,0 +1,46 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListIteratorOfListOfMesh.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMesh_HeaderFile +#include "SMDS_ListOfMesh.hxx" +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile +#include "SMDS_ListNodeOfListOfMesh.hxx" +#endif + + +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_ListNodeOfListOfMesh.hxx b/src/SMDS/SMDS_ListNodeOfListOfMesh.hxx new file mode 100644 index 000000000..3dcf31735 --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMesh.hxx @@ -0,0 +1,127 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile +#define _SMDS_ListNodeOfListOfMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMesh.hxx" +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_Mesh; +class SMDS_ListOfMesh; +class SMDS_ListIteratorOfListOfMesh; + + +class SMDS_ListNodeOfListOfMesh : public TCollection_MapNode { + +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 SMDS_ListNodeOfListOfMesh(const Handle(SMDS_Mesh)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMDS_Mesh& Value() const; +Standard_EXPORT ~SMDS_ListNodeOfListOfMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMesh_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 + // +Handle_SMDS_Mesh myValue; + + +}; + +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx b/src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx new file mode 100644 index 000000000..3328b0b0a --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx @@ -0,0 +1,127 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile +#define _SMDS_ListNodeOfListOfMeshElement_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx" +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_MeshElement; +class SMDS_ListOfMeshElement; +class SMDS_ListIteratorOfListOfMeshElement; + + +class SMDS_ListNodeOfListOfMeshElement : public TCollection_MapNode { + +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 SMDS_ListNodeOfListOfMeshElement(const Handle(SMDS_MeshElement)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMDS_MeshElement& Value() const; +Standard_EXPORT ~SMDS_ListNodeOfListOfMeshElement(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMeshElement_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 + // +Handle_SMDS_MeshElement myValue; + + +}; + +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx b/src/SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx new file mode 100644 index 000000000..8ec414feb --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx @@ -0,0 +1,92 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListNodeOfListOfMeshElement.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile +#include "SMDS_ListIteratorOfListOfMeshElement.hxx" +#endif +SMDS_ListNodeOfListOfMeshElement::~SMDS_ListNodeOfListOfMeshElement() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMeshElement_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMeshElement", + sizeof(SMDS_ListNodeOfListOfMeshElement), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_ListNodeOfListOfMeshElement) Handle(SMDS_ListNodeOfListOfMeshElement)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_ListNodeOfListOfMeshElement) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement))) { + _anOtherObject = Handle(SMDS_ListNodeOfListOfMeshElement)((Handle(SMDS_ListNodeOfListOfMeshElement)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_ListNodeOfListOfMeshElement::DynamicType() const +{ + return STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement) ; +} +Standard_Boolean SMDS_ListNodeOfListOfMeshElement::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_ListNodeOfListOfMeshElement::~Handle_SMDS_ListNodeOfListOfMeshElement() {} +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx b/src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx new file mode 100644 index 000000000..a365d70fa --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx @@ -0,0 +1,127 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#define _SMDS_ListNodeOfListOfMeshGroup_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx" +#endif + +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#include "Handle_SMDS_MeshGroup.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_MeshGroup; +class SMDS_ListOfMeshGroup; +class SMDS_ListIteratorOfListOfMeshGroup; + + +class SMDS_ListNodeOfListOfMeshGroup : public TCollection_MapNode { + +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 SMDS_ListNodeOfListOfMeshGroup(const Handle(SMDS_MeshGroup)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMDS_MeshGroup& Value() const; +Standard_EXPORT ~SMDS_ListNodeOfListOfMeshGroup(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMeshGroup_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 + // +Handle_SMDS_MeshGroup myValue; + + +}; + +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx b/src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx new file mode 100644 index 000000000..b1727e078 --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx @@ -0,0 +1,92 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListNodeOfListOfMeshGroup.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_MeshGroup_HeaderFile +#include "SMDS_MeshGroup.hxx" +#endif +#ifndef _SMDS_ListOfMeshGroup_HeaderFile +#include "SMDS_ListOfMeshGroup.hxx" +#endif +#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile +#include "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#endif +SMDS_ListNodeOfListOfMeshGroup::~SMDS_ListNodeOfListOfMeshGroup() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMeshGroup_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMeshGroup", + sizeof(SMDS_ListNodeOfListOfMeshGroup), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_ListNodeOfListOfMeshGroup) Handle(SMDS_ListNodeOfListOfMeshGroup)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_ListNodeOfListOfMeshGroup) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup))) { + _anOtherObject = Handle(SMDS_ListNodeOfListOfMeshGroup)((Handle(SMDS_ListNodeOfListOfMeshGroup)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_ListNodeOfListOfMeshGroup::DynamicType() const +{ + return STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup) ; +} +Standard_Boolean SMDS_ListNodeOfListOfMeshGroup::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_ListNodeOfListOfMeshGroup::~Handle_SMDS_ListNodeOfListOfMeshGroup() {} +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" +#include + diff --git a/src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx b/src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx new file mode 100644 index 000000000..1b5caa3a1 --- /dev/null +++ b/src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx @@ -0,0 +1,92 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListNodeOfListOfMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_ListOfMesh_HeaderFile +#include "SMDS_ListOfMesh.hxx" +#endif +#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile +#include "SMDS_ListIteratorOfListOfMesh.hxx" +#endif +SMDS_ListNodeOfListOfMesh::~SMDS_ListNodeOfListOfMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMesh_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMesh", + sizeof(SMDS_ListNodeOfListOfMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_ListNodeOfListOfMesh) Handle(SMDS_ListNodeOfListOfMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_ListNodeOfListOfMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMesh))) { + _anOtherObject = Handle(SMDS_ListNodeOfListOfMesh)((Handle(SMDS_ListNodeOfListOfMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_ListNodeOfListOfMesh::DynamicType() const +{ + return STANDARD_TYPE(SMDS_ListNodeOfListOfMesh) ; +} +Standard_Boolean SMDS_ListNodeOfListOfMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_ListNodeOfListOfMesh) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_ListNodeOfListOfMesh::~Handle_SMDS_ListNodeOfListOfMesh() {} +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_ListOfMesh.hxx b/src/SMDS/SMDS_ListOfMesh.hxx new file mode 100644 index 000000000..f02ba99a0 --- /dev/null +++ b/src/SMDS/SMDS_ListOfMesh.hxx @@ -0,0 +1,155 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListOfMesh_HeaderFile +#define _SMDS_ListOfMesh_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMesh.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMDS_ListIteratorOfListOfMesh; +class SMDS_Mesh; +class SMDS_ListNodeOfListOfMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListOfMesh { + +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_ListOfMesh(); +Standard_EXPORT void Assign(const SMDS_ListOfMesh& Other) ; + void operator=(const SMDS_ListOfMesh& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMDS_ListOfMesh() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const Handle(SMDS_Mesh)& I) ; +Standard_EXPORT void Prepend(SMDS_ListOfMesh& Other) ; +Standard_EXPORT void Append(const Handle(SMDS_Mesh)& I) ; +Standard_EXPORT void Append(SMDS_ListOfMesh& Other) ; +Standard_EXPORT Handle_SMDS_Mesh& First() const; +Standard_EXPORT Handle_SMDS_Mesh& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMesh& It) ; +Standard_EXPORT void InsertBefore(const Handle(SMDS_Mesh)& I,SMDS_ListIteratorOfListOfMesh& It) ; +Standard_EXPORT void InsertBefore(SMDS_ListOfMesh& Other,SMDS_ListIteratorOfListOfMesh& It) ; +Standard_EXPORT void InsertAfter(const Handle(SMDS_Mesh)& I,SMDS_ListIteratorOfListOfMesh& It) ; +Standard_EXPORT void InsertAfter(SMDS_ListOfMesh& Other,SMDS_ListIteratorOfListOfMesh& It) ; + + +friend class SMDS_ListIteratorOfListOfMesh; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_ListOfMesh(const SMDS_ListOfMesh& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListOfMeshElement.hxx b/src/SMDS/SMDS_ListOfMeshElement.hxx new file mode 100644 index 000000000..d0b3908bd --- /dev/null +++ b/src/SMDS/SMDS_ListOfMeshElement.hxx @@ -0,0 +1,155 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#define _SMDS_ListOfMeshElement_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMDS_ListIteratorOfListOfMeshElement; +class SMDS_MeshElement; +class SMDS_ListNodeOfListOfMeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListOfMeshElement { + +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_ListOfMeshElement(); +Standard_EXPORT void Assign(const SMDS_ListOfMeshElement& Other) ; + void operator=(const SMDS_ListOfMeshElement& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMDS_ListOfMeshElement() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const Handle(SMDS_MeshElement)& I) ; +Standard_EXPORT void Prepend(SMDS_ListOfMeshElement& Other) ; +Standard_EXPORT void Append(const Handle(SMDS_MeshElement)& I) ; +Standard_EXPORT void Append(SMDS_ListOfMeshElement& Other) ; +Standard_EXPORT Handle_SMDS_MeshElement& First() const; +Standard_EXPORT Handle_SMDS_MeshElement& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMeshElement& It) ; +Standard_EXPORT void InsertBefore(const Handle(SMDS_MeshElement)& I,SMDS_ListIteratorOfListOfMeshElement& It) ; +Standard_EXPORT void InsertBefore(SMDS_ListOfMeshElement& Other,SMDS_ListIteratorOfListOfMeshElement& It) ; +Standard_EXPORT void InsertAfter(const Handle(SMDS_MeshElement)& I,SMDS_ListIteratorOfListOfMeshElement& It) ; +Standard_EXPORT void InsertAfter(SMDS_ListOfMeshElement& Other,SMDS_ListIteratorOfListOfMeshElement& It) ; + + +friend class SMDS_ListIteratorOfListOfMeshElement; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_ListOfMeshElement(const SMDS_ListOfMeshElement& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListOfMeshElement_0.cxx b/src/SMDS/SMDS_ListOfMeshElement_0.cxx new file mode 100644 index 000000000..227a38920 --- /dev/null +++ b/src/SMDS/SMDS_ListOfMeshElement_0.cxx @@ -0,0 +1,43 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListOfMeshElement.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile +#include "SMDS_ListIteratorOfListOfMeshElement.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile +#include "SMDS_ListNodeOfListOfMeshElement.hxx" +#endif + + +#define Item Handle_SMDS_MeshElement +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_() +#define TCollection_List SMDS_ListOfMeshElement +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_ListOfMeshGroup.hxx b/src/SMDS/SMDS_ListOfMeshGroup.hxx new file mode 100644 index 000000000..93cc433f5 --- /dev/null +++ b/src/SMDS/SMDS_ListOfMeshGroup.hxx @@ -0,0 +1,155 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_ListOfMeshGroup_HeaderFile +#define _SMDS_ListOfMeshGroup_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#include "Handle_SMDS_MeshGroup.hxx" +#endif +#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMDS_ListIteratorOfListOfMeshGroup; +class SMDS_MeshGroup; +class SMDS_ListNodeOfListOfMeshGroup; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_ListOfMeshGroup { + +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_ListOfMeshGroup(); +Standard_EXPORT void Assign(const SMDS_ListOfMeshGroup& Other) ; + void operator=(const SMDS_ListOfMeshGroup& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMDS_ListOfMeshGroup() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const Handle(SMDS_MeshGroup)& I) ; +Standard_EXPORT void Prepend(SMDS_ListOfMeshGroup& Other) ; +Standard_EXPORT void Append(const Handle(SMDS_MeshGroup)& I) ; +Standard_EXPORT void Append(SMDS_ListOfMeshGroup& Other) ; +Standard_EXPORT Handle_SMDS_MeshGroup& First() const; +Standard_EXPORT Handle_SMDS_MeshGroup& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMeshGroup& It) ; +Standard_EXPORT void InsertBefore(const Handle(SMDS_MeshGroup)& I,SMDS_ListIteratorOfListOfMeshGroup& It) ; +Standard_EXPORT void InsertBefore(SMDS_ListOfMeshGroup& Other,SMDS_ListIteratorOfListOfMeshGroup& It) ; +Standard_EXPORT void InsertAfter(const Handle(SMDS_MeshGroup)& I,SMDS_ListIteratorOfListOfMeshGroup& It) ; +Standard_EXPORT void InsertAfter(SMDS_ListOfMeshGroup& Other,SMDS_ListIteratorOfListOfMeshGroup& It) ; + + +friend class SMDS_ListIteratorOfListOfMeshGroup; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_ListOfMeshGroup(const SMDS_ListOfMeshGroup& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" + +#include + +#undef Item +#undef Item_hxx +#undef TCollection_ListNode +#undef TCollection_ListNode_hxx +#undef TCollection_ListIterator +#undef TCollection_ListIterator_hxx +#undef Handle_TCollection_ListNode +#undef TCollection_ListNode_Type_ +#undef TCollection_List +#undef TCollection_List_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_ListOfMeshGroup_0.cxx b/src/SMDS/SMDS_ListOfMeshGroup_0.cxx new file mode 100644 index 000000000..2cb93c23f --- /dev/null +++ b/src/SMDS/SMDS_ListOfMeshGroup_0.cxx @@ -0,0 +1,43 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListOfMeshGroup.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile +#include "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#endif +#ifndef _SMDS_MeshGroup_HeaderFile +#include "SMDS_MeshGroup.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile +#include "SMDS_ListNodeOfListOfMeshGroup.hxx" +#endif + + +#define Item Handle_SMDS_MeshGroup +#define Item_hxx "SMDS_MeshGroup.hxx" +#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx" +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup +#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx" +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_() +#define TCollection_List SMDS_ListOfMeshGroup +#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx" +#include + diff --git a/src/SMDS/SMDS_ListOfMesh_0.cxx b/src/SMDS/SMDS_ListOfMesh_0.cxx new file mode 100644 index 000000000..8afc4f2d1 --- /dev/null +++ b/src/SMDS/SMDS_ListOfMesh_0.cxx @@ -0,0 +1,43 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_ListOfMesh.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile +#include "SMDS_ListIteratorOfListOfMesh.hxx" +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile +#include "SMDS_ListNodeOfListOfMesh.hxx" +#endif + + +#define Item Handle_SMDS_Mesh +#define Item_hxx +#define TCollection_ListNode SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh +#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_() +#define TCollection_List SMDS_ListOfMesh +#define TCollection_List_hxx +#include + diff --git a/src/SMDS/SMDS_Map.gxx b/src/SMDS/SMDS_Map.gxx new file mode 100644 index 000000000..95f1677f9 --- /dev/null +++ b/src/SMDS/SMDS_Map.gxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_Map.gxx has disappeared diff --git a/src/SMDS/SMDS_MapHasher.gxx b/src/SMDS/SMDS_MapHasher.gxx new file mode 100644 index 000000000..2ee518363 --- /dev/null +++ b/src/SMDS/SMDS_MapHasher.gxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_MapHasher.gxx has disappeared diff --git a/src/SMDS/SMDS_MapIterator.gxx b/src/SMDS/SMDS_MapIterator.gxx new file mode 100644 index 000000000..a42ad7d37 --- /dev/null +++ b/src/SMDS/SMDS_MapIterator.gxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_MapIterator.gxx has disappeared diff --git a/src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx b/src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx new file mode 100644 index 000000000..eaa917e59 --- /dev/null +++ b/src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx @@ -0,0 +1,102 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MapIteratorOfExtendedMap_HeaderFile +#define _SMDS_MapIteratorOfExtendedMap_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedMap.hxx" +#endif +class Standard_NoSuchObject; +class SMDS_MeshElement; +class SMDS_MeshElementMapHasher; +class SMDS_ExtendedMap; +class SMDS_StdMapNodeOfExtendedMap; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MapIteratorOfExtendedMap : public TCollection_BasicMapIterator { + +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_MapIteratorOfExtendedMap(); +Standard_EXPORT SMDS_MapIteratorOfExtendedMap(const SMDS_ExtendedMap& aMap); +Standard_EXPORT void Initialize(const SMDS_ExtendedMap& aMap) ; +Standard_EXPORT const Handle_SMDS_MeshElement& Key() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx b/src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx new file mode 100644 index 000000000..b0831e3f5 --- /dev/null +++ b/src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx @@ -0,0 +1,48 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MapIteratorOfExtendedMap.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif +#ifndef _SMDS_ExtendedMap_HeaderFile +#include "SMDS_ExtendedMap.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_() +#define TCollection_Map SMDS_ExtendedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx b/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx new file mode 100644 index 000000000..d505ac7ac --- /dev/null +++ b/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx @@ -0,0 +1,102 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile +#define _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif +class Standard_NoSuchObject; +class SMDS_MeshElement; +class SMDS_MeshOrientedElementMapHasher; +class SMDS_ExtendedOrientedMap; +class SMDS_StdMapNodeOfExtendedOrientedMap; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MapIteratorOfExtendedOrientedMap : public TCollection_BasicMapIterator { + +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_MapIteratorOfExtendedOrientedMap(); +Standard_EXPORT SMDS_MapIteratorOfExtendedOrientedMap(const SMDS_ExtendedOrientedMap& aMap); +Standard_EXPORT void Initialize(const SMDS_ExtendedOrientedMap& aMap) ; +Standard_EXPORT const Handle_SMDS_MeshElement& Key() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx b/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx new file mode 100644 index 000000000..87ddaf91f --- /dev/null +++ b/src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx @@ -0,0 +1,48 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile +#include "SMDS_MeshOrientedElementMapHasher.hxx" +#endif +#ifndef _SMDS_ExtendedOrientedMap_HeaderFile +#include "SMDS_ExtendedOrientedMap.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshOrientedElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +#define TCollection_Map SMDS_ExtendedOrientedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_MapNode.lxx b/src/SMDS/SMDS_MapNode.lxx new file mode 100644 index 000000000..f4dd175e5 --- /dev/null +++ b/src/SMDS/SMDS_MapNode.lxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_MapNode.lxx has disappeared diff --git a/src/SMDS/SMDS_MapOfMeshElement.cdl b/src/SMDS/SMDS_MapOfMeshElement.cdl new file mode 100644 index 000000000..2033419ad --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.cdl @@ -0,0 +1,60 @@ +-- File: SMDS_MapOfMeshElement.cdl +-- Created: Fri Jan 25 11:39:17 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MapOfMeshElement from SMDS inherits ExtendedMap from SMDS + + ---Purpose: Redefinition/definition of methods of Map from TCollection + +uses + MeshElement from SMDS + +raises + NoSuchObject from Standard + +is + Create(NbBuckets : Integer =1) returns MapOfMeshElement from SMDS; + ---Purpose: Creates a Map with buckets. Without + -- arguments the map is automatically dimensioned. + ---C++: inline + + Find(me; K : MeshElement) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the Key in the Map. + ---Trigger: An exception is raised when is not in the map. + raises NoSuchObject from Standard + ---C++: alias operator() + ---C++: return const & + is static; + + ChangeFind(me : in out; K : MeshElement) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the Key in the + -- Map. This Item can be modified with the syntax + -- aMap(K) = newItem; + ---Trigger: An exception is raised when is not in the map. + ---C++: alias operator() + ---C++: return & + raises NoSuchObject from Standard + is static; + + FindID(me; ID : Integer) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the ID in the Map. + ---Trigger: An exception is raised when ID is not in the map. + raises NoSuchObject from Standard + ---C++: alias operator() + ---C++: return const & + is static; + + + ContainsID(me; ID : Integer) returns Boolean + ---Level: Public + ---Purpose: Returns True if the ID is stored in the + -- map . + is static; + +end MapOfMeshElement; diff --git a/src/SMDS/SMDS_MapOfMeshElement.cxx b/src/SMDS/SMDS_MapOfMeshElement.cxx new file mode 100644 index 000000000..f85b90a22 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.cxx @@ -0,0 +1,131 @@ +using namespace std; +// File: SMDS_MapOfMeshElement.cxx +// Created: Fri Jan 25 11:47:26 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MapOfMeshElement.ixx" +#include + + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_() +#define TCollection_Map SMDS_ExtendedMap +#define TCollection_Map_hxx + + + +//======================================================================= +//function : Find +//purpose : +//======================================================================= + +const Handle(SMDS_MeshElement)& SMDS_MapOfMeshElement::Find(const TheKey& K) const +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::Find"); + } +// Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshElement::Find"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[Hasher::HashCode(K,NbBuckets())]; + while (p) { + if (Hasher::IsEqual(p->Key(),K)) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::Find"); + return p->Key(); +} + +//======================================================================= +//function : ChangeFind +//purpose : +//======================================================================= + +Handle(SMDS_MeshElement)& SMDS_MapOfMeshElement::ChangeFind(const TheKey& K) +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::ChangeFind"); + } +//Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshElement::ChangeFind"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[Hasher::HashCode(K,NbBuckets())]; + while (p) { + if (Hasher::IsEqual(p->Key(),K)) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::ChangeFind"); + return p->Key(); +} + + +//======================================================================= +//function : FindID +//purpose : +//======================================================================= + +const Handle(SMDS_MeshElement)& SMDS_MapOfMeshElement::FindID(const Standard_Integer ID) const +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::FindID"); + } +// Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshElement::Find"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[ID % NbBuckets()]; + while (p) { + if (p->Key()->GetID() == ID) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshElement::Find"); + return p->Key(); +} + +//======================================================================= +//function : ContainsID +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MapOfMeshElement::ContainsID(const Standard_Integer ID) const +{ + if (IsEmpty()) return Standard_False; + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[ID % NbBuckets()]; + while (p) { + if (p->Key()->GetID() == ID) { + return Standard_True; + } + p = (TCollection_StdMapNode*)p->Next(); + } + return Standard_False; +} diff --git a/src/SMDS/SMDS_MapOfMeshElement.hxx b/src/SMDS/SMDS_MapOfMeshElement.hxx new file mode 100644 index 000000000..aef4e4448 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.hxx @@ -0,0 +1,119 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#define _SMDS_MapOfMeshElement_HeaderFile + +#ifndef _SMDS_ExtendedMap_HeaderFile +#include "SMDS_ExtendedMap.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMDS_MeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MapOfMeshElement : public SMDS_ExtendedMap { + +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 SMDS_MapOfMeshElement(const Standard_Integer NbBuckets = 1); +Standard_EXPORT const Handle_SMDS_MeshElement& Find(const Handle(SMDS_MeshElement)& K) const; + const Handle_SMDS_MeshElement& operator()(const Handle(SMDS_MeshElement)& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMDS_MeshElement& ChangeFind(const Handle(SMDS_MeshElement)& K) ; + Handle_SMDS_MeshElement& operator()(const Handle(SMDS_MeshElement)& K) +{ + return ChangeFind(K); +} + +Standard_EXPORT const Handle_SMDS_MeshElement& FindID(const Standard_Integer ID) const; + const Handle_SMDS_MeshElement& operator()(const Standard_Integer ID) const +{ + return FindID(ID); +} + +Standard_EXPORT Standard_Boolean ContainsID(const Standard_Integer ID) const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_MapOfMeshElement.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MapOfMeshElement.ixx b/src/SMDS/SMDS_MapOfMeshElement.ixx new file mode 100644 index 000000000..d6a7c11cc --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MapOfMeshElement.jxx" + + + + diff --git a/src/SMDS/SMDS_MapOfMeshElement.jxx b/src/SMDS/SMDS_MapOfMeshElement.jxx new file mode 100644 index 000000000..816ba77ab --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.jxx @@ -0,0 +1,9 @@ +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif diff --git a/src/SMDS/SMDS_MapOfMeshElement.lxx b/src/SMDS/SMDS_MapOfMeshElement.lxx new file mode 100644 index 000000000..82a06100b --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshElement.lxx @@ -0,0 +1,12 @@ +// File: SMDS_MapOfMeshElement.lxx +// Created: Fri Jan 25 11:43:44 2002 +// Author: Jean-Michel BOULCOURT +// + +#include + +inline SMDS_MapOfMeshElement::SMDS_MapOfMeshElement( + const Standard_Integer NbBuckets ): + SMDS_ExtendedMap( NbBuckets ) +{} + diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.cdl b/src/SMDS/SMDS_MapOfMeshOrientedElement.cdl new file mode 100644 index 000000000..1956d8b70 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.cdl @@ -0,0 +1,60 @@ +-- File: SMDS_MapOfMeshOrientedElement.cdl +-- Created: Fri Jan 25 11:39:17 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MapOfMeshOrientedElement from SMDS inherits ExtendedOrientedMap from SMDS + + ---Purpose: Redefinition/definition of methods of Map from TCollection + +uses + MeshElement from SMDS + +raises + NoSuchObject from Standard + +is + Create(NbBuckets : Integer =1) returns MapOfMeshOrientedElement from SMDS; + ---Purpose: Creates a Map with buckets. Without + -- arguments the map is automatically dimensioned. + ---C++: inline + + Find(me; K : MeshElement) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the Key in the Map. + ---Trigger: An exception is raised when is not in the map. + raises NoSuchObject from Standard + ---C++: alias operator() + ---C++: return const & + is static; + + ChangeFind(me : in out; K : MeshElement) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the Key in the + -- Map. This Item can be modified with the syntax + -- aMap(K) = newItem; + ---Trigger: An exception is raised when is not in the map. + ---C++: alias operator() + ---C++: return & + raises NoSuchObject from Standard + is static; + + FindID(me; ID : Integer) returns MeshElement + ---Level: Public + ---Purpose: Returns the Item stored with the ID in the Map. + ---Trigger: An exception is raised when ID is not in the map. + raises NoSuchObject from Standard + ---C++: alias operator() + ---C++: return const & + is static; + + + ContainsID(me; ID : Integer) returns Boolean + ---Level: Public + ---Purpose: Returns True if the ID is stored in the + -- map . + is static; + +end MapOfMeshOrientedElement; diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.cxx b/src/SMDS/SMDS_MapOfMeshOrientedElement.cxx new file mode 100644 index 000000000..cc0cd099b --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.cxx @@ -0,0 +1,131 @@ +using namespace std; +// File: SMDS_MapOfMeshOrientedElement.cxx +// Created: Fri Jan 25 11:47:26 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MapOfMeshOrientedElement.ixx" +#include + + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif +#ifndef _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" +#endif + + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +#define TCollection_Map SMDS_ExtendedOrientedMap +#define TCollection_Map_hxx + + + +//======================================================================= +//function : Find +//purpose : +//======================================================================= + +const Handle(SMDS_MeshElement)& SMDS_MapOfMeshOrientedElement::Find(const TheKey& K) const +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::Find"); + } +// Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshOrientedElement::Find"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[Hasher::HashCode(K,NbBuckets())]; + while (p) { + if (Hasher::IsEqual(p->Key(),K)) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::Find"); + return p->Key(); +} + +//======================================================================= +//function : ChangeFind +//purpose : +//======================================================================= + +Handle(SMDS_MeshElement)& SMDS_MapOfMeshOrientedElement::ChangeFind(const TheKey& K) +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::ChangeFind"); + } +//Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshOrientedElement::ChangeFind"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[Hasher::HashCode(K,NbBuckets())]; + while (p) { + if (Hasher::IsEqual(p->Key(),K)) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::ChangeFind"); + return p->Key(); +} + + +//======================================================================= +//function : FindID +//purpose : +//======================================================================= + +const Handle(SMDS_MeshElement)& SMDS_MapOfMeshOrientedElement::FindID(const Standard_Integer ID) const +{ + if (IsEmpty()) { + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::FindID"); + } +// Standard_NoSuchObject_Raise_if(IsEmpty(),"SMDS_MapOfMeshOrientedElement::Find"); + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[ID % NbBuckets()]; + while (p) { + if (p->Key()->GetID() == ID) { + return p->Key(); + } + p = (TCollection_StdMapNode*) p->Next(); + } + Standard_NoSuchObject::Raise("SMDS_MapOfMeshOrientedElement::Find"); + return p->Key(); +} + +//======================================================================= +//function : ContainsID +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MapOfMeshOrientedElement::ContainsID(const Standard_Integer ID) const +{ + if (IsEmpty()) return Standard_False; + TCollection_StdMapNode** data = (TCollection_StdMapNode**) myData1; + TCollection_StdMapNode* p = data[ID % NbBuckets()]; + while (p) { + if (p->Key()->GetID() == ID) { + return Standard_True; + } + p = (TCollection_StdMapNode*)p->Next(); + } + return Standard_False; +} diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.hxx b/src/SMDS/SMDS_MapOfMeshOrientedElement.hxx new file mode 100644 index 000000000..c4139e7f6 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.hxx @@ -0,0 +1,119 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MapOfMeshOrientedElement_HeaderFile +#define _SMDS_MapOfMeshOrientedElement_HeaderFile + +#ifndef _SMDS_ExtendedOrientedMap_HeaderFile +#include "SMDS_ExtendedOrientedMap.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMDS_MeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MapOfMeshOrientedElement : public SMDS_ExtendedOrientedMap { + +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 SMDS_MapOfMeshOrientedElement(const Standard_Integer NbBuckets = 1); +Standard_EXPORT const Handle_SMDS_MeshElement& Find(const Handle(SMDS_MeshElement)& K) const; + const Handle_SMDS_MeshElement& operator()(const Handle(SMDS_MeshElement)& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMDS_MeshElement& ChangeFind(const Handle(SMDS_MeshElement)& K) ; + Handle_SMDS_MeshElement& operator()(const Handle(SMDS_MeshElement)& K) +{ + return ChangeFind(K); +} + +Standard_EXPORT const Handle_SMDS_MeshElement& FindID(const Standard_Integer ID) const; + const Handle_SMDS_MeshElement& operator()(const Standard_Integer ID) const +{ + return FindID(ID); +} + +Standard_EXPORT Standard_Boolean ContainsID(const Standard_Integer ID) const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_MapOfMeshOrientedElement.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.ixx b/src/SMDS/SMDS_MapOfMeshOrientedElement.ixx new file mode 100644 index 000000000..8b5c67a72 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MapOfMeshOrientedElement.jxx" + + + + diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.jxx b/src/SMDS/SMDS_MapOfMeshOrientedElement.jxx new file mode 100644 index 000000000..9f32c1fb6 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.jxx @@ -0,0 +1,9 @@ +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MapOfMeshOrientedElement_HeaderFile +#include "SMDS_MapOfMeshOrientedElement.hxx" +#endif diff --git a/src/SMDS/SMDS_MapOfMeshOrientedElement.lxx b/src/SMDS/SMDS_MapOfMeshOrientedElement.lxx new file mode 100644 index 000000000..c4396f2f6 --- /dev/null +++ b/src/SMDS/SMDS_MapOfMeshOrientedElement.lxx @@ -0,0 +1,12 @@ +// File: SMDS_MapOfMeshOrientedElement.lxx +// Created: Fri Jan 25 11:43:44 2002 +// Author: Jean-Michel BOULCOURT +// + +#include + +inline SMDS_MapOfMeshOrientedElement::SMDS_MapOfMeshOrientedElement( + const Standard_Integer NbBuckets ): + SMDS_ExtendedOrientedMap( NbBuckets ) +{} + diff --git a/src/SMDS/SMDS_Mesh.cdl b/src/SMDS/SMDS_Mesh.cdl new file mode 100755 index 000000000..96b1e7c6c --- /dev/null +++ b/src/SMDS/SMDS_Mesh.cdl @@ -0,0 +1,408 @@ +-- File: SMDS_Mesh.cdl +-- Created: Wed Jan 23 12:08:54 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class Mesh from SMDS inherits MeshObject from SMDS + + ---Purpose: + +uses + MeshNodeIDFactory from SMDS, + MeshElementIDFactory from SMDS, + ListOfMeshElement from SMDS, + ListOfMesh from SMDS, + MapOfMeshOrientedElement from SMDS, + MeshElement from SMDS, + MeshNode from SMDS, + ListIteratorOfListOfMesh from SMDS +raises + + NoSuchObject from Standard +is + + ---================================ + ---Category: public API methods + -- Mesh creation + --================================= + + Create(nbnodes: Integer = 10; nbedges : Integer = 10; + nbfaces : Integer = 10; nbvolumes : Integer = 10) returns mutable Mesh; + ---Purpose: create a new mesh. It is possible to specify the + -- initial size of elements. + -- It is recommended to set the size of mesh elements + -- in the constructor to avoid too much resizing of data storage + + AddSubMesh(me: mutable) returns Mesh from SMDS + ---Purpose: create an submesh. + -- uses a private constructor to create a instance of the submesh + -- and attach it to the mesh parent. + is static; + + + + ---================================ + ---Category: public API methods + -- Mesh Element creation + --================================= + + -- *** Nodes *** -- + + + AddNode(me: mutable; x,y,z : Real) returns Integer + ---Purpose: create an instance of MeshNode and add it to the mesh + -- if the mesh has a parent then the node is also added + -- to the parent mesh. + -- Returns a generated ID for the created node. + is virtual; + + AddNodeWithID(me: mutable; x,y,z : Real; ID: Integer) returns Boolean + ---Purpose: create an instance of MeshNode and add it to the mesh + -- if the mesh has a parent then the node is also added + -- to the parent mesh. + -- returns False in case the ID already exists + is virtual; + + AddNode(me: mutable; ID : Integer) returns Boolean + ---Purpose: add an existing node in the mesh. This is useful to + -- add a node from a parent mesh to the submesh + is virtual; + + + -- *** Edges *** -- + + AddEdge(me: mutable; idnode1, idnode2 : Integer) returns Integer + ---Purpose: create an instance of MeshEdge and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddEdgeWithID(me: mutable; idnode1, idnode2, ID : Integer) returns Boolean + ---Purpose: create an instance of MeshEdge and add it to the mesh + is virtual; + + + -- *** Faces *** -- + + AddFace(me: mutable; idnode1, idnode2, idnode3 : Integer) returns Integer + ---Purpose: create an instance of MeshFace and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddFaceWithID(me: mutable; idnode1, idnode2, idnode3, ID : Integer) returns Boolean + ---Purpose: create an instance of MeshFace and add it to the mesh + is virtual; + + + AddFace(me: mutable; idnode1, idnode2, idnode3, idnode4 : Integer) + returns Integer + ---Purpose: create an instance of MeshFace and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddFaceWithID(me: mutable; idnode1, idnode2, idnode3, idnode4, ID : Integer) + returns Boolean + ---Purpose: create an instance of MeshFace and add it to the mesh + is virtual; + + + + -- *** Volumes *** -- + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4 : Integer) + returns Integer + ---Purpose: create an instance of MeshVolume and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddVolumeWithID(me: mutable; idnode1, idnode2, idnode3, idnode4, ID : Integer) + returns Boolean + ---Purpose: create an instance of MeshVolume and add it to the mesh + is virtual; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5 : Integer) + returns Integer + ---Purpose: create an instance of MeshVolume and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddVolumeWithID(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, ID : Integer) + returns Boolean + ---Purpose: create an instance of MeshVolume and add it to the mesh + is virtual; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6 : Integer) + returns Integer + ---Purpose: create an instance of MeshVolume and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddVolumeWithID(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, ID : Integer) + returns Boolean + ---Purpose: create an instance of MeshVolume and add it to the mesh + is virtual; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, + idnode7, idnode8 : Integer) + returns Integer + ---Purpose: create an instance of MeshVolume and add it to the mesh + -- returns the id of the element. Returns 0 if creation failed + is virtual; + + AddVolumeWithID(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, + idnode7, idnode8, ID : Integer) + returns Boolean + ---Purpose: create an instance of MeshVolume and add it to the mesh + is virtual; + + + AddVolume(me: mutable; node1, node2, node3, node4 : MeshElement) + returns MeshElement from SMDS + ---Purpose: create an instance of MeshVolume and add it to the mesh + is static; + + AddVolume(me: mutable; node1, node2, node3, node4, node5 : MeshElement) + returns MeshElement from SMDS + ---Purpose: create an instance of MeshVolume and add it to the mesh + is static; + + AddVolume(me: mutable; node1, node2, node3, node4, node5, node6 : MeshElement) + returns MeshElement from SMDS + ---Purpose: create an instance of MeshVolume and add it to the mesh + is static; + + AddVolume(me: mutable; node1, node2, node3, node4, + node5, node6, node7, node8 : MeshElement) + returns MeshElement from SMDS + ---Purpose: create an instance of MeshVolume and add it to the mesh + is static; + + + + ---================================ + ---Category: public API methods + -- Mesh Element deletion + --================================= + + + RemoveNode(me: mutable; IDnode: Integer) + ---Purpose: remove the node IDnode in the mesh and in all the children mesh + -- if it exists, it remains in the parent mesh + -- if the mesh has no parent, then ID is released + is virtual; + + RemoveEdge(me: mutable; idnode1, idnode2 : Integer) + ---Purpose: remove the edge defined by idnode1,idnode2 in the mesh + is virtual; + + RemoveFace(me: mutable; idnode1, idnode2, idnode3 : Integer) + ---Purpose: remove the face defined by idnode1,idnode2,idnode3 in the mesh + is virtual; + + RemoveFace(me: mutable; idnode1, idnode2, idnode3, idnode4 : Integer) + ---Purpose: remove the face defined by idnode1,idnode2,idnode3,idnode4 in the mesh + is virtual; + + RemoveElement(me: mutable; IDelem : Integer;removenodes : Boolean = Standard_False) + ---Purpose: remove the mesh element IDelem + -- Caution : Cannot be used to remove nodes, instead + -- use method RemoveNode + is virtual; + + RemoveElement(me: mutable; elem: MeshElement;removenodes : Boolean = Standard_False) + is static; + + RemoveFromParent(me: mutable) + returns Boolean + ---Purpose: remove this from its parent + -- if this has no parent then it returns False (True otherwise) + is virtual; + + RemoveSubMesh(me: mutable; aMesh : Mesh from SMDS) + returns Boolean + ---Purpose: remove aMesh from the list of Children + -- if the submesh does not belong to this, it returns False + -- (True otherwiswe) + is virtual; + + ---================================ + ---Category: public API methods + -- Mesh exploration + --================================= + + GetNode(me; rank: Integer; ME: MeshElement) returns MeshNode from SMDS + is static; + + FindNode(me; idnode: Integer) returns MeshElement from SMDS + ---Purpose: return the meshnode idnode in the mesh + is static; + + FindEdge(me; idnode1, idnode2: Integer) returns MeshElement from SMDS + ---Purpose: + is static; + + FindFace(me; idnode1, idnode2, idnode3: Integer) returns MeshElement from SMDS + ---Purpose: + is static; + + FindFace(me; idnode1, idnode2, idnode3, idnode4: Integer) returns MeshElement from SMDS + ---Purpose: + is static; + + FindElement(me; IDelem: Integer) returns MeshElement from SMDS + ---Purpose: returns the mesh element corresponding to IDelem + is static; + + Contains(me; elem: MeshElement) returns Boolean + ---Purpose: + is static; + + RebuildAllInverseConnections(me: mutable) + ---Purpose: clean the inverse connections and rebuild them + -- completely. If the mesh has children, the + -- inverse connections are also rebuilt + is static; + + SubMeshIterator(me;itmsh: out ListIteratorOfListOfMesh from SMDS) + ---Purpose: + is static; + + + NbNodes(me) returns Integer; + ---C++: inline + + NbEdges(me) returns Integer; + ---C++: inline + + NbFaces(me) returns Integer; + ---C++: inline + + NbVolumes(me) returns Integer; + ---C++: inline + + NbSubMesh(me) returns Integer; + ---C++: inline + + DumpNodes(me); + + DumpEdges(me); + + DumpFaces(me); + + DumpVolumes(me); + + DebugStats(me); + + + + ---Category: private or protected methods + -- + + Create(parent: Mesh; nbnodes: Integer = 10) returns mutable Mesh + ---Purpose: constructor used internally to create submesh + -- + is private; + + AddNode(me: mutable; node : MeshElement ) returns Boolean + ---Purpose: add a node in the mesh + -- if the mesh has parent, the node is also added to the parent. + -- returns False if the node is invalid ( null handle) + is private; + + CreateEdge(me; ID, idnode1, idnode2 : Integer) returns MeshElement from SMDS; + + CreateFace(me; ID, idnode1, idnode2, idnode3 : Integer) returns MeshElement from SMDS; + + CreateFace(me; ID, idnode1, idnode2, idnode3, idnode4 : Integer) + returns MeshElement from SMDS; + + CreateVolume(me; ID, idnode1, idnode2, idnode3, idnode4 : Integer) + returns MeshElement from SMDS; + + CreateVolume(me; ID, idnode1, idnode2, idnode3, idnode4, idnode5 : Integer) + returns MeshElement from SMDS; + + CreateVolume(me; ID, idnode1, idnode2, idnode3, idnode4, idnode5, idnode6 : Integer) + returns MeshElement from SMDS; + + CreateVolume(me; ID, idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, idnode7, idnode8 : Integer) + returns MeshElement from SMDS; + + + FindNode(me; node: MeshElement) returns MeshElement from SMDS + ---Purpose: + is protected; + + FindEdge(me; edge: MeshElement) returns MeshElement from SMDS + ---Purpose: + is protected; + + FindFace(me; face: MeshElement) returns MeshElement from SMDS + ---Purpose: + is protected; + + FindVolume(me; volume: MeshElement) returns MeshElement from SMDS + ---Purpose: + is protected; + + + RemoveInverseElement(me; node,parent : MeshElement) + ---Purpose: + is protected; + + FreeNode(me: mutable; node: MeshElement) + is private; + + RemoveNode(me: mutable; node: MeshElement) returns Boolean + is protected; + + RemoveEdge(me: mutable; edge: MeshElement) + is protected; + + RemoveFace(me: mutable; face: MeshElement) + is protected; + + RemoveVolume(me: mutable; volume: MeshElement) + is protected; + + + + GetNode(me; ID: Integer) returns MeshElement from SMDS + is protected; + + RemoveAncestors(me: mutable; ME: MeshElement from SMDS; map: MapOfMeshOrientedElement from SMDS) + is protected; + + BuildMapNodeAncestors(me; ME: MeshElement from SMDS;map: in out MapOfMeshOrientedElement from SMDS) + is private; + + BuildMapEdgeAncestors(me; ME: MeshElement from SMDS;map: in out MapOfMeshOrientedElement from SMDS) + is private; + + BuildMapFaceAncestors(me; ME: MeshElement from SMDS;map: in out MapOfMeshOrientedElement from SMDS) + is private; + + RebuildInverseConnections(me: mutable) + ---Purpose: + is private; + + +fields + + myNodes : MapOfMeshOrientedElement from SMDS; + myEdges : MapOfMeshOrientedElement from SMDS; + myFaces : MapOfMeshOrientedElement from SMDS; + myVolumes : MapOfMeshOrientedElement from SMDS; + myParent : Mesh from SMDS; + myChildren : ListOfMesh from SMDS; + myNodeIDFactory : MeshNodeIDFactory from SMDS; + myElementIDFactory : MeshElementIDFactory from SMDS; + myHasInverse : Boolean; +friends + class MeshVolumesIterator from SMDS, + class MeshFacesIterator from SMDS, + class MeshEdgesIterator from SMDS, + class MeshNodesIterator from SMDS + +end Mesh; diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx new file mode 100644 index 000000000..5eaf68c76 --- /dev/null +++ b/src/SMDS/SMDS_Mesh.cxx @@ -0,0 +1,1472 @@ +using namespace std; +// File: SMDS_Mesh.cxx +// Created: Wed Jan 23 16:49:00 2002 +// Author: Jean-Michel BOULCOURT +// + + +#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 +#include + +#include "utilities.h" + + +//======================================================================= +//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) +{ +} + +//======================================================================= +//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) +{ +} + +//======================================================================= +//function : AddSubMesh +//purpose : create an submesh +//======================================================================= + +Handle(SMDS_Mesh) SMDS_Mesh::AddSubMesh() +{ + Handle(SMDS_Mesh) submesh = new SMDS_Mesh(this); + if (!submesh.IsNull()) { + myChildren.Append(submesh); + } + + return submesh; +} + + +//======================================================================= +//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) +{ + Standard_Integer ID = myNodeIDFactory->GetFreeID(); + + Handle(SMDS_MeshElement) node = new SMDS_MeshNode(ID,x,y,z); + AddNode(node); + + return ID; +} + +//======================================================================= +//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) +{ + + // 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; + +} + +//======================================================================= +//function : AddEdge +//purpose : +//======================================================================= + +Standard_Boolean SMDS_Mesh::AddEdgeWithID(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer ID) +{ + 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; + +} + +//======================================================================= +//function : AddFace +//purpose : +//======================================================================= + +Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + Standard_Integer ID = myElementIDFactory->GetFreeID(); + + if (AddFaceWithID(idnode1,idnode2,idnode3,ID)) + return ID; + else + return 0; + +} + +//======================================================================= +//function : AddFace +//purpose : +//======================================================================= + +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); + } + successAdd = myElementIDFactory->BindID(ID,face); + } + } + } + + return successAdd; + +} + + +//======================================================================= +//function : AddFace +//purpose : +//======================================================================= + +Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Standard_Integer ID = myElementIDFactory->GetFreeID(); + + if (AddFaceWithID(idnode1,idnode2,idnode3,idnode4,ID)) + return ID; + else + return 0; + +} + + +//======================================================================= +//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); + } + } + } + } + + 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) +{ + Standard_Integer ID = myElementIDFactory->GetFreeID(); + + if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,ID)) + return ID; + else + return 0; + +} + +//======================================================================= +//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); + } + } + } + } + + 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) +{ + Standard_Integer ID = myElementIDFactory->GetFreeID(); + + if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,idnode5,ID)) + return ID; + else + return 0; + +} + +//======================================================================= +//function : AddVolume +//purpose : Pyramid +//======================================================================= + +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); + } + } + } + } + } + + return successAdd; + +} + +//======================================================================= +//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) +{ + Standard_Integer ID = myElementIDFactory->GetFreeID(); + + if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4, + idnode5,idnode6,ID)) + return ID; + else + return 0; + +} + +//======================================================================= +//function : AddVolume +//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); + } + } + } + } + } + } + + 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; + +} + +//======================================================================= +//function : AddVolume +//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); + } + } + } + } + } + } + } + } + + 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; +} + +//======================================================================= +//function : FindNode +//purpose : +//======================================================================= + +Handle(SMDS_MeshElement) SMDS_Mesh::FindNode(const Handle(SMDS_MeshElement)& node) const +{ + Handle(SMDS_MeshElement) elem; + if (myNodes.Contains(node)) + elem = myNodes.Find(node); + + return elem; +} + +//======================================================================= +//function : CreateEdge +//purpose : +//======================================================================= + +Handle(SMDS_MeshElement) SMDS_Mesh::CreateEdge(const Standard_Integer ID, + const Standard_Integer idnode1, + const Standard_Integer idnode2) const +{ + 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 : +//======================================================================= + +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; +} + + +//======================================================================= +//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()); + } +} + + + +//======================================================================= +//function : RemoveNode +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveNode(const Standard_Integer 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); + } + } + +} + +//======================================================================= +//function : RemoveNode +//purpose : +//======================================================================= + +Standard_Boolean SMDS_Mesh::RemoveNode(const Handle(SMDS_MeshElement)& 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; +} + +//======================================================================= +//function : RemoveEdge +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveEdge(const Standard_Integer idnode1, const Standard_Integer idnode2) +{ + Handle(SMDS_MeshElement) edge = FindEdge(idnode1,idnode2); + RemoveEdge(edge); +} + +//======================================================================= +//function : RemoveEdge +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveEdge(const Handle(SMDS_MeshElement)& edge) +{ + + if (!edge.IsNull()) { + myEdges.Remove(edge); + + myElementIDFactory->ReleaseID(edge->GetID()); + } +} + + +//======================================================================= +//function : RemoveFace +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3); + RemoveFace(face); +} + +//======================================================================= +//function : RemoveFace +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3,idnode4); + RemoveFace(face); +} + + +//======================================================================= +//function : RemoveFace +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveFace(const Handle(SMDS_MeshElement)& face) +{ + if (!face.IsNull()) { + myFaces.Remove(face); + myElementIDFactory->ReleaseID(face->GetID()); + } +} + +//======================================================================= +//function : RemoveVolume +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveVolume(const Handle(SMDS_MeshElement)& volume) +{ + if (myVolumes.Contains(volume)) { + myVolumes.Remove(volume); + myElementIDFactory->ReleaseID(volume->GetID()); + } +} + +//======================================================================= +//function : RemoveElement +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveElement(const Standard_Integer IDelem,const Standard_Boolean removenodes) +{ + Handle(SMDS_MeshElement) elem = myElementIDFactory->MeshElement(IDelem); + RemoveElement(elem,removenodes); + + + +} + +//======================================================================= +//function : RemoveElement +//purpose : +//======================================================================= + +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 : +//======================================================================= + +Standard_Boolean SMDS_Mesh::RemoveFromParent() +{ + if (myParent.IsNull()) + return Standard_False; + + return (myParent->RemoveSubMesh(this)); + +} + +//======================================================================= +//function : RemoveSubMesh +//purpose : +//======================================================================= + +Standard_Boolean SMDS_Mesh::RemoveSubMesh(const Handle(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); + } + } + + 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); + } + + } + +} + + +//======================================================================= +//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 : +//======================================================================= + +Handle(SMDS_MeshElement) SMDS_Mesh::FindEdge(const Standard_Integer idnode1, + const Standard_Integer idnode2 ) const +{ + Handle(SMDS_MeshEdge) edge = new SMDS_MeshEdge(0,idnode1,idnode2); + return FindEdge(edge); +} + +//======================================================================= +//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); +} + +//======================================================================= +//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); +} + +//======================================================================= +//function : FindElement +//purpose : +//======================================================================= + +Handle(SMDS_MeshElement) SMDS_Mesh::FindElement(const Standard_Integer IDelem) const +{ + return myElementIDFactory->MeshElement(IDelem); +} + +//======================================================================= +//function : GetNode +//purpose : +//======================================================================= + +Handle(SMDS_MeshNode) SMDS_Mesh::GetNode(const Standard_Integer rank, + const Handle(SMDS_MeshElement)& ME) 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; + +} + + +//======================================================================= +//function : DumpNodes +//purpose : +//======================================================================= + +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); + + } + +} + + + +//======================================================================= +//function : DumpEdges +//purpose : +//======================================================================= + +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); + } +} + + + +//======================================================================= +//function : DumpFaces +//purpose : +//======================================================================= + +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); + } +} + + +//======================================================================= +//function : DumpVolumes +//purpose : +//======================================================================= + +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); + } +} + + + +//======================================================================= +//function : DebugStats +//purpose : +//======================================================================= + +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 " ); + + //#ifdef DEB + SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes); + Standard_Integer sizeofnodes = 0; + Standard_Integer sizeoffaces = 0; + + + for (;itnode.More();itnode.Next()) { + const Handle(SMDS_MeshElement)& node = itnode.Key(); + + Standard_Transient *p = node->This(); + sizeofnodes += sizeof( *((SMDS_MeshNode *)p) ); + + SMDS_ListIteratorOfListOfMeshElement it(node->InverseElements()); + for (;it.More();it.Next()) { + const Handle(SMDS_MeshElement)& me = it.Value(); + sizeofnodes += sizeof(me); + } + + } + + SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces); + + 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 );; + + //#endif + +} + +//======================================================================= +//function : RebuildAllInverseConnections +//purpose : +//======================================================================= + +void SMDS_Mesh::RebuildAllInverseConnections() +{ + if (!myParent.IsNull()) + myParent->RebuildAllInverseConnections(); + + else { + // Clear all inverseconnections from nodes + SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes); + + for (;itnode.More();itnode.Next()) { + const Handle(SMDS_MeshElement)& elem = itnode.Key(); + elem->ClearInverseElements(); + } + + + RebuildInverseConnections(); + + SMDS_ListIteratorOfListOfMesh itmsh(myChildren); + for (;itmsh.More(); itmsh.Next()) { + Handle(SMDS_Mesh) submesh; + submesh = itmsh.Value(); + + submesh->RebuildInverseConnections(); + + } + } +} + +//======================================================================= +//function : RebuildInverseConnections +//purpose : +//======================================================================= + +void SMDS_Mesh::RebuildInverseConnections() +{ + // rebuld inverse connections to volumes + SMDS_MapIteratorOfExtendedOrientedMap itvol(myVolumes); + + for (;itvol.More();itvol.Next()) { + const Handle(SMDS_MeshElement)& vol = itvol.Key(); + + 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); + } + + } + + // rebuld inverse connections to faces + SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces); + + for (;itface.More();itface.Next()) { + const Handle(SMDS_MeshElement)& face = itface.Key(); + + 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); + } + + } + + // rebuld inverse connections to edges + SMDS_MapIteratorOfExtendedOrientedMap itedge(myEdges); + + for (;itedge.More();itedge.Next()) { + const Handle(SMDS_MeshElement)& edge = itedge.Key(); + + 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); + } + + } + + myHasInverse = Standard_True; +} + + +//======================================================================= +//function : SubMeshIterator +//purpose : returns the ith SubMesh +//======================================================================= + +void SMDS_Mesh::SubMeshIterator(SMDS_ListIteratorOfListOfMesh& itmsh) const +{ + itmsh.Initialize(myChildren); +} + diff --git a/src/SMDS/SMDS_Mesh.hxx b/src/SMDS/SMDS_Mesh.hxx new file mode 100644 index 000000000..e4db75a00 --- /dev/null +++ b/src/SMDS/SMDS_Mesh.hxx @@ -0,0 +1,224 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_Mesh_HeaderFile +#define _SMDS_Mesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#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 +#endif +#ifndef _Standard_Real_HeaderFile +#include +#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_Mesh.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_Mesh.ixx b/src/SMDS/SMDS_Mesh.ixx new file mode 100644 index 000000000..c81e2dae8 --- /dev/null +++ b/src/SMDS/SMDS_Mesh.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_Mesh.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_Mesh::~SMDS_Mesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_Mesh_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_Mesh", + sizeof(SMDS_Mesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_Mesh) Handle(SMDS_Mesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_Mesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_Mesh))) { + _anOtherObject = Handle(SMDS_Mesh)((Handle(SMDS_Mesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_Mesh::DynamicType() const +{ + return STANDARD_TYPE(SMDS_Mesh) ; +} +Standard_Boolean SMDS_Mesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_Mesh) == AType || SMDS_MeshObject::IsKind(AType)); +} +Handle_SMDS_Mesh::~Handle_SMDS_Mesh() {} + diff --git a/src/SMDS/SMDS_Mesh.jxx b/src/SMDS/SMDS_Mesh.jxx new file mode 100644 index 000000000..9f8349556 --- /dev/null +++ b/src/SMDS/SMDS_Mesh.jxx @@ -0,0 +1,36 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshNodeIDFactory_HeaderFile +#include "SMDS_MeshNodeIDFactory.hxx" +#endif +#ifndef _SMDS_MeshElementIDFactory_HeaderFile +#include "SMDS_MeshElementIDFactory.hxx" +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_MeshVolumesIterator_HeaderFile +#include "SMDS_MeshVolumesIterator.hxx" +#endif +#ifndef _SMDS_MeshFacesIterator_HeaderFile +#include "SMDS_MeshFacesIterator.hxx" +#endif +#ifndef _SMDS_MeshEdgesIterator_HeaderFile +#include "SMDS_MeshEdgesIterator.hxx" +#endif +#ifndef _SMDS_MeshNodesIterator_HeaderFile +#include "SMDS_MeshNodesIterator.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshNode_HeaderFile +#include "SMDS_MeshNode.hxx" +#endif +#ifndef _SMDS_MapOfMeshOrientedElement_HeaderFile +#include "SMDS_MapOfMeshOrientedElement.hxx" +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif diff --git a/src/SMDS/SMDS_Mesh.lxx b/src/SMDS/SMDS_Mesh.lxx new file mode 100644 index 000000000..fe73d5f71 --- /dev/null +++ b/src/SMDS/SMDS_Mesh.lxx @@ -0,0 +1,57 @@ +// File: SMDS_Mesh.lxx +// Created: Thu Jan 24 09:45:40 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : NbNodes +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Mesh::NbNodes() const +{ + return myNodes.Extent(); +} + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Mesh::NbEdges() const +{ + return myEdges.Extent(); +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Mesh::NbFaces() const +{ + return myFaces.Extent(); +} + +//======================================================================= +//function : NbVolumes +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Mesh::NbVolumes() const +{ + return myVolumes.Extent(); +} + + +//======================================================================= +//function : NbSubMesh +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Mesh::NbSubMesh() const +{ + return myChildren.Extent(); +} + + diff --git a/src/SMDS/SMDS_MeshEdge.cdl b/src/SMDS/SMDS_MeshEdge.cdl new file mode 100755 index 000000000..335d64aed --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.cdl @@ -0,0 +1,38 @@ +-- File: SMDS_MeshEdge.cdl +-- Created: Wed Jan 23 16:15:51 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshEdge from SMDS inherits MeshElement from SMDS + + ---Purpose: + +is + Create (ID,idnode1,idnode2: Integer) returns mutable MeshEdge; + + ComputeKey(me: mutable); + ---Purpose: compute the ID of the edge based on the id's of its + -- bounding nodes + ---C++: inline + + GetKey(me) returns Integer is redefined static; + ---C++: inline + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2: Integer) is private; + + Print(me; OS: in out OStream) is redefined static; + +fields + + myKey : Integer; + myNodes : Integer [2]; + +end MeshEdge; diff --git a/src/SMDS/SMDS_MeshEdge.cxx b/src/SMDS/SMDS_MeshEdge.cxx new file mode 100644 index 000000000..cbb448286 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.cxx @@ -0,0 +1,53 @@ +using namespace std; +// File: SMDS_MeshEdge.cxx +// Created: Wed Jan 23 17:02:20 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshEdge.ixx" + +//======================================================================= +//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(); +} + +//======================================================================= +//function : SetConnections +//purpose : +//======================================================================= +void SMDS_MeshEdge::SetConnections(const Standard_Integer idnode1, + const Standard_Integer idnode2) +{ + Standard_Integer idmin = (idnode1 < idnode2? idnode1 : idnode2); + + myNodes[0] = idmin; + if (idmin == idnode1) { + myNodes[1] = idnode2; + } else { + myNodes[1] = idnode1; + } +} + +//======================================================================= +//function : Print +//purpose : +//======================================================================= + +void SMDS_MeshEdge::Print(Standard_OStream& OS) const +{ + OS << "edge <" << myID <<"> : (" << myNodes[0] << " , " << myNodes[1] << ") " << endl; +} + + + + diff --git a/src/SMDS/SMDS_MeshEdge.hxx b/src/SMDS/SMDS_MeshEdge.hxx new file mode 100644 index 000000000..74c4e9351 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.hxx @@ -0,0 +1,113 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshEdge_HeaderFile +#define _SMDS_MeshEdge_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshEdge_HeaderFile +#include "Handle_SMDS_MeshEdge.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Standard_OStream_HeaderFile +#include +#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; + +protected: + + // Methods PROTECTED + // + + + // 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]; + + +}; + + +#include "SMDS_MeshEdge.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshEdge.ixx b/src/SMDS/SMDS_MeshEdge.ixx new file mode 100644 index 000000000..735bb4b67 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshEdge.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshEdge::~SMDS_MeshEdge() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshEdge_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshEdge", + sizeof(SMDS_MeshEdge), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshEdge) Handle(SMDS_MeshEdge)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshEdge) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshEdge))) { + _anOtherObject = Handle(SMDS_MeshEdge)((Handle(SMDS_MeshEdge)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshEdge::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshEdge) ; +} +Standard_Boolean SMDS_MeshEdge::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshEdge) == AType || SMDS_MeshElement::IsKind(AType)); +} +Handle_SMDS_MeshEdge::~Handle_SMDS_MeshEdge() {} + diff --git a/src/SMDS/SMDS_MeshEdge.jxx b/src/SMDS/SMDS_MeshEdge.jxx new file mode 100644 index 000000000..e5a7e1dd7 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshEdge_HeaderFile +#include "SMDS_MeshEdge.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshEdge.lxx b/src/SMDS/SMDS_MeshEdge.lxx new file mode 100644 index 000000000..42cde7c49 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdge.lxx @@ -0,0 +1,51 @@ +// File: SMDS_MeshEdge.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the edge based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshEdge::ComputeKey() +{ + // myKey = (myNodes[0] << 2) + myNodes[1]; + myKey = myNodes[0] + myNodes[1]; +} + +//======================================================================= +//function : GetKey +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshEdge::GetKey() const +{ + return myKey; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshEdge::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshEdge::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + diff --git a/src/SMDS/SMDS_MeshEdgesIterator.cdl b/src/SMDS/SMDS_MeshEdgesIterator.cdl new file mode 100644 index 000000000..79aa3c86c --- /dev/null +++ b/src/SMDS/SMDS_MeshEdgesIterator.cdl @@ -0,0 +1,35 @@ +-- File: SMDS_MeshEdgesIterator.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshEdgesIterator from SMDS inherits MeshElementsIterator from SMDS + + ---Purpose: The Iterator objet to iterate on all edges of a mesh + -- + +uses + Mesh from SMDS, + MeshElement from SMDS, + MapIteratorOfExtendedMap from SMDS + +raises + NoMoreObject, + NoSuchObject + +is + + Create returns MeshEdgesIterator from SMDS; + ---Purpose: Creates an empty Iterator. + + Create(M : Mesh from SMDS) returns MeshEdgesIterator from SMDS; + ---Purpose: Creates an Iterator on faces of mesh . + + Initialize(me : in out; M : Mesh from SMDS) + ---Purpose: Reset the Iterator on the faces of mesh . + is redefined static; + + +end MeshEdgesIterator; diff --git a/src/SMDS/SMDS_MeshEdgesIterator.cxx b/src/SMDS/SMDS_MeshEdgesIterator.cxx new file mode 100644 index 000000000..235855055 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdgesIterator.cxx @@ -0,0 +1,42 @@ +using namespace std; +// File: SMDS_MeshEdgesIterator.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshEdgesIterator.ixx" + +//======================================================================= +//function : SMDS_MeshEdgesIterator +//purpose : +//======================================================================= + +SMDS_MeshEdgesIterator::SMDS_MeshEdgesIterator() +{ +} + +//======================================================================= +//function : SMDS_MeshEdgesIterator +//purpose : +//======================================================================= + +SMDS_MeshEdgesIterator::SMDS_MeshEdgesIterator(const Handle(SMDS_Mesh)& M) +{ + Initialize(M); +} + +//======================================================================= +//function : Initialize +//purpose : +//======================================================================= + +void SMDS_MeshEdgesIterator::Initialize(const Handle(SMDS_Mesh)& M) +{ + + myMapIterator.Initialize(M->myEdges); + if (More()) { + myCurrentMeshElement = myMapIterator.Key(); + } +} + diff --git a/src/SMDS/SMDS_MeshEdgesIterator.hxx b/src/SMDS/SMDS_MeshEdgesIterator.hxx new file mode 100644 index 000000000..ed2b22bc6 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdgesIterator.hxx @@ -0,0 +1,96 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshEdgesIterator_HeaderFile +#define _SMDS_MeshEdgesIterator_HeaderFile + +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#include "SMDS_MeshElementsIterator.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_Mesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshEdgesIterator : public SMDS_MeshElementsIterator { + +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_MeshEdgesIterator(); +Standard_EXPORT SMDS_MeshEdgesIterator(const Handle(SMDS_Mesh)& M); +Standard_EXPORT void Initialize(const Handle(SMDS_Mesh)& M) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshEdgesIterator.ixx b/src/SMDS/SMDS_MeshEdgesIterator.ixx new file mode 100644 index 000000000..b30c842c9 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdgesIterator.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshEdgesIterator.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshEdgesIterator.jxx b/src/SMDS/SMDS_MeshEdgesIterator.jxx new file mode 100644 index 000000000..a6a892465 --- /dev/null +++ b/src/SMDS/SMDS_MeshEdgesIterator.jxx @@ -0,0 +1,12 @@ +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshEdgesIterator_HeaderFile +#include "SMDS_MeshEdgesIterator.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshElement.cdl b/src/SMDS/SMDS_MeshElement.cdl new file mode 100644 index 000000000..b14b6758e --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.cdl @@ -0,0 +1,115 @@ + +-- -- File: SMDS_MeshElement.cdl +-- Created: Wed Jan 23 12:09:23 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshElement from SMDS inherits MeshObject from SMDS + + ---Purpose: MeshElement is the base class for all mesh -- + -- elements that constitutes a mesh. The children + -- classes will include elements like Node, Edge, + -- Face, and Volume. + +uses + ListOfMeshElement from SMDS, + HArray1OfDir from TColgp, + Dir from gp, + Vec from gp, + ElementType from SMDSAbs + +raises + OutOfRange from Standard + +is + + Initialize(ID: Integer; NbConnections : Integer; + Type: ElementType from SMDSAbs) + returns mutable MeshElement; + + HashCode (me; Upper : Integer) returns Integer is redefined static; + ---Purpose: Returns a hashed value denoting . This value is in + -- the range 1... + ---C++: inline + + IsSame(me; other : MeshElement) returns Boolean; + ---Purpose: Returns True if two mesh elements are same but not + -- necessary the same orientation + ---C++: inline + + + IsEqual(me; other : MeshElement) returns Boolean; + ---Purpose: Returns True if two mesh elements are same and + -- havesame orientation + ---C++: inline + + + IsNodeInElement(me; idnode: Integer) returns Boolean; + ---Purpose: returns true or false if idnode is in the list of the + -- direct connections + ---C++: inline + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1, idnode2 : out Integer) is virtual; + ---Purpose: returns the idnodes of the ith edge (rank) of the face + -- rank must be comprised between 1 and myNbConnections included. + + GetFaceDefinedByNodes(me; rank: Integer; idnode : Address;nb: out Integer) is virtual; + ---Purpose: returns the idnodes of the ith edge (rank) of the face + -- rank must be comprised between 1 and myNbConnections included. + + GetConnections(me) returns Address + is virtual protected; + + GetConnection(me; rank: Integer) returns Integer is virtual; + + AddInverseElement(me:mutable; ME: MeshElement from SMDS) is virtual; + + InverseElements(me) returns ListOfMeshElement is virtual; + ---C++: return const & + + ClearInverseElements(me: mutable) is virtual; + + NbNodes(me) returns Integer; + ---C++: inline + + NbEdges(me) returns Integer + is virtual; + + NbFaces(me) returns Integer + is virtual; + + GetID(me) returns Integer; + ---Purpose: returns identifier of node + ---C++: inline + + GetKey(me) returns Integer is deferred; + ---Purpose: returns key for hashcode + + + SetNormal(me: mutable; rank: Integer; vx,vy,vz : Real) is virtual; + ---Purpose: set the rank th normal of the element + + SetNormal(me: mutable; rank: Integer; v : Vec from gp) is virtual; + ---Purpose: set the rank th normal of the element + + GetNormal(me:mutable; rank: Integer) returns Dir from gp is virtual; + ---Purpose: get the rank th normal of the element + + Print(me; OS: in out OStream) is virtual; + ---Purpose: + ---C++: alias "friend Standard_EXPORT Standard_OStream& operator << (Standard_OStream& OS, const Handle(SMDS_MeshElement)& );" + + GetType(me) returns ElementType from SMDSAbs; + ---Purpose: return the mesh element type + ---C++: inline + +fields + + myID : Integer is protected; + myType : ElementType from SMDSAbs; + myNbNodes : Integer is protected; + myNormals : HArray1OfDir from TColgp is protected; + +end MeshElement; diff --git a/src/SMDS/SMDS_MeshElement.cxx b/src/SMDS/SMDS_MeshElement.cxx new file mode 100644 index 000000000..df8be2d75 --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.cxx @@ -0,0 +1,177 @@ +using namespace std; +// File: SMDS_MeshElement.cxx +// Created: Wed Jan 23 16:49:11 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElement.ixx" + +//======================================================================= +//function : SMDS_MeshElement +//purpose : +//======================================================================= + +SMDS_MeshElement::SMDS_MeshElement(const Standard_Integer ID, const Standard_Integer nb,const SMDSAbs_ElementType Type) + :myID(ID),myNbNodes(nb),myType(Type) +{ +} + +//======================================================================= +//function : GetConnections +//purpose : +//======================================================================= + +Standard_Address SMDS_MeshElement::GetConnections() const +{ + return (Standard_Address)&myID; +} + + +//======================================================================= +//function : GetConnection +//purpose : +//======================================================================= + +Standard_Integer SMDS_MeshElement::GetConnection(const Standard_Integer rank) const +{ + return myID; +} + + +//======================================================================= +//function : InverseElements +//purpose : +//======================================================================= + +const SMDS_ListOfMeshElement& SMDS_MeshElement::InverseElements() const +{ + static SMDS_ListOfMeshElement empty; + return empty; +} + +//======================================================================= +//function : ClearInverseElements +//purpose : +//======================================================================= + +void SMDS_MeshElement::ClearInverseElements() +{ +} + +//======================================================================= +//function : AddInverseElement +//purpose : +//======================================================================= + +void SMDS_MeshElement::AddInverseElement(const Handle(SMDS_MeshElement)& elem) +{ +} + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +Standard_Integer SMDS_MeshElement::NbEdges() const +{ + return 0; +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +Standard_Integer SMDS_MeshElement::NbFaces() const +{ + return 0; +} + + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= + +void SMDS_MeshElement::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = 0; + idnode2 = 0; +} + +//======================================================================= +//function : GetFaceDefinedByNodes +//purpose : +//======================================================================= + +void SMDS_MeshElement::GetFaceDefinedByNodes(const Standard_Integer rank, + const Standard_Address idnode, + Standard_Integer& nb) const +{ + nb = 0; +} + +//======================================================================= +//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) +{ + if (myNormals.IsNull()) { + myNormals = new TColgp_HArray1OfDir(1,NbNodes()); + } + myNormals->SetValue(rank, gp_Dir(V)); +} + +//======================================================================= +//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) +{ + ME->Print(OS); + return OS; +} diff --git a/src/SMDS/SMDS_MeshElement.hxx b/src/SMDS/SMDS_MeshElement.hxx new file mode 100644 index 000000000..61631859c --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.hxx @@ -0,0 +1,148 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshElement_HeaderFile +#define _SMDS_MeshElement_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#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 +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +#ifndef _Standard_OStream_HeaderFile +#include +#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_MeshElement.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshElement.ixx b/src/SMDS/SMDS_MeshElement.ixx new file mode 100644 index 000000000..a54cd490e --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshElement.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshElement::~SMDS_MeshElement() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshElement_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshElement", + sizeof(SMDS_MeshElement), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshElement) Handle(SMDS_MeshElement)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshElement) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshElement))) { + _anOtherObject = Handle(SMDS_MeshElement)((Handle(SMDS_MeshElement)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshElement::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshElement) ; +} +Standard_Boolean SMDS_MeshElement::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshElement) == AType || SMDS_MeshObject::IsKind(AType)); +} +Handle_SMDS_MeshElement::~Handle_SMDS_MeshElement() {} + diff --git a/src/SMDS/SMDS_MeshElement.jxx b/src/SMDS/SMDS_MeshElement.jxx new file mode 100644 index 000000000..61b241d0e --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.jxx @@ -0,0 +1,18 @@ +#ifndef _TColgp_HArray1OfDir_HeaderFile +#include +#endif +#ifndef _Standard_OutOfRange_HeaderFile +#include +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +#ifndef _gp_Vec_HeaderFile +#include +#endif +#ifndef _gp_Dir_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshElement.lxx b/src/SMDS/SMDS_MeshElement.lxx new file mode 100644 index 000000000..c1b9a5fb8 --- /dev/null +++ b/src/SMDS/SMDS_MeshElement.lxx @@ -0,0 +1,131 @@ +// File: SMDS_MeshElement.lxx +// Created: Thu Jan 24 09:45:40 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : HashCode +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshElement::HashCode(const Standard_Integer Upper) const +{ + return (GetKey() % Upper); +} + +//======================================================================= +//function : IsEqual +//purpose : +//======================================================================= + +inline Standard_Boolean SMDS_MeshElement::IsEqual(const Handle(SMDS_MeshElement)& other) const +{ + if (this->NbNodes()!=other->NbNodes()) + return Standard_False; + Standard_Integer *c1,*c2; + Standard_Integer n = this->NbNodes(); + + c1 = (Standard_Integer *)this->GetConnections(); + c2 = (Standard_Integer *)other->GetConnections(); + if (*c1 != *c2) + return Standard_False; + + n--; + c1++; + c2++; + + for (;n--; c1++,c2++) { + if (*c1 != *c2) { + return Standard_False; + } + } + + return Standard_True; + +} + +//======================================================================= +//function : IsSame +//purpose : +//======================================================================= + +inline Standard_Boolean SMDS_MeshElement::IsSame(const Handle(SMDS_MeshElement)& other) const +{ + if (this->NbNodes()!=other->NbNodes()) + return Standard_False; + Standard_Integer *c1,*c2; + Standard_Integer n = this->NbNodes(); + + c1 = (Standard_Integer *)this->GetConnections(); + c2 = (Standard_Integer *)other->GetConnections(); + if (*c1 != *c2) + return Standard_False; + + n--; + c1++; + c2++; + + Standard_Integer off = n-1; + + for (;n--; c1++,c2++) { + if (*c1 != *c2 && *c1 != *(c2+off)) { + return Standard_False; + } + off -= 2; + } + + return Standard_True; +} + +//======================================================================= +//function : IsNodeInElement +//purpose : +//======================================================================= +inline Standard_Boolean SMDS_MeshElement::IsNodeInElement(const Standard_Integer idnode) const +{ + if (idnode < GetConnection(1)) + return Standard_False; + + Standard_Integer *c; + c = (Standard_Integer *)this->GetConnections(); + Standard_Integer n = myNbNodes; + + for (;n--; c++) { + if (*c == idnode) + return Standard_True; + } + + return Standard_False; +} + + +//======================================================================= +//function : NbNodes +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshElement::NbNodes() const +{ + return myNbNodes; +} + +//======================================================================= +//function : GetID +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshElement::GetID() const +{ + return myID; +} + +//======================================================================= +//function : GetType +//purpose : +//======================================================================= +inline SMDSAbs_ElementType SMDS_MeshElement::GetType() const +{ + return myType; +} + + + diff --git a/src/SMDS/SMDS_MeshElementIDFactory.cdl b/src/SMDS/SMDS_MeshElementIDFactory.cdl new file mode 100644 index 000000000..588c3a5a2 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.cdl @@ -0,0 +1,45 @@ +-- File: SMDS_MeshElementIDFactory.cdl +-- Created: Tue May 7 16:19:36 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +private class MeshElementIDFactory from SMDS inherits MeshIDFactory + + ---Purpose: + +uses + DataMapOfIntegerMeshElement from SMDS, + MeshElement from SMDS + +is + + Create returns mutable MeshElementIDFactory from SMDS; + + GetFreeID(me:mutable) returns Integer is redefined static; + ---Purpose: returns a free identifier for mesh from + -- the pool of ID + ---C++: inline + + ReleaseID(me: mutable;ID :Integer) is redefined static; + ---Purpose: free the ID and give it back to the pool of ID + ---C++: inline + + BindID(me: mutable;ID :Integer; elem : MeshElement from SMDS ) + returns Boolean; + ---Purpose: bind the ID with the mesh element + -- returns False if the ID is already bound. + -- In this case the element is not replaced + ---C++: inline + + MeshElement(me;ID :Integer) returns MeshElement from SMDS; + ---Purpose: returns the MeshElement associated with ID + -- raises an exception if the ID is not bound + ---C++: inline + + +fields + myIDElements : DataMapOfIntegerMeshElement from SMDS; + +end MeshElementIDFactory; diff --git a/src/SMDS/SMDS_MeshElementIDFactory.cxx b/src/SMDS/SMDS_MeshElementIDFactory.cxx new file mode 100644 index 000000000..34b433f41 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.cxx @@ -0,0 +1,18 @@ +using namespace std; +// File: SMDS_MeshElementIDFactory.cxx +// Created: Tue May 7 16:57:15 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElementIDFactory.ixx" + +//======================================================================= +//function : SMDS_MeshElementIDFactory +//purpose : +//======================================================================= + +SMDS_MeshElementIDFactory::SMDS_MeshElementIDFactory() : SMDS_MeshIDFactory() +{ +} + diff --git a/src/SMDS/SMDS_MeshElementIDFactory.hxx b/src/SMDS/SMDS_MeshElementIDFactory.hxx new file mode 100644 index 000000000..7875a9af0 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.hxx @@ -0,0 +1,114 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshElementIDFactory_HeaderFile +#define _SMDS_MeshElementIDFactory_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile +#include "Handle_SMDS_MeshElementIDFactory.hxx" +#endif + +#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile +#include "SMDS_DataMapOfIntegerMeshElement.hxx" +#endif +#ifndef _SMDS_MeshIDFactory_HeaderFile +#include "SMDS_MeshIDFactory.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +class SMDS_MeshElement; + + +class SMDS_MeshElementIDFactory : public SMDS_MeshIDFactory { + +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_MeshElementIDFactory(); +Standard_EXPORT inline Standard_Integer GetFreeID() ; +Standard_EXPORT inline void ReleaseID(const Standard_Integer ID) ; +Standard_EXPORT inline Standard_Boolean BindID(const Standard_Integer ID,const Handle(SMDS_MeshElement)& elem) ; +Standard_EXPORT inline Handle_SMDS_MeshElement MeshElement(const Standard_Integer ID) const; +Standard_EXPORT ~SMDS_MeshElementIDFactory(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshElementIDFactory_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 + // +SMDS_DataMapOfIntegerMeshElement myIDElements; + + +}; + + +#include "SMDS_MeshElementIDFactory.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshElementIDFactory.ixx b/src/SMDS/SMDS_MeshElementIDFactory.ixx new file mode 100644 index 000000000..95cf8263c --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshElementIDFactory.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshElementIDFactory::~SMDS_MeshElementIDFactory() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshElementIDFactory_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshIDFactory); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshIDFactory); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshElementIDFactory", + sizeof(SMDS_MeshElementIDFactory), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshElementIDFactory) Handle(SMDS_MeshElementIDFactory)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshElementIDFactory) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshElementIDFactory))) { + _anOtherObject = Handle(SMDS_MeshElementIDFactory)((Handle(SMDS_MeshElementIDFactory)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshElementIDFactory::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshElementIDFactory) ; +} +Standard_Boolean SMDS_MeshElementIDFactory::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshElementIDFactory) == AType || SMDS_MeshIDFactory::IsKind(AType)); +} +Handle_SMDS_MeshElementIDFactory::~Handle_SMDS_MeshElementIDFactory() {} + diff --git a/src/SMDS/SMDS_MeshElementIDFactory.jxx b/src/SMDS/SMDS_MeshElementIDFactory.jxx new file mode 100644 index 000000000..f7eadb66d --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementIDFactory_HeaderFile +#include "SMDS_MeshElementIDFactory.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshElementIDFactory.lxx b/src/SMDS/SMDS_MeshElementIDFactory.lxx new file mode 100644 index 000000000..b8581cbf6 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementIDFactory.lxx @@ -0,0 +1,56 @@ +// File: SMDS_MeshElementIDFactory.lxx +// Created: Tue May 7 16:30:34 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : GetFreeID +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshElementIDFactory::GetFreeID() +{ + if (myPoolOfID.IsEmpty()) { + ++myMaxID; + while (myIDElements.IsBound(myMaxID)) ++myMaxID; + return myMaxID; + } else { + Standard_Integer ID = myPoolOfID.Top(); + myPoolOfID.Pop(); + return ID; + } + +} + +//======================================================================= +//function : ReleaseID +//purpose : +//======================================================================= +inline void SMDS_MeshElementIDFactory::ReleaseID(const Standard_Integer ID) +{ + myIDElements.UnBind(ID); + if (ID < myMaxID) + myPoolOfID.Push(ID); + +} + +//======================================================================= +//function : BindID +//purpose : +//======================================================================= +inline Standard_Boolean SMDS_MeshElementIDFactory::BindID(const Standard_Integer ID, + const Handle(SMDS_MeshElement)& elem) +{ + return myIDElements.Bind(ID,elem); + +} + +//======================================================================= +//function : MeshElement +//purpose : +//======================================================================= +inline Handle(SMDS_MeshElement) SMDS_MeshElementIDFactory::MeshElement(const Standard_Integer ID) const +{ + return myIDElements.Find(ID); + +} + diff --git a/src/SMDS/SMDS_MeshElementMapHasher.cdl b/src/SMDS/SMDS_MeshElementMapHasher.cdl new file mode 100644 index 000000000..4e9aa74de --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.cdl @@ -0,0 +1,31 @@ +-- File: SMDS_MeshElementMapHasher.cdl +-- Created: Wed Jan 23 14:04:07 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshElementMapHasher from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + + +is + HashCode(myclass; ME: MeshElement from SMDS; Upper : Integer) returns Integer; + ---Purpose: Returns a HasCode value for the Key in the + -- range 0..Upper. + -- + ---C++: inline + + IsEqual(myclass; ME1, ME2 : MeshElement from SMDS) returns Boolean; + ---Purpose: Returns True when the two keys are the same. Two + -- same keys must have the same hashcode, the + -- contrary is not necessary. + -- + ---C++: inline + + +end MeshElementMapHasher; diff --git a/src/SMDS/SMDS_MeshElementMapHasher.cxx b/src/SMDS/SMDS_MeshElementMapHasher.cxx new file mode 100644 index 000000000..c6d7e352f --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.cxx @@ -0,0 +1,8 @@ +using namespace std; +// File: SMDS_MeshElementMapHasher.cxx +// Created: Wed Jan 23 14:09:30 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElementMapHasher.ixx" diff --git a/src/SMDS/SMDS_MeshElementMapHasher.hxx b/src/SMDS/SMDS_MeshElementMapHasher.hxx new file mode 100644 index 000000000..307824f7d --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.hxx @@ -0,0 +1,97 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#define _SMDS_MeshElementMapHasher_HeaderFile + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class SMDS_MeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshElementMapHasher { + +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 static Standard_Integer HashCode(const Handle(SMDS_MeshElement)& ME,const Standard_Integer Upper) ; +Standard_EXPORT inline static Standard_Boolean IsEqual(const Handle(SMDS_MeshElement)& ME1,const Handle(SMDS_MeshElement)& ME2) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_MeshElementMapHasher.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshElementMapHasher.ixx b/src/SMDS/SMDS_MeshElementMapHasher.ixx new file mode 100644 index 000000000..a158ff549 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshElementMapHasher.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshElementMapHasher.jxx b/src/SMDS/SMDS_MeshElementMapHasher.jxx new file mode 100644 index 000000000..1042eee59 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshElementMapHasher.lxx b/src/SMDS/SMDS_MeshElementMapHasher.lxx new file mode 100644 index 000000000..bc6649cc3 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementMapHasher.lxx @@ -0,0 +1,27 @@ +// File: SMDS_MeshElementMapHasher.lxx +// Created: Wed Jan 23 14:07:00 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElement.hxx" + +//======================================================================= +//function : HashCode +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshElementMapHasher::HashCode + (const Handle(SMDS_MeshElement)& ME, const Standard_Integer Upper) +{ + return ME->HashCode(Upper); +} + +//======================================================================= +//function : IsEqual +//purpose : +//======================================================================= +inline Standard_Boolean SMDS_MeshElementMapHasher::IsEqual + (const Handle(SMDS_MeshElement)& ME1, const Handle(SMDS_MeshElement)& ME2) +{ + return ME1->IsSame(ME2); +} diff --git a/src/SMDS/SMDS_MeshElementsIterator.cdl b/src/SMDS/SMDS_MeshElementsIterator.cdl new file mode 100644 index 000000000..a51d0f98a --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.cdl @@ -0,0 +1,56 @@ +-- File: SMDS_MeshElementsIterator.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshElementsIterator from SMDS + + ---Purpose: The Iterator objet to iterate on all faces of a mesh + -- + +uses + Mesh from SMDS, + MeshElement from SMDS, + MapIteratorOfExtendedOrientedMap from SMDS + +raises + NoMoreObject, + NoSuchObject + +is + + Delete(me:out) is virtual; + ---C++: alias "Standard_EXPORT virtual ~SMDS_MeshElementsIterator(){Delete();}" + + Initialize(me : in out; M : Mesh from SMDS) + ---Purpose: Reset the Iterator on the faces of mesh . + is deferred; + + More(me) returns Boolean + ---Purpose: Returns True if there is a current meshface. + -- + ---C++: inline + is static; + + Next(me : in out) + ---Purpose: Moves to the next face. + raises + NoMoreObject from Standard + is static; + + Value(me) returns MeshElement from SMDS + ---Purpose: Returns the meshface. + raises + NoSuchObject from Standard + ---C++: return const & + ---C++: inline + is static; + + +fields + myCurrentMeshElement : MeshElement from SMDS is protected; + myMapIterator : MapIteratorOfExtendedOrientedMap from SMDS is protected; + +end MeshElementsIterator; diff --git a/src/SMDS/SMDS_MeshElementsIterator.cxx b/src/SMDS/SMDS_MeshElementsIterator.cxx new file mode 100644 index 000000000..da45e145f --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.cxx @@ -0,0 +1,24 @@ +using namespace std; +// File: SMDS_MeshElementsIterator.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElementsIterator.ixx" + +void SMDS_MeshElementsIterator::Delete() +{} + +//======================================================================= +//function : Next +//purpose : +//======================================================================= + +void SMDS_MeshElementsIterator::Next() +{ + myMapIterator.Next(); + if (More()) { + myCurrentMeshElement = myMapIterator.Key(); + } +} diff --git a/src/SMDS/SMDS_MeshElementsIterator.hxx b/src/SMDS/SMDS_MeshElementsIterator.hxx new file mode 100644 index 000000000..f94d004b1 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.hxx @@ -0,0 +1,109 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#define _SMDS_MeshElementsIterator_HeaderFile + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class SMDS_MeshElement; +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_Mesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshElementsIterator { + +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 Delete() ; +Standard_EXPORT virtual ~SMDS_MeshElementsIterator(){Delete();} +Standard_EXPORT virtual void Initialize(const Handle(SMDS_Mesh)& M) = 0; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT inline const Handle_SMDS_MeshElement& Value() const; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // +Handle_SMDS_MeshElement myCurrentMeshElement; +SMDS_MapIteratorOfExtendedOrientedMap myMapIterator; + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_MeshElementsIterator.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshElementsIterator.ixx b/src/SMDS/SMDS_MeshElementsIterator.ixx new file mode 100644 index 000000000..a4b01e7c5 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshElementsIterator.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshElementsIterator.jxx b/src/SMDS/SMDS_MeshElementsIterator.jxx new file mode 100644 index 000000000..e5bb60a50 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.jxx @@ -0,0 +1,15 @@ +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#include "SMDS_MeshElementsIterator.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshElementsIterator.lxx b/src/SMDS/SMDS_MeshElementsIterator.lxx new file mode 100644 index 000000000..6e08e6404 --- /dev/null +++ b/src/SMDS/SMDS_MeshElementsIterator.lxx @@ -0,0 +1,28 @@ +// File: SMDS_MeshElementsIterator.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include + +//======================================================================= +//function : More +//purpose : +//======================================================================= + +inline Standard_Boolean SMDS_MeshElementsIterator::More() const +{ + return myMapIterator.More(); +} + +//======================================================================= +//function : Value +//purpose : +//======================================================================= + +inline const Handle(SMDS_MeshElement)& SMDS_MeshElementsIterator::Value() const +{ + Standard_NoSuchObject_Raise_if(!More(),"SMDS_MeshElementsIterator::Value"); + return myCurrentMeshElement; +} diff --git a/src/SMDS/SMDS_MeshFace.cdl b/src/SMDS/SMDS_MeshFace.cdl new file mode 100755 index 000000000..4dfd830ab --- /dev/null +++ b/src/SMDS/SMDS_MeshFace.cdl @@ -0,0 +1,34 @@ +-- File: SMDS_MeshFace.cdl +-- Created: Wed Jan 23 16:16:09 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshFace from SMDS inherits MeshElement from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +is + + Initialize(ID: Integer; NbConnections : Integer) returns mutable MeshFace; + + ComputeKey(me: mutable) is deferred; + ---Purpose: compute the ID of the face based on the id's of its + -- bounding nodes + + GetKey(me) returns Integer is redefined static; + ---C++: inline + + NbEdges(me) returns Integer + is redefined virtual; + + Print(me; OS: in out OStream) is redefined virtual; + +fields + myKey : Integer is protected; + +end MeshFace; diff --git a/src/SMDS/SMDS_MeshFace.cxx b/src/SMDS/SMDS_MeshFace.cxx new file mode 100644 index 000000000..94deb44ff --- /dev/null +++ b/src/SMDS/SMDS_MeshFace.cxx @@ -0,0 +1,45 @@ +using namespace std; +// File: SMDS_MeshFace.cxx +// Created: Wed Jan 23 17:02:27 2002 +// Author: Jean-Michel BOULCOURT +// + + +#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 : +//======================================================================= + +void SMDS_MeshFace::Print(Standard_OStream& OS) const +{ + OS << "face <" << myID <<" > : "; + for (Standard_Integer i=1; i +#endif +#ifndef _Handle_SMDS_MeshFace_HeaderFile +#include "Handle_SMDS_MeshFace.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_OStream_HeaderFile +#include +#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 + // + + +}; + + +#include "SMDS_MeshFace.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshFace.ixx b/src/SMDS/SMDS_MeshFace.ixx new file mode 100644 index 000000000..766d598d4 --- /dev/null +++ b/src/SMDS/SMDS_MeshFace.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshFace.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshFace::~SMDS_MeshFace() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshFace_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshFace", + sizeof(SMDS_MeshFace), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshFace) Handle(SMDS_MeshFace)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshFace) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshFace))) { + _anOtherObject = Handle(SMDS_MeshFace)((Handle(SMDS_MeshFace)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshFace::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshFace) ; +} +Standard_Boolean SMDS_MeshFace::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshFace) == AType || SMDS_MeshElement::IsKind(AType)); +} +Handle_SMDS_MeshFace::~Handle_SMDS_MeshFace() {} + diff --git a/src/SMDS/SMDS_MeshFace.jxx b/src/SMDS/SMDS_MeshFace.jxx new file mode 100644 index 000000000..439ee7742 --- /dev/null +++ b/src/SMDS/SMDS_MeshFace.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshFace_HeaderFile +#include "SMDS_MeshFace.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshFace.lxx b/src/SMDS/SMDS_MeshFace.lxx new file mode 100644 index 000000000..db68e26ea --- /dev/null +++ b/src/SMDS/SMDS_MeshFace.lxx @@ -0,0 +1,16 @@ +// File: SMDS_MeshFace.lxx +// Created: Tue May 7 18:09:59 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : GetKey +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshFace::GetKey() const +{ + return myKey; +} + diff --git a/src/SMDS/SMDS_MeshFacesIterator.cdl b/src/SMDS/SMDS_MeshFacesIterator.cdl new file mode 100644 index 000000000..99901da4a --- /dev/null +++ b/src/SMDS/SMDS_MeshFacesIterator.cdl @@ -0,0 +1,34 @@ +-- File: SMDS_MeshFacesIterator.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshFacesIterator from SMDS inherits MeshElementsIterator from SMDS + + ---Purpose: The Iterator objet to iterate on all faces of a mesh + -- + +uses + Mesh from SMDS, + MeshElement from SMDS + +raises + NoMoreObject, + NoSuchObject + +is + + Create returns MeshFacesIterator from SMDS; + ---Purpose: Creates an empty Iterator. + + Create(M : Mesh from SMDS) returns MeshFacesIterator from SMDS; + ---Purpose: Creates an Iterator on faces of mesh . + + Initialize(me : in out; M : Mesh from SMDS) + ---Purpose: Reset the Iterator on the faces of mesh . + is redefined static; + + +end MeshFacesIterator; diff --git a/src/SMDS/SMDS_MeshFacesIterator.cxx b/src/SMDS/SMDS_MeshFacesIterator.cxx new file mode 100644 index 000000000..466488c09 --- /dev/null +++ b/src/SMDS/SMDS_MeshFacesIterator.cxx @@ -0,0 +1,42 @@ +using namespace std; +// File: SMDS_MeshFacesIterator.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshFacesIterator.ixx" + +//======================================================================= +//function : SMDS_MeshFacesIterator +//purpose : +//======================================================================= + +SMDS_MeshFacesIterator::SMDS_MeshFacesIterator() +{ +} + +//======================================================================= +//function : SMDS_MeshFacesIterator +//purpose : +//======================================================================= + +SMDS_MeshFacesIterator::SMDS_MeshFacesIterator(const Handle(SMDS_Mesh)& M) +{ + Initialize(M); +} + +//======================================================================= +//function : Initialize +//purpose : +//======================================================================= + +void SMDS_MeshFacesIterator::Initialize(const Handle(SMDS_Mesh)& M) +{ + + myMapIterator.Initialize(M->myFaces); + if (More()) { + myCurrentMeshElement = myMapIterator.Key(); + } +} + diff --git a/src/SMDS/SMDS_MeshFacesIterator.hxx b/src/SMDS/SMDS_MeshFacesIterator.hxx new file mode 100644 index 000000000..1d66bc106 --- /dev/null +++ b/src/SMDS/SMDS_MeshFacesIterator.hxx @@ -0,0 +1,96 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshFacesIterator_HeaderFile +#define _SMDS_MeshFacesIterator_HeaderFile + +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#include "SMDS_MeshElementsIterator.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_Mesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshFacesIterator : public SMDS_MeshElementsIterator { + +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_MeshFacesIterator(); +Standard_EXPORT SMDS_MeshFacesIterator(const Handle(SMDS_Mesh)& M); +Standard_EXPORT void Initialize(const Handle(SMDS_Mesh)& M) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshFacesIterator.ixx b/src/SMDS/SMDS_MeshFacesIterator.ixx new file mode 100644 index 000000000..380bcdad0 --- /dev/null +++ b/src/SMDS/SMDS_MeshFacesIterator.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshFacesIterator.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshFacesIterator.jxx b/src/SMDS/SMDS_MeshFacesIterator.jxx new file mode 100644 index 000000000..32276e371 --- /dev/null +++ b/src/SMDS/SMDS_MeshFacesIterator.jxx @@ -0,0 +1,12 @@ +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshFacesIterator_HeaderFile +#include "SMDS_MeshFacesIterator.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshGroup.cdl b/src/SMDS/SMDS_MeshGroup.cdl new file mode 100644 index 000000000..40f4080f9 --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.cdl @@ -0,0 +1,116 @@ +-- File: SMDS_MeshGroup.cdl +-- Created: Mon Jun 3 11:49:08 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshGroup from SMDS inherits MeshObject from SMDS + + ---Purpose: + +uses + Mesh from SMDS, + MeshElement from SMDS, + ElementType from SMDSAbs, + ListOfMeshGroup from SMDS, + MapOfMeshElement from SMDS + +raises + + NoSuchObject from Standard, + TypeMismatch from Standard + +is + + ---===================================== + ---Category: public API methods + -- Group creation and deletion + --====================================== + + Create(aMesh: Mesh from SMDS) returns MeshGroup from SMDS; + ---Purpose: constructor + + AddSubGroup(me: mutable) returns MeshGroup from SMDS; + ---Purpose: create a sub group. + -- uses a private constructor to create an instance of the + -- subgroup and attahc it the parent group. + + RemoveSubGroup(me: mutable; aGroup: MeshGroup from SMDS) + returns Boolean + ---Purpose: remove aGroup from the list of Children + -- if the subgroup does not belong to this, it returns False + -- (True otherwise) + is virtual; + + RemoveFromParent(me: mutable) + returns Boolean + ---Purpose: remove this from its parent + -- if this has no parent then it returns False (True otherwise) + is virtual; + + + + ---===================================== + ---Category: public API methods + -- Group contents edition + --====================================== + + Clear(me: mutable); + ---Purpose: clear the group + -- once the group is cleared, the type is set to All + -- but the referenced mesh remains. + + Add(me: mutable; ME: MeshElement from SMDS) + raises TypeMismatch from Standard; + ---Purpose: add an element to the group + + Remove(me: mutable; ME: MeshElement from SMDS) + raises NoSuchObject from Standard; + ---Purpose: remove an element from the group + -- raises if the element is not in the group + + ---===================================== + ---Category: public API methods + -- Group contents exploration + --====================================== + + IsEmpty(me) + returns Boolean from Standard; + ---Purpose: check if the group is empty + + Extent(me) returns Integer from Standard; + ---Purpose: return numner of elements in the group + + Type(me) returns ElementType from SMDSAbs; + ---Purpose: return current element type + -- if the group is empty, returns All + + Contains(me; ME : MeshElement from SMDS) + returns Boolean from Standard; + ---Purpose: check if the group contains the mesh element + + Elements(me) returns MapOfMeshElement from SMDS; + ---Purpose: check if the group contains the mesh element + ---C++: return const & + ---C++: inline + + ---=========================================== + ---Category: private or protected API methods + -- + --============================================ + + Create(parent: MeshGroup) returns mutable MeshGroup + ---Purpose: constructor used internally to create subgroup + -- + is private; + + +fields + myMesh : Mesh from SMDS; + myType : ElementType from SMDSAbs; + myElements : MapOfMeshElement from SMDS; + myParent : MeshGroup from SMDS; + myChildren : ListOfMeshGroup from SMDS; + +end MeshGroup; diff --git a/src/SMDS/SMDS_MeshGroup.cxx b/src/SMDS/SMDS_MeshGroup.cxx new file mode 100644 index 000000000..6951886fd --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.cxx @@ -0,0 +1,162 @@ +using namespace std; +// File: SMDS_MeshGroup.cxx +// Created: Mon Jun 3 12:15:55 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshGroup.ixx" +#include "SMDS_ListIteratorOfListOfMeshGroup.hxx" + +//======================================================================= +//function : SMDS_MeshGroup +//purpose : +//======================================================================= + +SMDS_MeshGroup::SMDS_MeshGroup(const Handle(SMDS_Mesh)& aMesh) + :myMesh(aMesh),myType(SMDSAbs_All) +{ +} + +//======================================================================= +//function : SMDS_MeshGroup +//purpose : +//======================================================================= + +SMDS_MeshGroup::SMDS_MeshGroup(const Handle(SMDS_MeshGroup)& parent) + :myMesh(parent->myMesh),myType(SMDSAbs_All),myParent(parent) +{ +} + +//======================================================================= +//function : AddSubGroup +//purpose : +//======================================================================= + +Handle(SMDS_MeshGroup) SMDS_MeshGroup::AddSubGroup() +{ + Handle(SMDS_MeshGroup) subgroup = new SMDS_MeshGroup(this); + if (!subgroup.IsNull()) { + myChildren.Append(subgroup); + } + return subgroup; +} + +//======================================================================= +//function : RemoveSubGroup +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MeshGroup::RemoveSubGroup(const Handle(SMDS_MeshGroup)& aGroup) +{ + Standard_Boolean found = Standard_False; + + SMDS_ListIteratorOfListOfMeshGroup itgroup(myChildren); + for (;itgroup.More() && !found; itgroup.Next()) { + Handle(SMDS_MeshGroup) subgroup; + subgroup = itgroup.Value(); + if (subgroup == aGroup) { + found = Standard_True; + myChildren.Remove(itgroup); + } + } + + return found; +} + +//======================================================================= +//function : RemoveFromParent +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MeshGroup::RemoveFromParent() +{ + if (myParent.IsNull()) + return Standard_False; + + return (myParent->RemoveSubGroup(this)); + +} + +//======================================================================= +//function : Clear +//purpose : +//======================================================================= + +void SMDS_MeshGroup::Clear() +{ + myElements.Clear(); + myType = SMDSAbs_All; +} + +//======================================================================= +//function : IsEmpty +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MeshGroup::IsEmpty() const +{ + return myElements.IsEmpty(); +} + +//======================================================================= +//function : Extent +//purpose : +//======================================================================= + +Standard_Integer SMDS_MeshGroup::Extent() const +{ + return myElements.Extent(); +} + +//======================================================================= +//function : Add +//purpose : +//======================================================================= + +void SMDS_MeshGroup::Add(const Handle(SMDS_MeshElement)& ME) +{ + // the type of the group is determined by the first element added + if (myElements.IsEmpty()) { + myType = ME->GetType(); + } + + if (ME->GetType() != myType) { + Standard_TypeMismatch::Raise("SMDS_MeshGroup::Add"); + } + + myElements.Add(ME); +} + + +//======================================================================= +//function : Remove +//purpose : +//======================================================================= + +void SMDS_MeshGroup::Remove(const Handle(SMDS_MeshElement)& ME) +{ + myElements.Remove(ME); + if (myElements.IsEmpty()) + myType = SMDSAbs_All; +} + +//======================================================================= +//function : Type +//purpose : +//======================================================================= + +SMDSAbs_ElementType SMDS_MeshGroup::Type() const +{ + return myType; +} + +//======================================================================= +//function : Contains +//purpose : +//======================================================================= + +Standard_Boolean SMDS_MeshGroup::Contains(const Handle(SMDS_MeshElement)& ME) const +{ + return myElements.Contains(ME); +} diff --git a/src/SMDS/SMDS_MeshGroup.hxx b/src/SMDS/SMDS_MeshGroup.hxx new file mode 100644 index 000000000..46d4048a0 --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.hxx @@ -0,0 +1,142 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshGroup_HeaderFile +#define _SMDS_MeshGroup_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#include "Handle_SMDS_MeshGroup.hxx" +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _SMDSAbs_ElementType_HeaderFile +#include "SMDSAbs_ElementType.hxx" +#endif +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _Handle_SMDS_MeshGroup_HeaderFile +#include "Handle_SMDS_MeshGroup.hxx" +#endif +#ifndef _SMDS_ListOfMeshGroup_HeaderFile +#include "SMDS_ListOfMeshGroup.hxx" +#endif +#ifndef _SMDS_MeshObject_HeaderFile +#include "SMDS_MeshObject.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class SMDS_Mesh; +class Standard_NoSuchObject; +class Standard_TypeMismatch; +class SMDS_MeshElement; +class SMDS_MapOfMeshElement; + + +class SMDS_MeshGroup : 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_MeshGroup(const Handle(SMDS_Mesh)& aMesh); +Standard_EXPORT Handle_SMDS_MeshGroup AddSubGroup() ; +Standard_EXPORT virtual Standard_Boolean RemoveSubGroup(const Handle(SMDS_MeshGroup)& aGroup) ; +Standard_EXPORT virtual Standard_Boolean RemoveFromParent() ; +Standard_EXPORT void Clear() ; +Standard_EXPORT void Add(const Handle(SMDS_MeshElement)& ME) ; +Standard_EXPORT void Remove(const Handle(SMDS_MeshElement)& ME) ; +Standard_EXPORT Standard_Boolean IsEmpty() const; +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT SMDSAbs_ElementType Type() const; +Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& ME) const; +Standard_EXPORT inline const SMDS_MapOfMeshElement& Elements() const; +Standard_EXPORT ~SMDS_MeshGroup(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshGroup_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 + // +Standard_EXPORT SMDS_MeshGroup(const Handle(SMDS_MeshGroup)& parent); + + + // Fields PRIVATE + // +Handle_SMDS_Mesh myMesh; +SMDSAbs_ElementType myType; +SMDS_MapOfMeshElement myElements; +Handle_SMDS_MeshGroup myParent; +SMDS_ListOfMeshGroup myChildren; + + +}; + + +#include "SMDS_MeshGroup.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshGroup.ixx b/src/SMDS/SMDS_MeshGroup.ixx new file mode 100644 index 000000000..c871db275 --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshGroup.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include "Standard_TypeMismatch.hxx" +#endif + +SMDS_MeshGroup::~SMDS_MeshGroup() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshGroup_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshGroup", + sizeof(SMDS_MeshGroup), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshGroup) Handle(SMDS_MeshGroup)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshGroup) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshGroup))) { + _anOtherObject = Handle(SMDS_MeshGroup)((Handle(SMDS_MeshGroup)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshGroup::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshGroup) ; +} +Standard_Boolean SMDS_MeshGroup::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshGroup) == AType || SMDS_MeshObject::IsKind(AType)); +} +Handle_SMDS_MeshGroup::~Handle_SMDS_MeshGroup() {} + diff --git a/src/SMDS/SMDS_MeshGroup.jxx b/src/SMDS/SMDS_MeshGroup.jxx new file mode 100644 index 000000000..1c3d76cec --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.jxx @@ -0,0 +1,21 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshGroup_HeaderFile +#include "SMDS_MeshGroup.hxx" +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _SMDS_MeshGroup_HeaderFile +#include "SMDS_MeshGroup.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshGroup.lxx b/src/SMDS/SMDS_MeshGroup.lxx new file mode 100644 index 000000000..697c509b1 --- /dev/null +++ b/src/SMDS/SMDS_MeshGroup.lxx @@ -0,0 +1,14 @@ +// File: SMDS_MeshGroup.lxx +// Created: Fri Jun 7 12:00:06 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : Elements +//purpose : +//======================================================================= + +inline const SMDS_MapOfMeshElement& SMDS_MeshGroup::Elements() const +{ + return myElements; +} diff --git a/src/SMDS/SMDS_MeshHexahedron.cdl b/src/SMDS/SMDS_MeshHexahedron.cdl new file mode 100644 index 000000000..f1a7d04fa --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.cdl @@ -0,0 +1,69 @@ +-- File: SMDS_MeshHexahedron.cdl +-- Created: Wed Jan 23 16:17:22 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshHexahedron from SMDS inherits MeshVolume from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + + +raises + ConstructionError from Standard + +is + + + Create (ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8: Integer) + returns mutable MeshHexahedron; + ---Purpose: constructor for a hexaedra + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1 : out Integer; idnode2: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + GetFaceDefinedByNodes(me; rank: Integer; idnode : Address; nb: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith face (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + ComputeKey(me: mutable) is redefined static; + ---Purpose: compute the ID of the volume based on the id's of its + -- bounding nodes + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8: Integer) + is private; + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + NbEdges(me) returns Integer + is redefined static; + ---C++: inline + + NbFaces(me) returns Integer + is redefined static; + ---C++: inline + + NodesOfFace(myclass; rankface,ranknode: Integer) + returns Integer; + ---Purpose: returns the rank node in mynodes. Useful to extract faces from volume + -- + + NodesOfEdge(me; rankedge: Integer; ranknode: Integer) returns Integer; + +fields + + myNodes : Integer [8]; + +end MeshHexahedron; diff --git a/src/SMDS/SMDS_MeshHexahedron.cxx b/src/SMDS/SMDS_MeshHexahedron.cxx new file mode 100644 index 000000000..f2986a1ea --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.cxx @@ -0,0 +1,196 @@ +using namespace std; +// File: SMDS_MeshHexahedron.cxx +// Created: Wed Jan 23 17:02:34 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshHexahedron.ixx" +#include + + +//======================================================================= +//function : SMDS_MeshHexahedron +//purpose : Hexaedra +//======================================================================= + +SMDS_MeshHexahedron::SMDS_MeshHexahedron(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):SMDS_MeshVolume(ID,8) +{ + SetConnections(idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8); + ComputeKey(); +} + + +//======================================================================= +//function : SetConnections +//purpose : Heaxahedron +//======================================================================= +void SMDS_MeshHexahedron::SetConnections(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 idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + idmin = (idmin < idnode4 ? idmin : idnode4); + idmin = (idmin < idnode5 ? idmin : idnode5); + idmin = (idmin < idnode6 ? idmin : idnode6); + idmin = (idmin < idnode7 ? idmin : idnode7); + idmin = (idmin < idnode8 ? idmin : idnode8); + + myNodes[0] = idmin; + if (idmin == idnode1) { // 1 2 3 4 5 6 7 8 + myNodes[1] = idnode2; + myNodes[2] = idnode3; + myNodes[3] = idnode4; + myNodes[4] = idnode5; + myNodes[5] = idnode6; + myNodes[6] = idnode7; + myNodes[7] = idnode8; + } else if (idmin == idnode2) { // 2 3 4 1 6 7 8 5 + myNodes[1] = idnode3; + myNodes[2] = idnode4; + myNodes[3] = idnode1; + myNodes[4] = idnode6; + myNodes[5] = idnode7; + myNodes[6] = idnode8; + myNodes[7] = idnode5; + } else if (idmin == idnode3) { // 3 4 1 2 7 8 5 6 + myNodes[1] = idnode4; + myNodes[2] = idnode1; + myNodes[3] = idnode2; + myNodes[4] = idnode7; + myNodes[5] = idnode8; + myNodes[6] = idnode5; + myNodes[7] = idnode6; + } else if (idmin == idnode4) { // 4 1 2 3 8 5 6 7 + myNodes[1] = idnode1; + myNodes[2] = idnode2; + myNodes[3] = idnode3; + myNodes[4] = idnode8; + myNodes[5] = idnode5; + myNodes[6] = idnode6; + myNodes[7] = idnode7; + } else if (idmin == idnode5) { // 5 6 7 8 1 2 3 4 + myNodes[1] = idnode6; + myNodes[2] = idnode7; + myNodes[3] = idnode8; + myNodes[4] = idnode1; + myNodes[5] = idnode2; + myNodes[6] = idnode3; + myNodes[7] = idnode4; + } else if (idmin == idnode6){ // 6 7 8 5 2 3 4 1 + myNodes[1] = idnode7; + myNodes[2] = idnode8; + myNodes[3] = idnode5; + myNodes[4] = idnode2; + myNodes[5] = idnode3; + myNodes[6] = idnode4; + myNodes[7] = idnode1; + } else if (idmin == idnode7) { // 7 8 5 6 3 4 1 2 + myNodes[1] = idnode8; + myNodes[2] = idnode5; + myNodes[3] = idnode6; + myNodes[4] = idnode3; + myNodes[5] = idnode4; + myNodes[6] = idnode1; + myNodes[7] = idnode2; + } else { // 8 5 6 7 4 1 2 3 + myNodes[1] = idnode5; + myNodes[2] = idnode6; + myNodes[3] = idnode7; + myNodes[4] = idnode4; + myNodes[5] = idnode1; + myNodes[6] = idnode2; + myNodes[7] = idnode3; + } + +} + +//======================================================================= +//function : NodesOfFace +//purpose : returns the rank node in mynodes. Useful to extract faces from volume +//======================================================================= +Standard_Integer SMDS_MeshHexahedron::NodesOfFace(const Standard_Integer rankface, + const Standard_Integer ranknode) +{ + static Standard_Integer facenode[6][4] = { + {0,1,2,3}, + {4,7,6,5}, + {0,4,5,1}, + {1,5,6,2}, + {2,6,7,3}, + {0,3,7,4} + }; + + return facenode[rankface-1][ranknode-1]; +} + +//======================================================================= +//function : NodesOfEdge +//purpose : returns the rank node in mynodes. Useful to extract edges from volume +//======================================================================= +Standard_Integer SMDS_MeshHexahedron::NodesOfEdge(const Standard_Integer rankedge, + const Standard_Integer ranknode) const +{ + static Standard_Integer faceedge[12][2] = { + {0,1}, + {1,2}, + {2,3}, + {0,3}, + {4,7}, + {6,7}, + {5,6}, + {4,5}, + {0,4}, + {1,5}, + {2,6}, + {3,7} + + }; + + return faceedge[rankedge-1][ranknode-1]; +} + +//======================================================================= +//function : GetFaceDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshHexahedron::GetFaceDefinedByNodes(const Standard_Integer rank, + const Standard_Address idnode, + Standard_Integer& nb) const +{ + Standard_Integer *ptr; + nb = 4; + ptr = (Standard_Integer *)idnode; + ptr[0] = myNodes[NodesOfFace(rank,1)]; + ptr[1] = myNodes[NodesOfFace(rank,2)]; + ptr[2] = myNodes[NodesOfFace(rank,3)]; + ptr[3] = myNodes[NodesOfFace(rank,4)]; + +} + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshHexahedron::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[NodesOfEdge(rank,1)]; + idnode2 = myNodes[NodesOfEdge(rank,2)]; +} + diff --git a/src/SMDS/SMDS_MeshHexahedron.hxx b/src/SMDS/SMDS_MeshHexahedron.hxx new file mode 100644 index 000000000..9d52f78bc --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.hxx @@ -0,0 +1,114 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshHexahedron_HeaderFile +#define _SMDS_MeshHexahedron_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshHexahedron_HeaderFile +#include "Handle_SMDS_MeshHexahedron.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshVolume_HeaderFile +#include "SMDS_MeshVolume.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +class Standard_ConstructionError; + + +class SMDS_MeshHexahedron : public SMDS_MeshVolume { + +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_MeshHexahedron(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); +Standard_EXPORT void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const; +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT inline Standard_Integer NbEdges() const; +Standard_EXPORT inline Standard_Integer NbFaces() const; +Standard_EXPORT static Standard_Integer NodesOfFace(const Standard_Integer rankface,const Standard_Integer ranknode) ; +Standard_EXPORT Standard_Integer NodesOfEdge(const Standard_Integer rankedge,const Standard_Integer ranknode) const; +Standard_EXPORT ~SMDS_MeshHexahedron(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshHexahedron_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 + // +Standard_EXPORT void SetConnections(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) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[8]; + + +}; + + +#include "SMDS_MeshHexahedron.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshHexahedron.ixx b/src/SMDS/SMDS_MeshHexahedron.ixx new file mode 100644 index 000000000..c01b2ef1c --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshHexahedron.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshHexahedron::~SMDS_MeshHexahedron() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshHexahedron_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshVolume); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshVolume); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshHexahedron", + sizeof(SMDS_MeshHexahedron), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshHexahedron) Handle(SMDS_MeshHexahedron)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshHexahedron) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshHexahedron))) { + _anOtherObject = Handle(SMDS_MeshHexahedron)((Handle(SMDS_MeshHexahedron)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshHexahedron::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshHexahedron) ; +} +Standard_Boolean SMDS_MeshHexahedron::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshHexahedron) == AType || SMDS_MeshVolume::IsKind(AType)); +} +Handle_SMDS_MeshHexahedron::~Handle_SMDS_MeshHexahedron() {} + diff --git a/src/SMDS/SMDS_MeshHexahedron.jxx b/src/SMDS/SMDS_MeshHexahedron.jxx new file mode 100644 index 000000000..4781dc0b3 --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.jxx @@ -0,0 +1,6 @@ +#ifndef _Standard_ConstructionError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshHexahedron_HeaderFile +#include "SMDS_MeshHexahedron.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshHexahedron.lxx b/src/SMDS/SMDS_MeshHexahedron.lxx new file mode 100644 index 000000000..317534352 --- /dev/null +++ b/src/SMDS/SMDS_MeshHexahedron.lxx @@ -0,0 +1,63 @@ +// File: SMDS_MeshHexahedron.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshHexahedron::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshHexahedron::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : ComputKey +//purpose : compute theKey of the volume based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshHexahedron::ComputeKey() +{ + // myKey = (myNodes[0]<<8) + (myNodes[1]<<7) + (myNodes[2]<<6) + (myNodes[3]<<5) + // +(myNodes[4]<<4) + (myNodes[5]<<3) + (myNodes[6]<<2) + myNodes[7]; + myKey = myNodes[0] + myNodes[1] + myNodes[2] + myNodes[3] + + myNodes[4] + myNodes[5] + myNodes[6] + myNodes[7]; +} + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshHexahedron::NbEdges() const +{ + return 12; +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshHexahedron::NbFaces() const +{ + return 6; +} + diff --git a/src/SMDS/SMDS_MeshIDFactory.cdl b/src/SMDS/SMDS_MeshIDFactory.cdl new file mode 100644 index 000000000..477a016a0 --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.cdl @@ -0,0 +1,32 @@ +-- File: SMDS_MeshIDFactory.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +private deferred class MeshIDFactory from SMDS inherits MeshObject + + ---Purpose: + +uses + StackOfInteger from TColStd + +is + + Initialize returns mutable MeshIDFactory from SMDS; + + GetFreeID(me:mutable) returns Integer is deferred; + ---Purpose: returns a free identifier for mesh from + -- the pool of ID + + + ReleaseID(me: mutable;ID :Integer) is deferred; + ---Purpose: free the ID and give it back to the pool of ID + + +fields + myMaxID : Integer is protected; + myPoolOfID : StackOfInteger from TColStd is protected; + +end MeshIDFactory; diff --git a/src/SMDS/SMDS_MeshIDFactory.cxx b/src/SMDS/SMDS_MeshIDFactory.cxx new file mode 100644 index 000000000..9cd72d412 --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.cxx @@ -0,0 +1,19 @@ +using namespace std; +// File: SMDS_MeshIDFactory.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshIDFactory.ixx" + + +//======================================================================= +//function : SMDS_MeshIDFactory +//purpose : +//======================================================================= + +SMDS_MeshIDFactory::SMDS_MeshIDFactory() : myMaxID(0) +{ +} + diff --git a/src/SMDS/SMDS_MeshIDFactory.hxx b/src/SMDS/SMDS_MeshIDFactory.hxx new file mode 100644 index 000000000..88a266aed --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.hxx @@ -0,0 +1,105 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshIDFactory_HeaderFile +#define _SMDS_MeshIDFactory_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile +#include "Handle_SMDS_MeshIDFactory.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _TColStd_StackOfInteger_HeaderFile +#include +#endif +#ifndef _SMDS_MeshObject_HeaderFile +#include "SMDS_MeshObject.hxx" +#endif + + +class SMDS_MeshIDFactory : 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 virtual Standard_Integer GetFreeID() = 0; +Standard_EXPORT virtual void ReleaseID(const Standard_Integer ID) = 0; +Standard_EXPORT ~SMDS_MeshIDFactory(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshIDFactory_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_MeshIDFactory(); + + + // Fields PROTECTED + // +Standard_Integer myMaxID; +TColStd_StackOfInteger myPoolOfID; + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshIDFactory.ixx b/src/SMDS/SMDS_MeshIDFactory.ixx new file mode 100644 index 000000000..ba32bcc39 --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshIDFactory.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshIDFactory::~SMDS_MeshIDFactory() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshIDFactory_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshIDFactory", + sizeof(SMDS_MeshIDFactory), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshIDFactory) Handle(SMDS_MeshIDFactory)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshIDFactory) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshIDFactory))) { + _anOtherObject = Handle(SMDS_MeshIDFactory)((Handle(SMDS_MeshIDFactory)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshIDFactory::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshIDFactory) ; +} +Standard_Boolean SMDS_MeshIDFactory::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshIDFactory) == AType || SMDS_MeshObject::IsKind(AType)); +} +Handle_SMDS_MeshIDFactory::~Handle_SMDS_MeshIDFactory() {} + diff --git a/src/SMDS/SMDS_MeshIDFactory.jxx b/src/SMDS/SMDS_MeshIDFactory.jxx new file mode 100644 index 000000000..ccb401f0a --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshIDFactory_HeaderFile +#include "SMDS_MeshIDFactory.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshIDFactory.lxx b/src/SMDS/SMDS_MeshIDFactory.lxx new file mode 100644 index 000000000..3731249be --- /dev/null +++ b/src/SMDS/SMDS_MeshIDFactory.lxx @@ -0,0 +1,34 @@ +// File: SMDS_MeshIDFactory.lxx +// Created: Thu Jan 24 12:10:57 2002 +// Author: Jean-Michel BOULCOURT +// + + +//======================================================================= +//function : GetFreeID +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshIDFactory::GetFreeID() +{ + if (myPoolOfID.IsEmpty()) + return ++myMaxID; + else { + Standard_Integer ID = myPoolOfID.Top(); + myPoolOfID.Pop(); + return ID; + } + +} + +//======================================================================= +//function : ReleaseID +//purpose : +//======================================================================= +inline void SMDS_MeshIDFactory::ReleaseID(const Standard_Integer ID) +{ + if (ID < myMaxID) + myPoolOfID.Push(ID); + +} + + diff --git a/src/SMDS/SMDS_MeshNode.cdl b/src/SMDS/SMDS_MeshNode.cdl new file mode 100755 index 000000000..319308cc6 --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.cdl @@ -0,0 +1,64 @@ +-- File: SMDS_MeshNode.cdl +-- Created: Wed Jan 23 16:15:04 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshNode from SMDS inherits MeshElement from SMDS + + ---Purpose: +uses + Pnt from gp, + MeshEdge from SMDS, + MeshFace from SMDS, + MeshVolume from SMDS, + ListOfMeshElement from SMDS, + Position from SMDS + +is + + Create (ID: Integer; x, y, z : Real) returns mutable MeshNode; + + Print(me; OS: in out OStream) is redefined static; + + GetKey(me) returns Integer is redefined static; + ---C++: inline + + X(me) returns Real; + ---C++: inline + + Y(me) returns Real; + ---C++: inline + + Z(me) returns Real; + ---C++: inline + + Pnt(me) returns Pnt from gp; + ---C++: inline + + SetPnt(me: mutable;P: Pnt from gp); + ---C++: inline + + AddInverseElement(me:mutable; ME: MeshElement from SMDS) is redefined static; + ---C++: inline + + RemoveInverseElement(me:mutable; parent: MeshElement from SMDS); + + InverseElements(me) returns ListOfMeshElement is redefined static; + ---C++: return const & + ---C++: inline + + ClearInverseElements(me: mutable) is redefined static; + ---C++: inline + + SetPosition(me: mutable; aPos: Position from SMDS); + + GetPosition(me) returns Position from SMDS; + +fields + myPnt : Pnt from gp; + myInverseElements : ListOfMeshElement from SMDS; + myPosition : Position from SMDS; + +end MeshNode; diff --git a/src/SMDS/SMDS_MeshNode.cxx b/src/SMDS/SMDS_MeshNode.cxx new file mode 100644 index 000000000..78a9b70da --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.cxx @@ -0,0 +1,83 @@ +using namespace std; +// File: SMDS_MeshNode.cxx +// Created: Wed Jan 23 17:02:11 2002 +// Author: Jean-Michel BOULCOURT +// + + +#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; +} + +//======================================================================= +//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()) +{ +} + + +//======================================================================= +//function : RemoveInverseElement +//purpose : +//======================================================================= + +void SMDS_MeshNode::RemoveInverseElement(const Handle(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; + } +} + + +//======================================================================= +//function : Print +//purpose : +//======================================================================= + +void SMDS_MeshNode::Print(Standard_OStream& OS) const +{ + OS << "Node <" << myID << "> : X = " << myPnt.X() << " Y = " << myPnt.Y() << " Z = " << myPnt.Z() << endl; +} + + +//======================================================================= +//function : SetPosition +//purpose : +//======================================================================= + +void SMDS_MeshNode::SetPosition(const Handle(SMDS_Position)& aPos) +{ + myPosition = aPos; +} + +//======================================================================= +//function : GetPosition +//purpose : +//======================================================================= + +Handle(SMDS_Position) SMDS_MeshNode::GetPosition() const +{ + return myPosition; +} + diff --git a/src/SMDS/SMDS_MeshNode.hxx b/src/SMDS/SMDS_MeshNode.hxx new file mode 100644 index 000000000..4d9c35d2e --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.hxx @@ -0,0 +1,137 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshNode_HeaderFile +#define _SMDS_MeshNode_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshNode_HeaderFile +#include "Handle_SMDS_MeshNode.hxx" +#endif + +#ifndef _gp_Pnt_HeaderFile +#include +#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 +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +#ifndef _Standard_OStream_HeaderFile +#include +#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_MeshNode.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshNode.ixx b/src/SMDS/SMDS_MeshNode.ixx new file mode 100644 index 000000000..1ed6b3a05 --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshNode.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshNode::~SMDS_MeshNode() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshNode_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshNode", + sizeof(SMDS_MeshNode), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshNode) Handle(SMDS_MeshNode)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshNode) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshNode))) { + _anOtherObject = Handle(SMDS_MeshNode)((Handle(SMDS_MeshNode)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshNode::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshNode) ; +} +Standard_Boolean SMDS_MeshNode::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshNode) == AType || SMDS_MeshElement::IsKind(AType)); +} +Handle_SMDS_MeshNode::~Handle_SMDS_MeshNode() {} + diff --git a/src/SMDS/SMDS_MeshNode.jxx b/src/SMDS/SMDS_MeshNode.jxx new file mode 100644 index 000000000..ed0b2b5f1 --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.jxx @@ -0,0 +1,12 @@ +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_ListOfMeshElement_HeaderFile +#include "SMDS_ListOfMeshElement.hxx" +#endif +#ifndef _SMDS_MeshNode_HeaderFile +#include "SMDS_MeshNode.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshNode.lxx b/src/SMDS/SMDS_MeshNode.lxx new file mode 100644 index 000000000..f42881218 --- /dev/null +++ b/src/SMDS/SMDS_MeshNode.lxx @@ -0,0 +1,103 @@ +// File: SMDS_MeshNode.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + +//======================================================================= +//function : GetKey +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshNode::GetKey() const +{ + return myID; +} + +//======================================================================= +//function : X +//purpose : +// +//======================================================================= + +inline Standard_Real SMDS_MeshNode::X() const +{ + return myPnt.X(); +} + +//======================================================================= +//function : Y +//purpose : +// +//======================================================================= + +inline Standard_Real SMDS_MeshNode::Y() const +{ + return myPnt.Y(); +} + +//======================================================================= +//function : Z +//purpose : +// +//======================================================================= + +inline Standard_Real SMDS_MeshNode::Z() const +{ + return myPnt.Z(); +} + +//======================================================================= +//function : Pnt +//purpose : +// +//======================================================================= + +inline gp_Pnt SMDS_MeshNode::Pnt() const +{ + return myPnt; +} + +//======================================================================= +//function : Pnt +//purpose : +// +//======================================================================= + +inline void SMDS_MeshNode::SetPnt(const gp_Pnt& P) +{ + myPnt = P; +} + +//======================================================================= +//function : AddInverseElement +//purpose : +//======================================================================= + +inline void SMDS_MeshNode::AddInverseElement(const Handle(SMDS_MeshElement)& ME) +{ + myInverseElements.Append(ME); +} + +//======================================================================= +//function : InverseElements +//purpose : +//======================================================================= + +inline const SMDS_ListOfMeshElement& SMDS_MeshNode::InverseElements() const +{ + return myInverseElements; +} + +//======================================================================= +//function : ClearInverseElements +//purpose : +//======================================================================= + +inline void SMDS_MeshNode::ClearInverseElements() +{ + myInverseElements.Clear(); +} + diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.cdl b/src/SMDS/SMDS_MeshNodeIDFactory.cdl new file mode 100644 index 000000000..8034b9e26 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.cdl @@ -0,0 +1,26 @@ +-- File: SMDS_MeshNodeIDFactory.cdl +-- Created: Tue May 7 16:18:08 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +private class MeshNodeIDFactory from SMDS inherits MeshIDFactory + + ---Purpose: + +is + + Create returns mutable MeshNodeIDFactory from SMDS; + + GetFreeID(me:mutable) returns Integer is redefined static; + ---Purpose: returns a free identifier for mesh from + -- the pool of ID + ---C++: inline + + ReleaseID(me: mutable;ID :Integer) is redefined static; + ---Purpose: free the ID and give it back to the pool of ID + ---C++: inline + + +end MeshNodeIDFactory; diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.cxx b/src/SMDS/SMDS_MeshNodeIDFactory.cxx new file mode 100644 index 000000000..27af9b907 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.cxx @@ -0,0 +1,18 @@ +using namespace std; +// File: SMDS_MeshNodeIDFactory.cxx +// Created: Tue May 7 16:58:57 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshNodeIDFactory.ixx" + +//======================================================================= +//function : SMDS_MeshNodeIDFactory +//purpose : +//======================================================================= + +SMDS_MeshNodeIDFactory::SMDS_MeshNodeIDFactory() : SMDS_MeshIDFactory() +{ +} + diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.hxx b/src/SMDS/SMDS_MeshNodeIDFactory.hxx new file mode 100644 index 000000000..44af92bc3 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.hxx @@ -0,0 +1,101 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshNodeIDFactory_HeaderFile +#define _SMDS_MeshNodeIDFactory_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile +#include "Handle_SMDS_MeshNodeIDFactory.hxx" +#endif + +#ifndef _SMDS_MeshIDFactory_HeaderFile +#include "SMDS_MeshIDFactory.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif + + +class SMDS_MeshNodeIDFactory : public SMDS_MeshIDFactory { + +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_MeshNodeIDFactory(); +Standard_EXPORT inline Standard_Integer GetFreeID() ; +Standard_EXPORT inline void ReleaseID(const Standard_Integer ID) ; +Standard_EXPORT ~SMDS_MeshNodeIDFactory(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshNodeIDFactory_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 + // + + +}; + + +#include "SMDS_MeshNodeIDFactory.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.ixx b/src/SMDS/SMDS_MeshNodeIDFactory.ixx new file mode 100644 index 000000000..6dfed0eac --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshNodeIDFactory.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshNodeIDFactory::~SMDS_MeshNodeIDFactory() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshNodeIDFactory_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshIDFactory); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshIDFactory); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshNodeIDFactory", + sizeof(SMDS_MeshNodeIDFactory), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshNodeIDFactory) Handle(SMDS_MeshNodeIDFactory)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshNodeIDFactory) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshNodeIDFactory))) { + _anOtherObject = Handle(SMDS_MeshNodeIDFactory)((Handle(SMDS_MeshNodeIDFactory)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshNodeIDFactory::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshNodeIDFactory) ; +} +Standard_Boolean SMDS_MeshNodeIDFactory::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshNodeIDFactory) == AType || SMDS_MeshIDFactory::IsKind(AType)); +} +Handle_SMDS_MeshNodeIDFactory::~Handle_SMDS_MeshNodeIDFactory() {} + diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.jxx b/src/SMDS/SMDS_MeshNodeIDFactory.jxx new file mode 100644 index 000000000..d4a69a63f --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshNodeIDFactory_HeaderFile +#include "SMDS_MeshNodeIDFactory.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshNodeIDFactory.lxx b/src/SMDS/SMDS_MeshNodeIDFactory.lxx new file mode 100644 index 000000000..612feb3ac --- /dev/null +++ b/src/SMDS/SMDS_MeshNodeIDFactory.lxx @@ -0,0 +1,34 @@ +// File: SMDS_MeshNodeIDFactory.lxx +// Created: Thu Jan 24 12:10:57 2002 +// Author: Jean-Michel BOULCOURT +// + + +//======================================================================= +//function : GetFreeID +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshNodeIDFactory::GetFreeID() +{ + if (myPoolOfID.IsEmpty()) + return ++myMaxID; + else { + Standard_Integer ID = myPoolOfID.Top(); + myPoolOfID.Pop(); + return ID; + } + +} + +//======================================================================= +//function : ReleaseID +//purpose : +//======================================================================= +inline void SMDS_MeshNodeIDFactory::ReleaseID(const Standard_Integer ID) +{ + if (ID < myMaxID) + myPoolOfID.Push(ID); + +} + + diff --git a/src/SMDS/SMDS_MeshNodesIterator.cdl b/src/SMDS/SMDS_MeshNodesIterator.cdl new file mode 100644 index 000000000..0073a7ea1 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodesIterator.cdl @@ -0,0 +1,34 @@ +-- File: SMDS_MeshNodesIterator.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshNodesIterator from SMDS inherits MeshElementsIterator + + ---Purpose: The Iterator objet to iterate on all faces of a mesh + -- + +uses + Mesh from SMDS, + MeshElement from SMDS + +raises + NoMoreObject, + NoSuchObject + +is + + Create returns MeshNodesIterator from SMDS; + ---Purpose: Creates an empty Iterator. + + Create(M : Mesh from SMDS) returns MeshNodesIterator from SMDS; + ---Purpose: Creates an Iterator on faces of mesh . + + Initialize(me : in out; M : Mesh from SMDS) + ---Purpose: Reset the Iterator on the faces of mesh . + is redefined static; + + +end MeshNodesIterator; diff --git a/src/SMDS/SMDS_MeshNodesIterator.cxx b/src/SMDS/SMDS_MeshNodesIterator.cxx new file mode 100644 index 000000000..4ad9748a2 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodesIterator.cxx @@ -0,0 +1,42 @@ +using namespace std; +// File: SMDS_MeshNodesIterator.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshNodesIterator.ixx" + +//======================================================================= +//function : SMDS_MeshNodesIterator +//purpose : +//======================================================================= + +SMDS_MeshNodesIterator::SMDS_MeshNodesIterator() +{ +} + +//======================================================================= +//function : SMDS_MeshNodesIterator +//purpose : +//======================================================================= + +SMDS_MeshNodesIterator::SMDS_MeshNodesIterator(const Handle(SMDS_Mesh)& M) +{ + Initialize(M); +} + +//======================================================================= +//function : Initialize +//purpose : +//======================================================================= + +void SMDS_MeshNodesIterator::Initialize(const Handle(SMDS_Mesh)& M) +{ + + myMapIterator.Initialize(M->myNodes); + if (More()) { + myCurrentMeshElement = myMapIterator.Key(); + } +} + diff --git a/src/SMDS/SMDS_MeshNodesIterator.hxx b/src/SMDS/SMDS_MeshNodesIterator.hxx new file mode 100644 index 000000000..531145b10 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodesIterator.hxx @@ -0,0 +1,96 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshNodesIterator_HeaderFile +#define _SMDS_MeshNodesIterator_HeaderFile + +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#include "SMDS_MeshElementsIterator.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_Mesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshNodesIterator : public SMDS_MeshElementsIterator { + +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_MeshNodesIterator(); +Standard_EXPORT SMDS_MeshNodesIterator(const Handle(SMDS_Mesh)& M); +Standard_EXPORT void Initialize(const Handle(SMDS_Mesh)& M) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshNodesIterator.ixx b/src/SMDS/SMDS_MeshNodesIterator.ixx new file mode 100644 index 000000000..ed29b9020 --- /dev/null +++ b/src/SMDS/SMDS_MeshNodesIterator.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshNodesIterator.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshNodesIterator.jxx b/src/SMDS/SMDS_MeshNodesIterator.jxx new file mode 100644 index 000000000..046b05f7b --- /dev/null +++ b/src/SMDS/SMDS_MeshNodesIterator.jxx @@ -0,0 +1,12 @@ +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshNodesIterator_HeaderFile +#include "SMDS_MeshNodesIterator.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshObject.cdl b/src/SMDS/SMDS_MeshObject.cdl new file mode 100644 index 000000000..3bc214260 --- /dev/null +++ b/src/SMDS/SMDS_MeshObject.cdl @@ -0,0 +1,15 @@ +-- File: SMDS_MeshObject.cdl +-- Created: Wed Jan 23 12:01:38 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshObject from SMDS inherits TShared from MMgt + + ---Purpose: + +is + + +end MeshObject; diff --git a/src/SMDS/SMDS_MeshObject.cxx b/src/SMDS/SMDS_MeshObject.cxx new file mode 100644 index 000000000..3a4956159 --- /dev/null +++ b/src/SMDS/SMDS_MeshObject.cxx @@ -0,0 +1,8 @@ +using namespace std; +// File: SMDS_MeshObject.cxx +// Created: Wed Jan 23 16:48:49 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshObject.ixx" diff --git a/src/SMDS/SMDS_MeshObject.hxx b/src/SMDS/SMDS_MeshObject.hxx new file mode 100644 index 000000000..799ce1514 --- /dev/null +++ b/src/SMDS/SMDS_MeshObject.hxx @@ -0,0 +1,94 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshObject_HeaderFile +#define _SMDS_MeshObject_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshObject_HeaderFile +#include "Handle_SMDS_MeshObject.hxx" +#endif + +#ifndef _MMgt_TShared_HeaderFile +#include +#endif + + +class SMDS_MeshObject : public MMgt_TShared { + +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_MeshObject(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshObject_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 + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshObject.ixx b/src/SMDS/SMDS_MeshObject.ixx new file mode 100644 index 000000000..db154fa4d --- /dev/null +++ b/src/SMDS/SMDS_MeshObject.ixx @@ -0,0 +1,69 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshObject.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshObject::~SMDS_MeshObject() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshObject_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshObject", + sizeof(SMDS_MeshObject), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshObject) Handle(SMDS_MeshObject)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshObject) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshObject))) { + _anOtherObject = Handle(SMDS_MeshObject)((Handle(SMDS_MeshObject)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshObject::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshObject) ; +} +Standard_Boolean SMDS_MeshObject::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshObject) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMDS_MeshObject::~Handle_SMDS_MeshObject() {} + diff --git a/src/SMDS/SMDS_MeshObject.jxx b/src/SMDS/SMDS_MeshObject.jxx new file mode 100644 index 000000000..8b5d16d76 --- /dev/null +++ b/src/SMDS/SMDS_MeshObject.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshObject_HeaderFile +#include "SMDS_MeshObject.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.cdl b/src/SMDS/SMDS_MeshOrientedElementMapHasher.cdl new file mode 100644 index 000000000..195e379ad --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.cdl @@ -0,0 +1,31 @@ +-- File: SMDS_MeshOrientedElementMapHasher.cdl +-- Created: Wed Jan 23 14:04:07 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshOrientedElementMapHasher from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + + +is + HashCode(myclass; ME: MeshElement from SMDS; Upper : Integer) returns Integer; + ---Purpose: Returns a HasCode value for the Key in the + -- range 0..Upper. + -- + ---C++: inline + + IsEqual(myclass; ME1, ME2 : MeshElement from SMDS) returns Boolean; + ---Purpose: Returns True when the two keys are the same. Two + -- same keys must have the same hashcode, the + -- contrary is not necessary. + -- + ---C++: inline + + +end MeshOrientedElementMapHasher; diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.cxx b/src/SMDS/SMDS_MeshOrientedElementMapHasher.cxx new file mode 100644 index 000000000..691daf033 --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.cxx @@ -0,0 +1,8 @@ +using namespace std; +// File: SMDS_MeshOrientedElementMapHasher.cxx +// Created: Wed Jan 23 14:09:30 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshOrientedElementMapHasher.ixx" diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.hxx b/src/SMDS/SMDS_MeshOrientedElementMapHasher.hxx new file mode 100644 index 000000000..034efcb8b --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.hxx @@ -0,0 +1,97 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile +#define _SMDS_MeshOrientedElementMapHasher_HeaderFile + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class SMDS_MeshElement; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshOrientedElementMapHasher { + +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 static Standard_Integer HashCode(const Handle(SMDS_MeshElement)& ME,const Standard_Integer Upper) ; +Standard_EXPORT inline static Standard_Boolean IsEqual(const Handle(SMDS_MeshElement)& ME1,const Handle(SMDS_MeshElement)& ME2) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_MeshOrientedElementMapHasher.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.ixx b/src/SMDS/SMDS_MeshOrientedElementMapHasher.ixx new file mode 100644 index 000000000..7ccc92b3e --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshOrientedElementMapHasher.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.jxx b/src/SMDS/SMDS_MeshOrientedElementMapHasher.jxx new file mode 100644 index 000000000..16b28c35b --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.jxx @@ -0,0 +1,6 @@ +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile +#include "SMDS_MeshOrientedElementMapHasher.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshOrientedElementMapHasher.lxx b/src/SMDS/SMDS_MeshOrientedElementMapHasher.lxx new file mode 100644 index 000000000..5ca24a19b --- /dev/null +++ b/src/SMDS/SMDS_MeshOrientedElementMapHasher.lxx @@ -0,0 +1,27 @@ +// File: SMDS_MeshOrientedElementMapHasher.lxx +// Created: Wed Jan 23 14:07:00 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshElement.hxx" + +//======================================================================= +//function : HashCode +//purpose : +//======================================================================= +inline Standard_Integer SMDS_MeshOrientedElementMapHasher::HashCode + (const Handle(SMDS_MeshElement)& ME, const Standard_Integer Upper) +{ + return ME->HashCode(Upper); +} + +//======================================================================= +//function : IsEqual +//purpose : +//======================================================================= +inline Standard_Boolean SMDS_MeshOrientedElementMapHasher::IsEqual + (const Handle(SMDS_MeshElement)& ME1, const Handle(SMDS_MeshElement)& ME2) +{ + return ME1->IsEqual(ME2); +} diff --git a/src/SMDS/SMDS_MeshPrism.cdl b/src/SMDS/SMDS_MeshPrism.cdl new file mode 100644 index 000000000..b0f6ff347 --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.cdl @@ -0,0 +1,67 @@ +-- File: SMDS_MeshPrism.cdl +-- Created: Wed Jan 23 16:17:22 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshPrism from SMDS inherits MeshVolume from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + + +raises + ConstructionError from Standard + +is + + Create (ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6: Integer) + returns mutable MeshPrism; + ---Purpose: constructor for a prism + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1 : out Integer; idnode2: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + GetFaceDefinedByNodes(me; rank: Integer; idnode : Address; nb: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith face (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + ComputeKey(me: mutable); + ---Purpose: compute the ID of the volume based on the id's of its + -- bounding nodes + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2,idnode3,idnode4,idnode5,idnode6: Integer) is private; + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + NbEdges(me) returns Integer + is redefined static; + ---C++: inline + + NbFaces(me) returns Integer + is redefined static; + ---C++: inline + + NodesOfFace(myclass; rankface,ranknode: Integer) + returns Integer; + ---Purpose: returns the rank node in mynodes. Useful to extract faces from volume + -- + NodesOfEdge(me; rankedge: Integer; ranknode: Integer) returns Integer; + + +fields + + myNodes : Integer [6]; + +end MeshPrism; diff --git a/src/SMDS/SMDS_MeshPrism.cxx b/src/SMDS/SMDS_MeshPrism.cxx new file mode 100644 index 000000000..94568ca01 --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.cxx @@ -0,0 +1,161 @@ +using namespace std; +// File: SMDS_MeshPrism.cxx +// Created: Wed Jan 23 17:02:34 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshPrism.ixx" +#include "Standard_ConstructionError.hxx" + + +//======================================================================= +//function : SMDS_MeshPrism +//purpose : Prism +//======================================================================= + +SMDS_MeshPrism::SMDS_MeshPrism(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):SMDS_MeshVolume(ID,6) +{ + SetConnections(idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); + ComputeKey(); +} + + +//======================================================================= +//function : SetConnections +//purpose : Prism +//======================================================================= +void SMDS_MeshPrism::SetConnections(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_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + idmin = (idmin < idnode4 ? idmin : idnode4); + idmin = (idmin < idnode5 ? idmin : idnode5); + idmin = (idmin < idnode6 ? idmin : idnode6); + + myNodes[0] = idmin; + if (idmin == idnode1) { // 1 2 3 4 5 6 + myNodes[1] = idnode2; + myNodes[2] = idnode3; + myNodes[3] = idnode4; + myNodes[4] = idnode5; + myNodes[5] = idnode6; + } else if (idmin == idnode2) { // 2 3 1 5 6 4 + myNodes[1] = idnode3; + myNodes[2] = idnode1; + myNodes[3] = idnode5; + myNodes[4] = idnode6; + myNodes[5] = idnode4; + } else if (idmin == idnode3) { // 3 1 2 6 4 5 + myNodes[1] = idnode1; + myNodes[2] = idnode2; + myNodes[3] = idnode6; + myNodes[4] = idnode4; + myNodes[5] = idnode5; + } else if (idmin == idnode4) { // 4 5 6 1 2 3 + myNodes[1] = idnode5; + myNodes[2] = idnode6; + myNodes[3] = idnode1; + myNodes[4] = idnode2; + myNodes[5] = idnode3; + } else if (idmin == idnode5) { // 5 6 4 2 3 1 + myNodes[1] = idnode6; + myNodes[2] = idnode4; + myNodes[3] = idnode2; + myNodes[4] = idnode3; + myNodes[5] = idnode1; + } else { // 6 4 5 3 1 2 + myNodes[1] = idnode4; + myNodes[2] = idnode5; + myNodes[3] = idnode3; + myNodes[4] = idnode1; + myNodes[5] = idnode2; + } + +} + + +//======================================================================= +//function : NodesOfFace +//purpose : returns the rank node in mynodes. Useful to extract faces from volume +//======================================================================= +Standard_Integer SMDS_MeshPrism::NodesOfFace(const Standard_Integer rankface, + const Standard_Integer ranknode) +{ + static Standard_Integer facenode[5][4] = { + {0,1,2,-1}, + {3,5,4,-1}, + {0,3,4,1}, + {1,4,5,2}, + {2,5,3,0} + }; + + return facenode[rankface-1][ranknode-1]; +} + +//======================================================================= +//function : NodesOfEdge +//purpose : returns the rank node in mynodes. Useful to extract edges from volume +//======================================================================= +Standard_Integer SMDS_MeshPrism::NodesOfEdge(const Standard_Integer rankedge, + const Standard_Integer ranknode) const +{ + static Standard_Integer faceedge[9][2] = { + {0,1}, + {1,2}, + {0,2}, + {3,5}, + {4,5}, + {3,4}, + {0,3}, + {1,4}, + {2,5} + + }; + + return faceedge[rankedge-1][ranknode-1]; +} + +//======================================================================= +//function : GetFaceDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshPrism::GetFaceDefinedByNodes(const Standard_Integer rank, + const Standard_Address idnode, + Standard_Integer& nb) const +{ + Standard_Integer *ptr; + ptr = (Standard_Integer *)idnode; + ptr[0] = myNodes[NodesOfFace(rank,1)]; + ptr[1] = myNodes[NodesOfFace(rank,2)]; + ptr[2] = myNodes[NodesOfFace(rank,3)]; + ptr[3] = myNodes[NodesOfFace(rank,4)]; + nb = (NodesOfFace(rank,4) == -1 ? 3 : 4); + if (nb == 4) + ptr[3] = myNodes[NodesOfFace(rank,4)]; + +} + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshPrism::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[NodesOfEdge(rank,1)]; + idnode2 = myNodes[NodesOfEdge(rank,2)]; +} + diff --git a/src/SMDS/SMDS_MeshPrism.hxx b/src/SMDS/SMDS_MeshPrism.hxx new file mode 100644 index 000000000..41d0e6caf --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.hxx @@ -0,0 +1,114 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshPrism_HeaderFile +#define _SMDS_MeshPrism_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshPrism_HeaderFile +#include "Handle_SMDS_MeshPrism.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include "Standard_Integer.hxx" +#endif +#ifndef _SMDS_MeshVolume_HeaderFile +#include "SMDS_MeshVolume.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +class Standard_ConstructionError; + + +class SMDS_MeshPrism : public SMDS_MeshVolume { + +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_MeshPrism(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); +Standard_EXPORT void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const; +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT inline Standard_Integer NbEdges() const; +Standard_EXPORT inline Standard_Integer NbFaces() const; +Standard_EXPORT static Standard_Integer NodesOfFace(const Standard_Integer rankface,const Standard_Integer ranknode) ; +Standard_EXPORT Standard_Integer NodesOfEdge(const Standard_Integer rankedge,const Standard_Integer ranknode) const; +Standard_EXPORT ~SMDS_MeshPrism(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshPrism_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 + // +Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[6]; + + +}; + + +#include "SMDS_MeshPrism.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshPrism.ixx b/src/SMDS/SMDS_MeshPrism.ixx new file mode 100644 index 000000000..9c18b92a4 --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshPrism.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshPrism::~SMDS_MeshPrism() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshPrism_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshVolume); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshVolume); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshPrism", + sizeof(SMDS_MeshPrism), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshPrism) Handle(SMDS_MeshPrism)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshPrism) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshPrism))) { + _anOtherObject = Handle(SMDS_MeshPrism)((Handle(SMDS_MeshPrism)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshPrism::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshPrism) ; +} +Standard_Boolean SMDS_MeshPrism::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshPrism) == AType || SMDS_MeshVolume::IsKind(AType)); +} +Handle_SMDS_MeshPrism::~Handle_SMDS_MeshPrism() {} + diff --git a/src/SMDS/SMDS_MeshPrism.jxx b/src/SMDS/SMDS_MeshPrism.jxx new file mode 100644 index 000000000..f6f50b50f --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.jxx @@ -0,0 +1,6 @@ +#ifndef _Standard_ConstructionError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshPrism_HeaderFile +#include "SMDS_MeshPrism.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshPrism.lxx b/src/SMDS/SMDS_MeshPrism.lxx new file mode 100644 index 000000000..56a987f54 --- /dev/null +++ b/src/SMDS/SMDS_MeshPrism.lxx @@ -0,0 +1,62 @@ +// File: SMDS_MeshPrism.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshPrism::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshPrism::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the volume based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshPrism::ComputeKey() +{ + // myKey = (myNodes[0]<<5) + (myNodes[1]<<4) + (myNodes[2]<<3) + (myNodes[3]<<2) + // +(myNodes[4]<<1) + myNodes[5]; + myKey = myNodes[0] + myNodes[1] + myNodes[2] + myNodes[3] + myNodes[4] + myNodes[5]; +} + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshPrism::NbEdges() const +{ + return 9; +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshPrism::NbFaces() const +{ + return 5; +} + diff --git a/src/SMDS/SMDS_MeshPyramid.cdl b/src/SMDS/SMDS_MeshPyramid.cdl new file mode 100644 index 000000000..5f9839806 --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.cdl @@ -0,0 +1,68 @@ +-- File: SMDS_MeshPyramid.cdl +-- Created: Wed Jan 23 16:17:22 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshPyramid from SMDS inherits MeshVolume from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +raises + ConstructionError from Standard + +is + + Create (ID,idnode1,idnode2,idnode3,idnode4,idnode5: Integer) returns mutable MeshPyramid; + ---Purpose: constructor for a pyramid + + + GetFaceDefinedByNodes(me; rank: Integer; idnode : Address; nb: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith face (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1 : out Integer; idnode2: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + ComputeKey(me: mutable); + ---Purpose: compute the ID of the volume based on the id's of its + -- bounding nodes + ---C++: inline + + + SetConnections(me: mutable; idnode1,idnode2,idnode3,idnode4,idnode5: Integer) is private; + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + NbEdges(me) returns Integer + is redefined static; + ---C++: inline + + NbFaces(me) returns Integer + is redefined static; + ---C++: inline + + NodesOfFace(myclass; rankface,ranknode: Integer) + returns Integer; + ---Purpose: returns the rank node in mynodes. Useful to extract faces from volume + -- + + NodesOfEdge(me; rankedge: Integer; ranknode: Integer) returns Integer; + + +fields + + myNodes : Integer [5]; + +end MeshPyramid; diff --git a/src/SMDS/SMDS_MeshPyramid.cxx b/src/SMDS/SMDS_MeshPyramid.cxx new file mode 100644 index 000000000..d6868bb5d --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.cxx @@ -0,0 +1,147 @@ +using namespace std; +// File: SMDS_MeshPyramid.cxx +// Created: Wed Jan 23 17:02:34 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshPyramid.ixx" +#include + + +//======================================================================= +//function : SMDS_MeshPyramid +//purpose : Pyramid +//======================================================================= + +SMDS_MeshPyramid::SMDS_MeshPyramid(const Standard_Integer ID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5):SMDS_MeshVolume(ID,5) +{ + SetConnections(idnode1,idnode2,idnode3,idnode4,idnode5); + ComputeKey(); +} + + + +//======================================================================= +//function : SetConnections +//purpose : Pyramid +//======================================================================= +void SMDS_MeshPyramid::SetConnections(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5) +{ + + Standard_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + idmin = (idmin < idnode4 ? idmin : idnode4); + idmin = (idmin < idnode5 ? idmin : idnode5); + + myNodes[0] = idmin; + if (idmin == idnode1) { // 1 2 3 4 5 + myNodes[1] = idnode2; + myNodes[2] = idnode3; + myNodes[3] = idnode4; + myNodes[4] = idnode5; + } else if (idmin == idnode2) { // 2 3 4 5 1 + myNodes[1] = idnode3; + myNodes[2] = idnode4; + myNodes[3] = idnode5; + myNodes[4] = idnode1; + } else if (idmin == idnode3) { // 3 4 5 1 2 + myNodes[1] = idnode4; + myNodes[2] = idnode5; + myNodes[3] = idnode1; + myNodes[4] = idnode2; + } else if (idmin == idnode4) { // 4 5 1 2 3 + myNodes[1] = idnode5; + myNodes[2] = idnode1; + myNodes[3] = idnode2; + myNodes[4] = idnode3; + } else { // 5 1 2 3 4 + myNodes[1] = idnode1; + myNodes[2] = idnode2; + myNodes[3] = idnode3; + myNodes[4] = idnode4; + } + +} + +//======================================================================= +//function : NodesOfFace +//purpose : returns the rank node in mynodes. Useful to extract faces from volume +//======================================================================= +Standard_Integer SMDS_MeshPyramid::NodesOfFace(const Standard_Integer rankface, + const Standard_Integer ranknode) +{ + static Standard_Integer facenode[5][4] = { + {0,1,2,3}, + {0,4,1,-1}, + {1,4,2,-1}, + {2,4,3,-1}, + {0,3,4,-1} + }; + + return facenode[rankface-1][ranknode-1]; +} + +//======================================================================= +//function : NodesOfEdge +//purpose : returns the rank node in mynodes. Useful to extract edges from volume +//======================================================================= +Standard_Integer SMDS_MeshPyramid::NodesOfEdge(const Standard_Integer rankedge, + const Standard_Integer ranknode) const +{ + static Standard_Integer faceedge[8][2] = { + {0,1}, + {1,2}, + {2,3}, + {0,3}, + {0,4}, + {1,4}, + {2,4}, + {3,4} + + }; + + return faceedge[rankedge-1][ranknode-1]; +} + + +//======================================================================= +//function : GetFaceDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshPyramid::GetFaceDefinedByNodes(const Standard_Integer rank, + const Standard_Address idnode, + Standard_Integer& nb) const +{ + Standard_Integer *ptr; + ptr = (Standard_Integer *)idnode; + ptr[0] = myNodes[NodesOfFace(rank,1)]; + ptr[1] = myNodes[NodesOfFace(rank,2)]; + ptr[2] = myNodes[NodesOfFace(rank,3)]; + nb = (NodesOfFace(rank,4) == -1 ? 3 : 4); + if (nb == 4) + ptr[3] = myNodes[NodesOfFace(rank,4)]; + +} + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshPyramid::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[NodesOfEdge(rank,1)]; + idnode2 = myNodes[NodesOfEdge(rank,2)]; +} + diff --git a/src/SMDS/SMDS_MeshPyramid.hxx b/src/SMDS/SMDS_MeshPyramid.hxx new file mode 100644 index 000000000..2aa2c4623 --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.hxx @@ -0,0 +1,114 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshPyramid_HeaderFile +#define _SMDS_MeshPyramid_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshPyramid_HeaderFile +#include "Handle_SMDS_MeshPyramid.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshVolume_HeaderFile +#include "SMDS_MeshVolume.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +class Standard_ConstructionError; + + +class SMDS_MeshPyramid : public SMDS_MeshVolume { + +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_MeshPyramid(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5); +Standard_EXPORT void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const; +Standard_EXPORT void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT inline Standard_Integer NbEdges() const; +Standard_EXPORT inline Standard_Integer NbFaces() const; +Standard_EXPORT static Standard_Integer NodesOfFace(const Standard_Integer rankface,const Standard_Integer ranknode) ; +Standard_EXPORT Standard_Integer NodesOfEdge(const Standard_Integer rankedge,const Standard_Integer ranknode) const; +Standard_EXPORT ~SMDS_MeshPyramid(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshPyramid_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 + // +Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[5]; + + +}; + + +#include "SMDS_MeshPyramid.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshPyramid.ixx b/src/SMDS/SMDS_MeshPyramid.ixx new file mode 100644 index 000000000..62833c223 --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshPyramid.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshPyramid::~SMDS_MeshPyramid() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshPyramid_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshVolume); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshVolume); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshPyramid", + sizeof(SMDS_MeshPyramid), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshPyramid) Handle(SMDS_MeshPyramid)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshPyramid) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshPyramid))) { + _anOtherObject = Handle(SMDS_MeshPyramid)((Handle(SMDS_MeshPyramid)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshPyramid::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshPyramid) ; +} +Standard_Boolean SMDS_MeshPyramid::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshPyramid) == AType || SMDS_MeshVolume::IsKind(AType)); +} +Handle_SMDS_MeshPyramid::~Handle_SMDS_MeshPyramid() {} + diff --git a/src/SMDS/SMDS_MeshPyramid.jxx b/src/SMDS/SMDS_MeshPyramid.jxx new file mode 100644 index 000000000..5799b956c --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.jxx @@ -0,0 +1,6 @@ +#ifndef _Standard_ConstructionError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshPyramid_HeaderFile +#include "SMDS_MeshPyramid.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshPyramid.lxx b/src/SMDS/SMDS_MeshPyramid.lxx new file mode 100644 index 000000000..015b90f28 --- /dev/null +++ b/src/SMDS/SMDS_MeshPyramid.lxx @@ -0,0 +1,61 @@ +// File: SMDS_MeshPyramid.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshPyramid::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshPyramid::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the volume based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshPyramid::ComputeKey() +{ + // myKey = (myNodes[0]<<4) + (myNodes[1]<<3) + (myNodes[2]<<2) + (myNodes[3]<<1) + myNodes[4]; + myKey = myNodes[0] + myNodes[1] + myNodes[2] + myNodes[3] + myNodes[4]; +} + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshPyramid::NbEdges() const +{ + return 8; +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshPyramid::NbFaces() const +{ + return 5; +} + diff --git a/src/SMDS/SMDS_MeshQuadrangle.cdl b/src/SMDS/SMDS_MeshQuadrangle.cdl new file mode 100644 index 000000000..ba5a3afcc --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.cdl @@ -0,0 +1,43 @@ +-- File: SMDS_MeshQuadrangle.cdl +-- Created: Wed Jan 23 16:16:09 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshQuadrangle from SMDS inherits MeshFace from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +is + + Create (ID,idnode1,idnode2,idnode3,idnode4: Integer) returns mutable MeshQuadrangle; + ---Purpose: constructor for a quandrangle + + ComputeKey(me: mutable) is redefined static; + ---Purpose: compute the ID of the face based on the id's of its + -- bounding nodes + ---C++: inline + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1, idnode2 : out Integer) is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the face + -- rank must be comprised between 1 and myNbConnections included. + ---C++: inline + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2,idnode3,idnode4: Integer) is private; + + +fields + + myNodes : Integer [4]; + +end MeshQuadrangle; diff --git a/src/SMDS/SMDS_MeshQuadrangle.cxx b/src/SMDS/SMDS_MeshQuadrangle.cxx new file mode 100644 index 000000000..6482a1dc4 --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.cxx @@ -0,0 +1,62 @@ +using namespace std; +// File: SMDS_MeshQuadrangle.cxx +// Created: Wed Jan 23 17:02:27 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshQuadrangle.ixx" + + + +//======================================================================= +//function : SMDS_MeshQuadrangle +//purpose : +//======================================================================= + +SMDS_MeshQuadrangle::SMDS_MeshQuadrangle(const Standard_Integer ID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4):SMDS_MeshFace(ID,4) +{ + SetConnections(idnode1,idnode2,idnode3,idnode4); + ComputeKey(); +} + + + +//======================================================================= +//function : SetConnections +//purpose : +//======================================================================= +void SMDS_MeshQuadrangle::SetConnections(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Standard_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + idmin = (idmin < idnode4 ? idmin : idnode4); + + myNodes[0] = idmin; + if (idmin == idnode1) { + myNodes[1] = idnode2; + myNodes[2] = idnode3; + myNodes[3] = idnode4; + } else if (idmin == idnode2) { + myNodes[1] = idnode3; + myNodes[2] = idnode4; + myNodes[3] = idnode1; + } else if (idmin == idnode3) { + myNodes[1] = idnode4; + myNodes[2] = idnode1; + myNodes[3] = idnode2; + } else { + myNodes[1] = idnode1; + myNodes[2] = idnode2; + myNodes[3] = idnode3; + } + +} + diff --git a/src/SMDS/SMDS_MeshQuadrangle.hxx b/src/SMDS/SMDS_MeshQuadrangle.hxx new file mode 100644 index 000000000..3369f7689 --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.hxx @@ -0,0 +1,108 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshQuadrangle_HeaderFile +#define _SMDS_MeshQuadrangle_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshQuadrangle_HeaderFile +#include "Handle_SMDS_MeshQuadrangle.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshFace_HeaderFile +#include "SMDS_MeshFace.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif + + +class SMDS_MeshQuadrangle : public SMDS_MeshFace { + +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_MeshQuadrangle(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4); +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT ~SMDS_MeshQuadrangle(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshQuadrangle_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 + // +Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[4]; + + +}; + + +#include "SMDS_MeshQuadrangle.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshQuadrangle.ixx b/src/SMDS/SMDS_MeshQuadrangle.ixx new file mode 100644 index 000000000..e4eb0b0ee --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshQuadrangle.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshQuadrangle::~SMDS_MeshQuadrangle() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshQuadrangle_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshFace); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshFace); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshQuadrangle", + sizeof(SMDS_MeshQuadrangle), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshQuadrangle) Handle(SMDS_MeshQuadrangle)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshQuadrangle) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshQuadrangle))) { + _anOtherObject = Handle(SMDS_MeshQuadrangle)((Handle(SMDS_MeshQuadrangle)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshQuadrangle::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshQuadrangle) ; +} +Standard_Boolean SMDS_MeshQuadrangle::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshQuadrangle) == AType || SMDS_MeshFace::IsKind(AType)); +} +Handle_SMDS_MeshQuadrangle::~Handle_SMDS_MeshQuadrangle() {} + diff --git a/src/SMDS/SMDS_MeshQuadrangle.jxx b/src/SMDS/SMDS_MeshQuadrangle.jxx new file mode 100644 index 000000000..dd888e069 --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshQuadrangle_HeaderFile +#include "SMDS_MeshQuadrangle.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshQuadrangle.lxx b/src/SMDS/SMDS_MeshQuadrangle.lxx new file mode 100644 index 000000000..8acbba93c --- /dev/null +++ b/src/SMDS/SMDS_MeshQuadrangle.lxx @@ -0,0 +1,53 @@ +// File: SMDS_MeshQuadrangle.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshQuadrangle::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshQuadrangle::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the face based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshQuadrangle::ComputeKey() +{ + // myKey = (myNodes[0] << 3) + (myNodes[1] << 2) + (myNodes[2] << 1) + myNodes[3]; + myKey = myNodes[0] + myNodes[1] + myNodes[2] + myNodes[3]; +} + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +inline void SMDS_MeshQuadrangle::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[rank-1]; + idnode2 = myNodes[rank % myNbNodes]; +} + diff --git a/src/SMDS/SMDS_MeshTetrahedron.cdl b/src/SMDS/SMDS_MeshTetrahedron.cdl new file mode 100644 index 000000000..a15a0acc7 --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.cdl @@ -0,0 +1,67 @@ +-- File: SMDS_MeshTetrahedron.cdl +-- Created: Wed Jan 23 16:17:22 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshTetrahedron from SMDS inherits MeshVolume from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +raises + ConstructionError from Standard + +is + + Create (ID, idnode1,idnode2,idnode3,idnode4: Integer) returns mutable MeshTetrahedron; + ---Purpose: constructor for a tetrahedra + + GetFaceDefinedByNodes(me; rank: Integer; idnode : Address; nb: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith face (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1 : out Integer; idnode2: out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the volume + -- rank must be comprised between 1 and myNbConnections included. + + + ComputeKey(me: mutable) is redefined static; + ---Purpose: compute the ID of the volume based on the id's of its + -- bounding nodes + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2,idnode3,idnode4: Integer) is private; + + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + NbEdges(me) returns Integer + is redefined static; + ---C++: inline + + NbFaces(me) returns Integer + is redefined static; + ---C++: inline + + NodesOfFace(myclass; rankface,ranknode: Integer) + returns Integer; + ---Purpose: returns the rank node in mynodes. Useful to extract faces from volume + -- + + NodesOfEdge(me; rankedge: Integer; ranknode: Integer) returns Integer; + +fields + + myNodes : Integer [4]; + +end MeshTetrahedron; diff --git a/src/SMDS/SMDS_MeshTetrahedron.cxx b/src/SMDS/SMDS_MeshTetrahedron.cxx new file mode 100644 index 000000000..bfcfcbb8d --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.cxx @@ -0,0 +1,128 @@ +using namespace std; +// File: SMDS_MeshTetrahedron.cxx +// Created: Wed Jan 23 17:02:34 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshTetrahedron.ixx" +#include "Standard_ConstructionError.hxx" + +//======================================================================= +//function : SMDS_MeshTetrahedron +//purpose : Tetrahedra +//======================================================================= + +SMDS_MeshTetrahedron::SMDS_MeshTetrahedron(const Standard_Integer ID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4):SMDS_MeshVolume(ID,4) +{ + SetConnections(idnode1,idnode2,idnode3,idnode4); + ComputeKey(); +} + + +//======================================================================= +//function : SetConnections +//purpose : Tetrahedra +//======================================================================= +void SMDS_MeshTetrahedron::SetConnections(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Standard_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + idmin = (idmin < idnode4 ? idmin : idnode4); + + myNodes[0] = idmin; + if (idmin == idnode1) { + myNodes[1] = idnode2; + myNodes[2] = idnode3; + myNodes[3] = idnode4; + } else if (idmin == idnode2) { + myNodes[1] = idnode3; + myNodes[2] = idnode4; + myNodes[3] = idnode1; + } else if (idmin == idnode3) { + myNodes[1] = idnode4; + myNodes[2] = idnode1; + myNodes[3] = idnode2; + } else { + myNodes[1] = idnode1; + myNodes[2] = idnode2; + myNodes[3] = idnode3; + } + +} + + +//======================================================================= +//function : NodesOfFace +//purpose : returns the rank node in mynodes. Useful to extract faces from volume +//======================================================================= +Standard_Integer SMDS_MeshTetrahedron::NodesOfFace(const Standard_Integer rankface, + const Standard_Integer ranknode) +{ + static Standard_Integer facenode[4][3] = { + {0,1,2}, + {0,3,1}, + {1,3,2}, + {0,2,3} + }; + + return facenode[rankface-1][ranknode-1]; +} + + +//======================================================================= +//function : NodesOfEdge +//purpose : returns the rank node in mynodes. Useful to extract edges from volume +//======================================================================= +Standard_Integer SMDS_MeshTetrahedron::NodesOfEdge(const Standard_Integer rankedge, + const Standard_Integer ranknode) const +{ + static Standard_Integer faceedge[6][2] = { + {0,1}, + {1,2}, + {0,2}, + {0,3}, + {1,3}, + {2,3} + }; + + return faceedge[rankedge-1][ranknode-1]; +} + + +//======================================================================= +//function : GetFaceDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshTetrahedron::GetFaceDefinedByNodes(const Standard_Integer rank, + const Standard_Address idnode, + Standard_Integer& nb) const +{ + Standard_Integer *ptr; + nb = 3; + ptr = (Standard_Integer *)idnode; + ptr[0] = myNodes[NodesOfFace(rank,1)]; + ptr[1] = myNodes[NodesOfFace(rank,2)]; + ptr[2] = myNodes[NodesOfFace(rank,3)]; + +} + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +void SMDS_MeshTetrahedron::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[NodesOfEdge(rank,1)]; + idnode2 = myNodes[NodesOfEdge(rank,2)]; +} + diff --git a/src/SMDS/SMDS_MeshTetrahedron.hxx b/src/SMDS/SMDS_MeshTetrahedron.hxx new file mode 100644 index 000000000..e45f80a55 --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.hxx @@ -0,0 +1,114 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshTetrahedron_HeaderFile +#define _SMDS_MeshTetrahedron_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshTetrahedron_HeaderFile +#include "Handle_SMDS_MeshTetrahedron.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshVolume_HeaderFile +#include "SMDS_MeshVolume.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif +class Standard_ConstructionError; + + +class SMDS_MeshTetrahedron : public SMDS_MeshVolume { + +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_MeshTetrahedron(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4); +Standard_EXPORT void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const; +Standard_EXPORT void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT inline Standard_Integer NbEdges() const; +Standard_EXPORT inline Standard_Integer NbFaces() const; +Standard_EXPORT static Standard_Integer NodesOfFace(const Standard_Integer rankface,const Standard_Integer ranknode) ; +Standard_EXPORT Standard_Integer NodesOfEdge(const Standard_Integer rankedge,const Standard_Integer ranknode) const; +Standard_EXPORT ~SMDS_MeshTetrahedron(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshTetrahedron_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 + // +Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[4]; + + +}; + + +#include "SMDS_MeshTetrahedron.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshTetrahedron.ixx b/src/SMDS/SMDS_MeshTetrahedron.ixx new file mode 100644 index 000000000..b801dd430 --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshTetrahedron.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshTetrahedron::~SMDS_MeshTetrahedron() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshTetrahedron_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshVolume); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshVolume); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshTetrahedron", + sizeof(SMDS_MeshTetrahedron), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshTetrahedron) Handle(SMDS_MeshTetrahedron)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshTetrahedron) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshTetrahedron))) { + _anOtherObject = Handle(SMDS_MeshTetrahedron)((Handle(SMDS_MeshTetrahedron)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshTetrahedron::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshTetrahedron) ; +} +Standard_Boolean SMDS_MeshTetrahedron::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshTetrahedron) == AType || SMDS_MeshVolume::IsKind(AType)); +} +Handle_SMDS_MeshTetrahedron::~Handle_SMDS_MeshTetrahedron() {} + diff --git a/src/SMDS/SMDS_MeshTetrahedron.jxx b/src/SMDS/SMDS_MeshTetrahedron.jxx new file mode 100644 index 000000000..7430d1b40 --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.jxx @@ -0,0 +1,6 @@ +#ifndef _Standard_ConstructionError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshTetrahedron_HeaderFile +#include "SMDS_MeshTetrahedron.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshTetrahedron.lxx b/src/SMDS/SMDS_MeshTetrahedron.lxx new file mode 100644 index 000000000..37d0fdd46 --- /dev/null +++ b/src/SMDS/SMDS_MeshTetrahedron.lxx @@ -0,0 +1,62 @@ +// File: SMDS_MeshTetrahedron.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshTetrahedron::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshTetrahedron::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the volume based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshTetrahedron::ComputeKey() +{ + // myKey = (myNodes[0]<<3) + (myNodes[1]<<2) + (myNodes[2]<<1) + myNodes[3]; + myKey = myNodes[0] + myNodes[1] + myNodes[2] + myNodes[3]; +} + + +//======================================================================= +//function : NbEdges +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshTetrahedron::NbEdges() const +{ + return 6; +} + +//======================================================================= +//function : NbFaces +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_MeshTetrahedron::NbFaces() const +{ + return 4; +} + diff --git a/src/SMDS/SMDS_MeshTriangle.cdl b/src/SMDS/SMDS_MeshTriangle.cdl new file mode 100644 index 000000000..a1a7dde82 --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.cdl @@ -0,0 +1,44 @@ +-- File: SMDS_MeshTriangle.cdl +-- Created: Wed Jan 23 16:16:09 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshTriangle from SMDS inherits MeshFace from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +is + + Create (ID, idnode1,idnode2,idnode3: Integer) returns mutable MeshTriangle; + ---Purpose: constructor for a triangle + + ComputeKey(me: mutable) is redefined static; + ---Purpose: compute the ID of the face based on the id's of its + -- bounding nodes + ---C++: inline + + GetEdgeDefinedByNodes(me; rank: Integer; idnode1, idnode2 : out Integer) + is redefined static; + ---Purpose: returns the idnodes of the ith edge (rank) of the face + -- rank must be comprised between 1 and myNbConnections included. + ---C++: inline + + GetConnections(me) returns Address is redefined static; + ---C++: inline + + GetConnection(me; rank: Integer) returns Integer is redefined static; + ---C++: inline + + SetConnections(me: mutable; idnode1,idnode2,idnode3: Integer) is private; + + +fields + + myNodes : Integer [3]; + +end MeshTriangle; diff --git a/src/SMDS/SMDS_MeshTriangle.cxx b/src/SMDS/SMDS_MeshTriangle.cxx new file mode 100644 index 000000000..408fb0167 --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.cxx @@ -0,0 +1,50 @@ +using namespace std; +// File: SMDS_MeshTriangle.cxx +// Created: Wed Jan 23 17:02:27 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshTriangle.ixx" + + +//======================================================================= +//function : SMDS_MeshTriangle +//purpose : +//======================================================================= + +SMDS_MeshTriangle::SMDS_MeshTriangle(const Standard_Integer ID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3):SMDS_MeshFace(ID,3) +{ + SetConnections(idnode1,idnode2,idnode3); + ComputeKey(); +} + + +//======================================================================= +//function : SetConnections +//purpose : +//======================================================================= +void SMDS_MeshTriangle::SetConnections(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + Standard_Integer idmin = (idnode1 < idnode2 ? idnode1 : idnode2); + idmin = (idmin < idnode3 ? idmin : idnode3); + + myNodes[0] = idmin; + if (idmin == idnode1) { + myNodes[1] = idnode2; + myNodes[2] = idnode3; + } else if (idmin == idnode2) { + myNodes[1] = idnode3; + myNodes[2] = idnode1; + } else { + myNodes[1] = idnode1; + myNodes[2] = idnode2; + } + +} + diff --git a/src/SMDS/SMDS_MeshTriangle.hxx b/src/SMDS/SMDS_MeshTriangle.hxx new file mode 100644 index 000000000..88a021a3c --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.hxx @@ -0,0 +1,108 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_MeshTriangle_HeaderFile +#define _SMDS_MeshTriangle_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshTriangle_HeaderFile +#include "Handle_SMDS_MeshTriangle.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshFace_HeaderFile +#include "SMDS_MeshFace.hxx" +#endif +#ifndef _Standard_Address_HeaderFile +#include +#endif + + +class SMDS_MeshTriangle : public SMDS_MeshFace { + +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_MeshTriangle(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3); +Standard_EXPORT inline void ComputeKey() ; +Standard_EXPORT inline void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; +Standard_EXPORT inline Standard_Address GetConnections() const; +Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; +Standard_EXPORT ~SMDS_MeshTriangle(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshTriangle_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 + // +Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; + + + // Fields PRIVATE + // +Standard_Integer myNodes[3]; + + +}; + + +#include "SMDS_MeshTriangle.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshTriangle.ixx b/src/SMDS/SMDS_MeshTriangle.ixx new file mode 100644 index 000000000..028c45d33 --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.ixx @@ -0,0 +1,75 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshTriangle.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshTriangle::~SMDS_MeshTriangle() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshTriangle_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshFace); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshFace); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType3 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType4 = STANDARD_TYPE(MMgt_TShared); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType5 = STANDARD_TYPE(Standard_Transient); + if ( aType5.IsNull()) aType5 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,aType5,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshTriangle", + sizeof(SMDS_MeshTriangle), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshTriangle) Handle(SMDS_MeshTriangle)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshTriangle) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshTriangle))) { + _anOtherObject = Handle(SMDS_MeshTriangle)((Handle(SMDS_MeshTriangle)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshTriangle::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshTriangle) ; +} +Standard_Boolean SMDS_MeshTriangle::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshTriangle) == AType || SMDS_MeshFace::IsKind(AType)); +} +Handle_SMDS_MeshTriangle::~Handle_SMDS_MeshTriangle() {} + diff --git a/src/SMDS/SMDS_MeshTriangle.jxx b/src/SMDS/SMDS_MeshTriangle.jxx new file mode 100644 index 000000000..1aef5df6a --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.jxx @@ -0,0 +1,3 @@ +#ifndef _SMDS_MeshTriangle_HeaderFile +#include "SMDS_MeshTriangle.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshTriangle.lxx b/src/SMDS/SMDS_MeshTriangle.lxx new file mode 100644 index 000000000..89c0e10ea --- /dev/null +++ b/src/SMDS/SMDS_MeshTriangle.lxx @@ -0,0 +1,56 @@ +// File: SMDS_MeshTriangle.lxx +// Created: Thu Jan 24 17:06:47 2002 +// Author: Jean-Michel BOULCOURT +// + + + + +//======================================================================= +//function : GetConnections +//purpose : +// +//======================================================================= + +inline Standard_Address SMDS_MeshTriangle::GetConnections() const +{ + return (Standard_Address)&myNodes; +} + +//======================================================================= +//function : GetConnection +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshTriangle::GetConnection(const Standard_Integer rank) const +{ + return myNodes[rank-1]; +} + +//======================================================================= +//function : ComputeKey +//purpose : compute the Key of the face based on the ids of its bounding nodes +// +//======================================================================= + +inline void SMDS_MeshTriangle::ComputeKey() +{ + // myKey = (myNodes[0] << 2) + (myNodes[1] << 1) + (myNodes[2]); + myKey = myNodes[0] + myNodes[1] + myNodes[2]; +} + + +//======================================================================= +//function : GetEdgeDefinedByNodes +//purpose : +//======================================================================= +inline void SMDS_MeshTriangle::GetEdgeDefinedByNodes(const Standard_Integer rank, + Standard_Integer& idnode1, + Standard_Integer& idnode2) const +{ + idnode1 = myNodes[rank-1]; + idnode2 = myNodes[rank % myNbNodes]; +} + + diff --git a/src/SMDS/SMDS_MeshVolume.cdl b/src/SMDS/SMDS_MeshVolume.cdl new file mode 100755 index 000000000..dba7e8130 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolume.cdl @@ -0,0 +1,35 @@ +-- File: SMDS_MeshVolume.cdl +-- Created: Wed Jan 23 16:17:22 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class MeshVolume from SMDS inherits MeshElement from SMDS + + ---Purpose: + +uses + MeshElement from SMDS + +raises + ConstructionError from Standard + +is + + Initialize(ID: Integer; NbConnections : Integer) returns mutable MeshVolume; + + + ComputeKey(me: mutable) is deferred; + ---Purpose: compute the ID of the volume based on the id's of its + -- bounding nodes + + GetKey(me) returns Integer is redefined static; + ---C++: inline + + Print(me; OS: in out OStream) is redefined virtual; + +fields + myKey : Integer is protected; + +end MeshVolume; diff --git a/src/SMDS/SMDS_MeshVolume.cxx b/src/SMDS/SMDS_MeshVolume.cxx new file mode 100644 index 000000000..f965172bf --- /dev/null +++ b/src/SMDS/SMDS_MeshVolume.cxx @@ -0,0 +1,34 @@ +using namespace std; +// File: SMDS_MeshVolume.cxx +// Created: Wed Jan 23 17:02:34 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshVolume.ixx" +#include + +//======================================================================= +//function : SMDS_MeshVolume +//purpose : +//======================================================================= + +SMDS_MeshVolume::SMDS_MeshVolume(const Standard_Integer ID, const Standard_Integer nb) +:SMDS_MeshElement(ID,nb,SMDSAbs_Volume) +{ +} + +//======================================================================= +//function : Print +//purpose : +//======================================================================= + +void SMDS_MeshVolume::Print(Standard_OStream& OS) const +{ + OS << "volume <" << myID <<"> : " ; + for (Standard_Integer i=1; i +#endif +#ifndef _Handle_SMDS_MeshVolume_HeaderFile +#include "Handle_SMDS_MeshVolume.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _Standard_OStream_HeaderFile +#include +#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 + // + + +}; + + +#include "SMDS_MeshVolume.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshVolume.ixx b/src/SMDS/SMDS_MeshVolume.ixx new file mode 100644 index 000000000..c29910917 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolume.ixx @@ -0,0 +1,73 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshVolume.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_MeshVolume::~SMDS_MeshVolume() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_MeshVolume_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_MeshElement); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_MeshElement); + static Handle_Standard_Type aType2 = STANDARD_TYPE(SMDS_MeshObject); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(SMDS_MeshObject); + static Handle_Standard_Type aType3 = STANDARD_TYPE(MMgt_TShared); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType4 = STANDARD_TYPE(Standard_Transient); + if ( aType4.IsNull()) aType4 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,aType4,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_MeshVolume", + sizeof(SMDS_MeshVolume), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_MeshVolume) Handle(SMDS_MeshVolume)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_MeshVolume) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_MeshVolume))) { + _anOtherObject = Handle(SMDS_MeshVolume)((Handle(SMDS_MeshVolume)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_MeshVolume::DynamicType() const +{ + return STANDARD_TYPE(SMDS_MeshVolume) ; +} +Standard_Boolean SMDS_MeshVolume::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_MeshVolume) == AType || SMDS_MeshElement::IsKind(AType)); +} +Handle_SMDS_MeshVolume::~Handle_SMDS_MeshVolume() {} + diff --git a/src/SMDS/SMDS_MeshVolume.jxx b/src/SMDS/SMDS_MeshVolume.jxx new file mode 100644 index 000000000..80cff7107 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolume.jxx @@ -0,0 +1,6 @@ +#ifndef _Standard_ConstructionError_HeaderFile +#include +#endif +#ifndef _SMDS_MeshVolume_HeaderFile +#include "SMDS_MeshVolume.hxx" +#endif diff --git a/src/SMDS/SMDS_MeshVolume.lxx b/src/SMDS/SMDS_MeshVolume.lxx new file mode 100644 index 000000000..a8dc5acf4 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolume.lxx @@ -0,0 +1,16 @@ +// File: SMDS_MeshVolume.lxx +// Created: Tue May 7 18:15:11 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : GetKey +//purpose : +// +//======================================================================= + +inline Standard_Integer SMDS_MeshVolume::GetKey() const +{ + return myKey; +} + diff --git a/src/SMDS/SMDS_MeshVolumesIterator.cdl b/src/SMDS/SMDS_MeshVolumesIterator.cdl new file mode 100644 index 000000000..3a3eed139 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolumesIterator.cdl @@ -0,0 +1,34 @@ +-- File: SMDS_MeshVolumesIterator.cdl +-- Created: Thu Jan 24 12:00:41 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class MeshVolumesIterator from SMDS inherits MeshElementsIterator from SMDS + + ---Purpose: The Iterator objet to iterate on all volumes of a mesh + -- + +uses + Mesh from SMDS, + MeshElement from SMDS + +raises + NoMoreObject, + NoSuchObject + +is + + Create returns MeshVolumesIterator from SMDS; + ---Purpose: Creates an empty Iterator. + + Create(M : Mesh from SMDS) returns MeshVolumesIterator from SMDS; + ---Purpose: Creates an Iterator on faces of mesh . + + Initialize(me : in out; M : Mesh from SMDS) + ---Purpose: Reset the Iterator on the faces of mesh . + is redefined static; + + +end MeshVolumesIterator; diff --git a/src/SMDS/SMDS_MeshVolumesIterator.cxx b/src/SMDS/SMDS_MeshVolumesIterator.cxx new file mode 100644 index 000000000..46608dce5 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolumesIterator.cxx @@ -0,0 +1,42 @@ +using namespace std; +// File: SMDS_MeshVolumesIterator.cxx +// Created: Thu Jan 24 12:09:12 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_MeshVolumesIterator.ixx" + +//======================================================================= +//function : SMDS_MeshVolumesIterator +//purpose : +//======================================================================= + +SMDS_MeshVolumesIterator::SMDS_MeshVolumesIterator() +{ +} + +//======================================================================= +//function : SMDS_MeshVolumesIterator +//purpose : +//======================================================================= + +SMDS_MeshVolumesIterator::SMDS_MeshVolumesIterator(const Handle(SMDS_Mesh)& M) +{ + Initialize(M); +} + +//======================================================================= +//function : Initialize +//purpose : +//======================================================================= + +void SMDS_MeshVolumesIterator::Initialize(const Handle(SMDS_Mesh)& M) +{ + + myMapIterator.Initialize(M->myVolumes); + if (More()) { + myCurrentMeshElement = myMapIterator.Key(); + } +} + diff --git a/src/SMDS/SMDS_MeshVolumesIterator.hxx b/src/SMDS/SMDS_MeshVolumesIterator.hxx new file mode 100644 index 000000000..d5a9f098b --- /dev/null +++ b/src/SMDS/SMDS_MeshVolumesIterator.hxx @@ -0,0 +1,96 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_MeshVolumesIterator_HeaderFile +#define _SMDS_MeshVolumesIterator_HeaderFile + +#ifndef _SMDS_MeshElementsIterator_HeaderFile +#include "SMDS_MeshElementsIterator.hxx" +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMDS_Mesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_MeshVolumesIterator : public SMDS_MeshElementsIterator { + +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_MeshVolumesIterator(); +Standard_EXPORT SMDS_MeshVolumesIterator(const Handle(SMDS_Mesh)& M); +Standard_EXPORT void Initialize(const Handle(SMDS_Mesh)& M) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_MeshVolumesIterator.ixx b/src/SMDS/SMDS_MeshVolumesIterator.ixx new file mode 100644 index 000000000..c74a18090 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolumesIterator.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_MeshVolumesIterator.jxx" + + + + diff --git a/src/SMDS/SMDS_MeshVolumesIterator.jxx b/src/SMDS/SMDS_MeshVolumesIterator.jxx new file mode 100644 index 000000000..45c037688 --- /dev/null +++ b/src/SMDS/SMDS_MeshVolumesIterator.jxx @@ -0,0 +1,12 @@ +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshVolumesIterator_HeaderFile +#include "SMDS_MeshVolumesIterator.hxx" +#endif diff --git a/src/SMDS/SMDS_PntHasher.cdl b/src/SMDS/SMDS_PntHasher.cdl new file mode 100644 index 000000000..b48e9829b --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.cdl @@ -0,0 +1,26 @@ +-- File: IntPoly_PntHasher.cdl +-- Created: Wed Jan 23 16:15:04 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class PntHasher from SMDS + +uses Pnt from gp + +is HashCode(myclass; Point : Pnt from gp; + Upper : Integer) + returns Integer; + ---Purpose: Returns a HasCode value for the Key in the + -- range 0..Upper. + ---C++: inline + + IsEqual(myclass; Point1,Point2 : Pnt from gp) + returns Boolean; + ---Purpose: Returns True when the two keys are the same. Two + -- same keys must have the same hashcode, the + -- contrary is not necessary. + ---C++: inline + +end PntHasher; diff --git a/src/SMDS/SMDS_PntHasher.cxx b/src/SMDS/SMDS_PntHasher.cxx new file mode 100644 index 000000000..3b0c8c244 --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.cxx @@ -0,0 +1,8 @@ +using namespace std; +// File: SMDS_PntHasher.cxx +// Created: Wed Jan 23 14:09:30 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_PntHasher.ixx" diff --git a/src/SMDS/SMDS_PntHasher.hxx b/src/SMDS/SMDS_PntHasher.hxx new file mode 100644 index 000000000..fcb4e8dae --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.hxx @@ -0,0 +1,94 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_PntHasher_HeaderFile +#define _SMDS_PntHasher_HeaderFile + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class gp_Pnt; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_PntHasher { + +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 static Standard_Integer HashCode(const gp_Pnt& Point,const Standard_Integer Upper) ; +Standard_EXPORT inline static Standard_Boolean IsEqual(const gp_Pnt& Point1,const gp_Pnt& Point2) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // + + +}; + + +#include "SMDS_PntHasher.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_PntHasher.ixx b/src/SMDS/SMDS_PntHasher.ixx new file mode 100644 index 000000000..3fe15c8a4 --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.ixx @@ -0,0 +1,19 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_PntHasher.jxx" + + + + diff --git a/src/SMDS/SMDS_PntHasher.jxx b/src/SMDS/SMDS_PntHasher.jxx new file mode 100644 index 000000000..4a51bc08b --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_PntHasher_HeaderFile +#include "SMDS_PntHasher.hxx" +#endif diff --git a/src/SMDS/SMDS_PntHasher.lxx b/src/SMDS/SMDS_PntHasher.lxx new file mode 100644 index 000000000..0f7e79cdc --- /dev/null +++ b/src/SMDS/SMDS_PntHasher.lxx @@ -0,0 +1,42 @@ +// File: SMDS_PntHasher.lxx +// Created: Wed Jan 23 14:07:00 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include + +static Standard_Real tab1[3]; +static Standard_Real tab2[3]; + +//======================================================================= +//function : HashCode +//purpose : +//======================================================================= +inline Standard_Integer SMDS_PntHasher::HashCode + (const gp_Pnt& point, const Standard_Integer Upper) +{ + union + { + Standard_Real R[3]; + Standard_Integer I[6]; + } U; + + point.Coord(U.R[0],U.R[1],U.R[2]); + + return ::HashCode(U.I[0]/23+U.I[1]/19+U.I[2]/17+U.I[3]/13+U.I[4]/11+U.I[5]/7,Upper); + // return ::HashCode((U.I[0]>>4)+(U.I[1]>>3)+(U.I[2]>>2)+(U.I[3]>>1)+(U.I[4]>>4)+(U.I[5]>>3),Upper); + +} + +//======================================================================= +//function : IsEqual +//purpose : +//======================================================================= +inline Standard_Boolean SMDS_PntHasher::IsEqual + (const gp_Pnt& point1, const gp_Pnt& point2) +{ + point1.Coord(tab1[0],tab1[1],tab1[2]); + point2.Coord(tab2[0],tab2[1],tab2[2]); + return (memcmp(tab1,tab2,sizeof(tab1)) == 0); +} diff --git a/src/SMDS/SMDS_Position.cdl b/src/SMDS/SMDS_Position.cdl new file mode 100644 index 000000000..0c493e851 --- /dev/null +++ b/src/SMDS/SMDS_Position.cdl @@ -0,0 +1,48 @@ +-- File: SMDS_Position.cdl +-- Created: Mon May 13 13:40:18 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +deferred class Position from SMDS inherits TShared from MMgt + + ---Purpose: abstract class to define the different positions + -- of a node related to the underlying geometry (CAD model) + +uses + Pnt from gp, + TypeOfPosition from SMDS + +is + + Initialize(aShapeId: Integer; + aType: TypeOfPosition from SMDS = SMDS_TOP_UNSPEC) + returns mutable Position; + + Coords(me) returns Pnt from gp is deferred; + ---Purpose: returns the resulting 3d point to be set + -- in the MeshNode instance + -- must be redefined by inherited classes + + GetTypeOfPosition(me) returns TypeOfPosition from SMDS; + ---Purpose: returns the type of position + -- + ---C++: inline + + SetShapeId(me: mutable; aShapeId: Integer); + ---Purpose: Sets the ShapeId of the position + -- + ---C++: inline + + GetShapeId(me) returns Integer; + ---Purpose: Returns the ShapeId of the position + -- + ---C++: inline + + +fields + + myShapeId : Integer; + myType : TypeOfPosition from SMDS; +end Position; diff --git a/src/SMDS/SMDS_Position.cxx b/src/SMDS/SMDS_Position.cxx new file mode 100644 index 000000000..a0de9a60b --- /dev/null +++ b/src/SMDS/SMDS_Position.cxx @@ -0,0 +1,19 @@ +using namespace std; +// File: SMDS_Position.cxx +// Created: Mon May 13 13:50:20 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_Position.ixx" + +//======================================================================= +//function : SMDS_Position +//purpose : +//======================================================================= + +SMDS_Position::SMDS_Position(const Standard_Integer aShapeId, + const SMDS_TypeOfPosition aType) + :myShapeId(aShapeId),myType(aType) +{ +} diff --git a/src/SMDS/SMDS_Position.hxx b/src/SMDS/SMDS_Position.hxx new file mode 100644 index 000000000..54f499730 --- /dev/null +++ b/src/SMDS/SMDS_Position.hxx @@ -0,0 +1,109 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_Position_HeaderFile +#define _SMDS_Position_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Position_HeaderFile +#include "Handle_SMDS_Position.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMDS_TypeOfPosition_HeaderFile +#include "SMDS_TypeOfPosition.hxx" +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +class gp_Pnt; + + +class SMDS_Position : public MMgt_TShared { + +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 gp_Pnt Coords() const = 0; +Standard_EXPORT inline SMDS_TypeOfPosition GetTypeOfPosition() const; +Standard_EXPORT inline void SetShapeId(const Standard_Integer aShapeId) ; +Standard_EXPORT inline Standard_Integer GetShapeId() const; +Standard_EXPORT ~SMDS_Position(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_Position_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_Position(const Standard_Integer aShapeId,const SMDS_TypeOfPosition aType = SMDS_TOP_UNSPEC); + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Integer myShapeId; +SMDS_TypeOfPosition myType; + + +}; + + +#include "SMDS_Position.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_Position.ixx b/src/SMDS/SMDS_Position.ixx new file mode 100644 index 000000000..f9688c8be --- /dev/null +++ b/src/SMDS/SMDS_Position.ixx @@ -0,0 +1,69 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_Position.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_Position::~SMDS_Position() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_Position_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_Position", + sizeof(SMDS_Position), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_Position) Handle(SMDS_Position)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_Position) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_Position))) { + _anOtherObject = Handle(SMDS_Position)((Handle(SMDS_Position)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_Position::DynamicType() const +{ + return STANDARD_TYPE(SMDS_Position) ; +} +Standard_Boolean SMDS_Position::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_Position) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMDS_Position::~Handle_SMDS_Position() {} + diff --git a/src/SMDS/SMDS_Position.jxx b/src/SMDS/SMDS_Position.jxx new file mode 100644 index 000000000..04803a2e1 --- /dev/null +++ b/src/SMDS/SMDS_Position.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif diff --git a/src/SMDS/SMDS_Position.lxx b/src/SMDS/SMDS_Position.lxx new file mode 100644 index 000000000..6498e9524 --- /dev/null +++ b/src/SMDS/SMDS_Position.lxx @@ -0,0 +1,34 @@ +// File: SMDS_Position.lxx +// Created: Mon May 13 13:47:03 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : GetTypeOfPosition +//purpose : +//======================================================================= + +inline SMDS_TypeOfPosition SMDS_Position::GetTypeOfPosition() const +{ + return myType; +} + +//======================================================================= +//function : SetShapeId +//purpose : +//======================================================================= + +inline void SMDS_Position::SetShapeId(const Standard_Integer aShapeId) +{ + myShapeId = aShapeId; +} + +//======================================================================= +//function : GetShapeId +//purpose : +//======================================================================= + +inline Standard_Integer SMDS_Position::GetShapeId() const +{ + return myShapeId; +} diff --git a/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx b/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx new file mode 100644 index 000000000..3f4f58103 --- /dev/null +++ b/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx @@ -0,0 +1,122 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile +#define _SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile +#include "Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _TCollection_SeqNode_HeaderFile +#include +#endif +#ifndef _TCollection_SeqNodePtr_HeaderFile +#include +#endif +class SMDS_Mesh; +class SMDS_SequenceOfMesh; + + +class SMDS_SequenceNodeOfSequenceOfMesh : public TCollection_SeqNode { + +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 SMDS_SequenceNodeOfSequenceOfMesh(const Handle(SMDS_Mesh)& I,const TCollection_SeqNodePtr& n,const TCollection_SeqNodePtr& p); +Standard_EXPORT inline Handle_SMDS_Mesh& Value() const; +Standard_EXPORT ~SMDS_SequenceNodeOfSequenceOfMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_SequenceNodeOfSequenceOfMesh_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 + // +Handle_SMDS_Mesh myValue; + + +}; + +#define SeqItem Handle_SMDS_Mesh +#define SeqItem_hxx "SMDS_Mesh.hxx" +#define TCollection_SequenceNode SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_hxx "SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#define Handle_TCollection_SequenceNode Handle_SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_Type_() SMDS_SequenceNodeOfSequenceOfMesh_Type_() +#define TCollection_Sequence SMDS_SequenceOfMesh +#define TCollection_Sequence_hxx "SMDS_SequenceOfMesh.hxx" + +#include + +#undef SeqItem +#undef SeqItem_hxx +#undef TCollection_SequenceNode +#undef TCollection_SequenceNode_hxx +#undef Handle_TCollection_SequenceNode +#undef TCollection_SequenceNode_Type_ +#undef TCollection_Sequence +#undef TCollection_Sequence_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx b/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx new file mode 100644 index 000000000..fd0c6691d --- /dev/null +++ b/src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx @@ -0,0 +1,87 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_SequenceNodeOfSequenceOfMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_SequenceOfMesh_HeaderFile +#include "SMDS_SequenceOfMesh.hxx" +#endif +SMDS_SequenceNodeOfSequenceOfMesh::~SMDS_SequenceNodeOfSequenceOfMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_SequenceNodeOfSequenceOfMesh_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_SeqNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_SeqNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_SequenceNodeOfSequenceOfMesh", + sizeof(SMDS_SequenceNodeOfSequenceOfMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_SequenceNodeOfSequenceOfMesh) Handle(SMDS_SequenceNodeOfSequenceOfMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_SequenceNodeOfSequenceOfMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh))) { + _anOtherObject = Handle(SMDS_SequenceNodeOfSequenceOfMesh)((Handle(SMDS_SequenceNodeOfSequenceOfMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_SequenceNodeOfSequenceOfMesh::DynamicType() const +{ + return STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh) ; +} +Standard_Boolean SMDS_SequenceNodeOfSequenceOfMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh) == AType || TCollection_SeqNode::IsKind(AType)); +} +Handle_SMDS_SequenceNodeOfSequenceOfMesh::~Handle_SMDS_SequenceNodeOfSequenceOfMesh() {} +#define SeqItem Handle_SMDS_Mesh +#define SeqItem_hxx "SMDS_Mesh.hxx" +#define TCollection_SequenceNode SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_hxx "SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#define Handle_TCollection_SequenceNode Handle_SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_Type_() SMDS_SequenceNodeOfSequenceOfMesh_Type_() +#define TCollection_Sequence SMDS_SequenceOfMesh +#define TCollection_Sequence_hxx "SMDS_SequenceOfMesh.hxx" +#include + diff --git a/src/SMDS/SMDS_SequenceOfMesh.hxx b/src/SMDS/SMDS_SequenceOfMesh.hxx new file mode 100644 index 000000000..ba9910448 --- /dev/null +++ b/src/SMDS/SMDS_SequenceOfMesh.hxx @@ -0,0 +1,157 @@ +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. + +#ifndef _SMDS_SequenceOfMesh_HeaderFile +#define _SMDS_SequenceOfMesh_HeaderFile + +#ifndef _TCollection_BaseSequence_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile +#include "Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class Standard_OutOfRange; +class SMDS_Mesh; +class SMDS_SequenceNodeOfSequenceOfMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMDS_SequenceOfMesh : public TCollection_BaseSequence { + +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 SMDS_SequenceOfMesh(); +Standard_EXPORT void Clear() ; +~SMDS_SequenceOfMesh() +{ + Clear(); +} + +Standard_EXPORT const SMDS_SequenceOfMesh& Assign(const SMDS_SequenceOfMesh& Other) ; + const SMDS_SequenceOfMesh& operator =(const SMDS_SequenceOfMesh& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void Append(const Handle(SMDS_Mesh)& T) ; +Standard_EXPORT inline void Append(SMDS_SequenceOfMesh& S) ; +Standard_EXPORT void Prepend(const Handle(SMDS_Mesh)& T) ; +Standard_EXPORT inline void Prepend(SMDS_SequenceOfMesh& S) ; +Standard_EXPORT inline void InsertBefore(const Standard_Integer Index,const Handle(SMDS_Mesh)& T) ; +Standard_EXPORT inline void InsertBefore(const Standard_Integer Index,SMDS_SequenceOfMesh& S) ; +Standard_EXPORT void InsertAfter(const Standard_Integer Index,const Handle(SMDS_Mesh)& T) ; +Standard_EXPORT inline void InsertAfter(const Standard_Integer Index,SMDS_SequenceOfMesh& S) ; +Standard_EXPORT const Handle_SMDS_Mesh& First() const; +Standard_EXPORT const Handle_SMDS_Mesh& Last() const; +Standard_EXPORT inline void Split(const Standard_Integer Index,SMDS_SequenceOfMesh& Sub) ; +Standard_EXPORT const Handle_SMDS_Mesh& Value(const Standard_Integer Index) const; + const Handle_SMDS_Mesh& operator()(const Standard_Integer Index) const +{ + return Value(Index); +} + +Standard_EXPORT void SetValue(const Standard_Integer Index,const Handle(SMDS_Mesh)& I) ; +Standard_EXPORT Handle_SMDS_Mesh& ChangeValue(const Standard_Integer Index) ; + Handle_SMDS_Mesh& operator()(const Standard_Integer Index) +{ + return ChangeValue(Index); +} + +Standard_EXPORT void Remove(const Standard_Integer Index) ; +Standard_EXPORT void Remove(const Standard_Integer FromIndex,const Standard_Integer ToIndex) ; + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMDS_SequenceOfMesh(const SMDS_SequenceOfMesh& Other); + + + // Fields PRIVATE + // + + +}; + +#define SeqItem Handle_SMDS_Mesh +#define SeqItem_hxx "SMDS_Mesh.hxx" +#define TCollection_SequenceNode SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_hxx "SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#define Handle_TCollection_SequenceNode Handle_SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_Type_() SMDS_SequenceNodeOfSequenceOfMesh_Type_() +#define TCollection_Sequence SMDS_SequenceOfMesh +#define TCollection_Sequence_hxx "SMDS_SequenceOfMesh.hxx" + +#include + +#undef SeqItem +#undef SeqItem_hxx +#undef TCollection_SequenceNode +#undef TCollection_SequenceNode_hxx +#undef Handle_TCollection_SequenceNode +#undef TCollection_SequenceNode_Type_ +#undef TCollection_Sequence +#undef TCollection_Sequence_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_SequenceOfMesh_0.cxx b/src/SMDS/SMDS_SequenceOfMesh_0.cxx new file mode 100644 index 000000000..01cc57301 --- /dev/null +++ b/src/SMDS/SMDS_SequenceOfMesh_0.cxx @@ -0,0 +1,41 @@ +using namespace std; +// File generated by CPPExt (Value) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_SequenceOfMesh.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _Standard_OutOfRange_HeaderFile +#include +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile +#include "SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#endif + + +#define SeqItem Handle_SMDS_Mesh +#define SeqItem_hxx "SMDS_Mesh.hxx" +#define TCollection_SequenceNode SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_hxx "SMDS_SequenceNodeOfSequenceOfMesh.hxx" +#define Handle_TCollection_SequenceNode Handle_SMDS_SequenceNodeOfSequenceOfMesh +#define TCollection_SequenceNode_Type_() SMDS_SequenceNodeOfSequenceOfMesh_Type_() +#define TCollection_Sequence SMDS_SequenceOfMesh +#define TCollection_Sequence_hxx "SMDS_SequenceOfMesh.hxx" +#include + diff --git a/src/SMDS/SMDS_SpacePosition.cdl b/src/SMDS/SMDS_SpacePosition.cdl new file mode 100644 index 000000000..4ffa80f2c --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.cdl @@ -0,0 +1,38 @@ +-- File: SMDS_SpacePosition.cdl +-- Created: Mon May 13 14:06:42 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class SpacePosition from SMDS inherits Position from SMDS + + ---Purpose: used to characterize a MeshNode with a 3D point + -- in space not related to any underlying geometry (CAD) + +uses + Pnt from gp + +is + + Create returns mutable SpacePosition; + ---Purpose: empty constructor. the coords are not set + + Create(x, y, z : Real) returns mutable SpacePosition; + + Create(aCoords : Pnt from gp) returns mutable SpacePosition; + + Coords(me) returns Pnt from gp is redefined virtual; + ---Purpose: returns the resulting 3d point to be set + -- in the MeshNode instance + + SetCoords(me: mutable; x, y, z : Real); + ---C++: inline + + SetCoords(me: mutable; aCoords : Pnt from gp); + ---C++: inline + +fields + myCoords : Pnt from gp; + +end SpacePosition; diff --git a/src/SMDS/SMDS_SpacePosition.cxx b/src/SMDS/SMDS_SpacePosition.cxx new file mode 100644 index 000000000..9ecc496f5 --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.cxx @@ -0,0 +1,50 @@ +using namespace std; +// File: SMDS_SpacePosition.cxx +// Created: Mon May 13 14:19:18 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_SpacePosition.ixx" + +//======================================================================= +//function : SMDS_SpacePosition +//purpose : +//======================================================================= + +SMDS_SpacePosition::SMDS_SpacePosition() + :SMDS_Position(0,SMDS_TOP_3DSPACE),myCoords(0.,0.,0.) +{ +} + +//======================================================================= +//function : SMDS_SpacePosition +//purpose : +//======================================================================= + +SMDS_SpacePosition::SMDS_SpacePosition(const Standard_Real x, + const Standard_Real y, + const Standard_Real z) + :SMDS_Position(0,SMDS_TOP_3DSPACE),myCoords(x,y,z) +{ +} + +//======================================================================= +//function : SMDS_SpacePosition +//purpose : +//======================================================================= + +SMDS_SpacePosition::SMDS_SpacePosition(const gp_Pnt& aCoords) + :SMDS_Position(0,SMDS_TOP_3DSPACE),myCoords(aCoords) +{ +} + +//======================================================================= +//function : Coords +//purpose : +//======================================================================= + +gp_Pnt SMDS_SpacePosition::Coords() const +{ + return myCoords; +} diff --git a/src/SMDS/SMDS_SpacePosition.hxx b/src/SMDS/SMDS_SpacePosition.hxx new file mode 100644 index 000000000..3965d12c8 --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.hxx @@ -0,0 +1,109 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_SpacePosition_HeaderFile +#define _SMDS_SpacePosition_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_SpacePosition_HeaderFile +#include "Handle_SMDS_SpacePosition.hxx" +#endif + +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +class gp_Pnt; + + +class SMDS_SpacePosition : public SMDS_Position { + +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_SpacePosition(); +Standard_EXPORT SMDS_SpacePosition(const Standard_Real x,const Standard_Real y,const Standard_Real z); +Standard_EXPORT SMDS_SpacePosition(const gp_Pnt& aCoords); +Standard_EXPORT virtual gp_Pnt Coords() const; +Standard_EXPORT inline void SetCoords(const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT inline void SetCoords(const gp_Pnt& aCoords) ; +Standard_EXPORT ~SMDS_SpacePosition(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_SpacePosition_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 myCoords; + + +}; + + +#include "SMDS_SpacePosition.lxx" + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_SpacePosition.ixx b/src/SMDS/SMDS_SpacePosition.ixx new file mode 100644 index 000000000..81fd053d6 --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_SpacePosition.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_SpacePosition::~SMDS_SpacePosition() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_SpacePosition_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_SpacePosition", + sizeof(SMDS_SpacePosition), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_SpacePosition) Handle(SMDS_SpacePosition)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_SpacePosition) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_SpacePosition))) { + _anOtherObject = Handle(SMDS_SpacePosition)((Handle(SMDS_SpacePosition)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_SpacePosition::DynamicType() const +{ + return STANDARD_TYPE(SMDS_SpacePosition) ; +} +Standard_Boolean SMDS_SpacePosition::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_SpacePosition) == AType || SMDS_Position::IsKind(AType)); +} +Handle_SMDS_SpacePosition::~Handle_SMDS_SpacePosition() {} + diff --git a/src/SMDS/SMDS_SpacePosition.jxx b/src/SMDS/SMDS_SpacePosition.jxx new file mode 100644 index 000000000..1ccf0c675 --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_SpacePosition_HeaderFile +#include "SMDS_SpacePosition.hxx" +#endif diff --git a/src/SMDS/SMDS_SpacePosition.lxx b/src/SMDS/SMDS_SpacePosition.lxx new file mode 100644 index 000000000..8291ba4ff --- /dev/null +++ b/src/SMDS/SMDS_SpacePosition.lxx @@ -0,0 +1,26 @@ +// File: SMDS_SpacePosition.lxx +// Created: Mon May 13 14:24:22 2002 +// Author: Jean-Michel BOULCOURT +// + +//======================================================================= +//function : SetCoords +//purpose : +//======================================================================= + +inline void SMDS_SpacePosition::SetCoords(const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + myCoords.SetCoord(x,y,z); +} + +//======================================================================= +//function : SetCoords +//purpose : +//======================================================================= + +inline void SMDS_SpacePosition::SetCoords(const gp_Pnt& aCoords) +{ + myCoords = aCoords; +} diff --git a/src/SMDS/SMDS_StdMapNode.gxx b/src/SMDS/SMDS_StdMapNode.gxx new file mode 100644 index 000000000..0cd96506c --- /dev/null +++ b/src/SMDS/SMDS_StdMapNode.gxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_StdMapNode.gxx has disappeared diff --git a/src/SMDS/SMDS_StdMapNode.lxx b/src/SMDS/SMDS_StdMapNode.lxx new file mode 100644 index 000000000..8aa1d0246 --- /dev/null +++ b/src/SMDS/SMDS_StdMapNode.lxx @@ -0,0 +1 @@ +#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_StdMapNode.lxx has disappeared diff --git a/src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx b/src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx new file mode 100644 index 000000000..a8993b489 --- /dev/null +++ b/src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx @@ -0,0 +1,132 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_StdMapNodeOfExtendedMap_HeaderFile +#define _SMDS_StdMapNodeOfExtendedMap_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedMap.hxx" +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_MeshElement; +class SMDS_MeshElementMapHasher; +class SMDS_ExtendedMap; +class SMDS_MapIteratorOfExtendedMap; + + +class SMDS_StdMapNodeOfExtendedMap : public TCollection_MapNode { + +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 SMDS_StdMapNodeOfExtendedMap(const Handle(SMDS_MeshElement)& K,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMDS_MeshElement& Key() const; +Standard_EXPORT ~SMDS_StdMapNodeOfExtendedMap(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_StdMapNodeOfExtendedMap_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 + // +Handle_SMDS_MeshElement myKey; + + +}; + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_() +#define TCollection_Map SMDS_ExtendedMap +#define TCollection_Map_hxx + +#include + +#undef TheKey +#undef TheKey_hxx +#undef Hasher +#undef Hasher_hxx +#undef TCollection_StdMapNode +#undef TCollection_StdMapNode_hxx +#undef TCollection_MapIterator +#undef TCollection_MapIterator_hxx +#undef Handle_TCollection_StdMapNode +#undef TCollection_StdMapNode_Type_ +#undef TCollection_Map +#undef TCollection_Map_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx b/src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx new file mode 100644 index 000000000..dab0485a4 --- /dev/null +++ b/src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx @@ -0,0 +1,97 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_StdMapNodeOfExtendedMap.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshElementMapHasher_HeaderFile +#include "SMDS_MeshElementMapHasher.hxx" +#endif +#ifndef _SMDS_ExtendedMap_HeaderFile +#include "SMDS_ExtendedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedMap.hxx" +#endif +SMDS_StdMapNodeOfExtendedMap::~SMDS_StdMapNodeOfExtendedMap() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_StdMapNodeOfExtendedMap_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_StdMapNodeOfExtendedMap", + sizeof(SMDS_StdMapNodeOfExtendedMap), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_StdMapNodeOfExtendedMap) Handle(SMDS_StdMapNodeOfExtendedMap)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_StdMapNodeOfExtendedMap) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap))) { + _anOtherObject = Handle(SMDS_StdMapNodeOfExtendedMap)((Handle(SMDS_StdMapNodeOfExtendedMap)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_StdMapNodeOfExtendedMap::DynamicType() const +{ + return STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap) ; +} +Standard_Boolean SMDS_StdMapNodeOfExtendedMap::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_StdMapNodeOfExtendedMap::~Handle_SMDS_StdMapNodeOfExtendedMap() {} +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_() +#define TCollection_Map SMDS_ExtendedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx b/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx new file mode 100644 index 000000000..f5965d243 --- /dev/null +++ b/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx @@ -0,0 +1,132 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#define _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile +#include "Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx" +#endif + +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMDS_MeshElement; +class SMDS_MeshOrientedElementMapHasher; +class SMDS_ExtendedOrientedMap; +class SMDS_MapIteratorOfExtendedOrientedMap; + + +class SMDS_StdMapNodeOfExtendedOrientedMap : public TCollection_MapNode { + +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 SMDS_StdMapNodeOfExtendedOrientedMap(const Handle(SMDS_MeshElement)& K,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMDS_MeshElement& Key() const; +Standard_EXPORT ~SMDS_StdMapNodeOfExtendedOrientedMap(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_StdMapNodeOfExtendedOrientedMap_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 + // +Handle_SMDS_MeshElement myKey; + + +}; + +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshOrientedElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +#define TCollection_Map SMDS_ExtendedOrientedMap +#define TCollection_Map_hxx + +#include + +#undef TheKey +#undef TheKey_hxx +#undef Hasher +#undef Hasher_hxx +#undef TCollection_StdMapNode +#undef TCollection_StdMapNode_hxx +#undef TCollection_MapIterator +#undef TCollection_MapIterator_hxx +#undef Handle_TCollection_StdMapNode +#undef TCollection_StdMapNode_Type_ +#undef TCollection_Map +#undef TCollection_Map_hxx + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx b/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx new file mode 100644 index 000000000..aa6ffc198 --- /dev/null +++ b/src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx @@ -0,0 +1,97 @@ +using namespace std; +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_StdMapNodeOfExtendedOrientedMap.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile +#include "SMDS_MeshOrientedElementMapHasher.hxx" +#endif +#ifndef _SMDS_ExtendedOrientedMap_HeaderFile +#include "SMDS_ExtendedOrientedMap.hxx" +#endif +#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile +#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" +#endif +SMDS_StdMapNodeOfExtendedOrientedMap::~SMDS_StdMapNodeOfExtendedOrientedMap() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_StdMapNodeOfExtendedOrientedMap", + sizeof(SMDS_StdMapNodeOfExtendedOrientedMap), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_StdMapNodeOfExtendedOrientedMap) Handle(SMDS_StdMapNodeOfExtendedOrientedMap)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_StdMapNodeOfExtendedOrientedMap) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap))) { + _anOtherObject = Handle(SMDS_StdMapNodeOfExtendedOrientedMap)((Handle(SMDS_StdMapNodeOfExtendedOrientedMap)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_StdMapNodeOfExtendedOrientedMap::DynamicType() const +{ + return STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap) ; +} +Standard_Boolean SMDS_StdMapNodeOfExtendedOrientedMap::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMDS_StdMapNodeOfExtendedOrientedMap::~Handle_SMDS_StdMapNodeOfExtendedOrientedMap() {} +#define TheKey Handle_SMDS_MeshElement +#define TheKey_hxx +#define Hasher SMDS_MeshOrientedElementMapHasher +#define Hasher_hxx +#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_hxx +#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap +#define TCollection_MapIterator_hxx +#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap +#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_() +#define TCollection_Map SMDS_ExtendedOrientedMap +#define TCollection_Map_hxx +#include + diff --git a/src/SMDS/SMDS_TypeOfPosition.hxx b/src/SMDS/SMDS_TypeOfPosition.hxx new file mode 100644 index 000000000..ec2330dbf --- /dev/null +++ b/src/SMDS/SMDS_TypeOfPosition.hxx @@ -0,0 +1,31 @@ +// File generated by CPPExt (Enum) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_TypeOfPosition_HeaderFile +#define _SMDS_TypeOfPosition_HeaderFile + +enum SMDS_TypeOfPosition { + SMDS_TOP_UNSPEC, +SMDS_TOP_3DSPACE, +SMDS_TOP_VERTEX, +SMDS_TOP_EDGE, +SMDS_TOP_FACE +}; + + +#ifndef _Standard_PrimitiveTypes_HeaderFile +#include +#endif + +#endif diff --git a/src/SMDS/SMDS_VertexPosition.cdl b/src/SMDS/SMDS_VertexPosition.cdl new file mode 100644 index 000000000..cace01059 --- /dev/null +++ b/src/SMDS/SMDS_VertexPosition.cdl @@ -0,0 +1,26 @@ +-- File: SMDS_VertexPosition.cdl +-- Created: Mon May 13 14:39:09 2002 +-- Author: Jean-Michel BOULCOURT +-- +---Copyright: Matra Datavision 2002 + + +class VertexPosition from SMDS inherits Position from SMDS + + ---Purpose: used to characterize a MeshNode with a CAD vertex + +uses + Pnt from gp + +is + + Create returns mutable VertexPosition; + ---Purpose: empty constructor. the vertex is not set + + Create(aVertexId : Integer) returns mutable VertexPosition; + + Coords(me) returns Pnt from gp is redefined virtual; + ---Purpose: returns the resulting 3d point to be set + -- in the MeshNode instance + +end VertexPosition; diff --git a/src/SMDS/SMDS_VertexPosition.cxx b/src/SMDS/SMDS_VertexPosition.cxx new file mode 100644 index 000000000..837e1140f --- /dev/null +++ b/src/SMDS/SMDS_VertexPosition.cxx @@ -0,0 +1,41 @@ +using namespace std; +// File: SMDS_VertexPosition.cxx +// Created: Mon May 13 14:41:57 2002 +// Author: Jean-Michel BOULCOURT +// + + +#include "SMDS_VertexPosition.ixx" +#include "utilities.h" + +//======================================================================= +//function : SMDS_VertexPosition +//purpose : +//======================================================================= + +SMDS_VertexPosition::SMDS_VertexPosition() + :SMDS_Position(0,SMDS_TOP_VERTEX) +{ +} + +//======================================================================= +//function : SMDS_VertexPosition +//purpose : +//======================================================================= + +SMDS_VertexPosition::SMDS_VertexPosition(const Standard_Integer aVertexId) + :SMDS_Position(aVertexId,SMDS_TOP_VERTEX) +{ +} + + +//======================================================================= +//function : Coords +//purpose : +//======================================================================= + +gp_Pnt SMDS_VertexPosition::Coords() const +{ + MESSAGE( "SMDS_VertexPosition::Coords not implemented" ); + return gp_Pnt(0,0,0); +} diff --git a/src/SMDS/SMDS_VertexPosition.hxx b/src/SMDS/SMDS_VertexPosition.hxx new file mode 100644 index 000000000..c63910952 --- /dev/null +++ b/src/SMDS/SMDS_VertexPosition.hxx @@ -0,0 +1,101 @@ +// File generated by CPPExt (Transient) +// +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#ifndef _SMDS_VertexPosition_HeaderFile +#define _SMDS_VertexPosition_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_VertexPosition_HeaderFile +#include "Handle_SMDS_VertexPosition.hxx" +#endif + +#ifndef _SMDS_Position_HeaderFile +#include "SMDS_Position.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class gp_Pnt; + + +class SMDS_VertexPosition : public SMDS_Position { + +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_VertexPosition(); +Standard_EXPORT SMDS_VertexPosition(const Standard_Integer aVertexId); +Standard_EXPORT virtual gp_Pnt Coords() const; +Standard_EXPORT ~SMDS_VertexPosition(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMDS_VertexPosition_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 + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMDS/SMDS_VertexPosition.ixx b/src/SMDS/SMDS_VertexPosition.ixx new file mode 100644 index 000000000..2ecf51228 --- /dev/null +++ b/src/SMDS/SMDS_VertexPosition.ixx @@ -0,0 +1,71 @@ +// File generated by CPPExt (Transient) +// Copyright (C) 1991,1995 by +// +// MATRA DATAVISION, FRANCE +// +// This software is furnished in accordance with the terms and conditions +// of the contract and with the inclusion of the above copyright notice. +// This software or any other copy thereof may not be provided or otherwise +// be made available to any other person. No title to an ownership of the +// software is hereby transferred. +// +// At the termination of the contract, the software and all copies of this +// software must be deleted. +// +#include "SMDS_VertexPosition.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMDS_VertexPosition::~SMDS_VertexPosition() {} + + + +Standard_EXPORT Handle_Standard_Type& SMDS_VertexPosition_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position); + static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared); + if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared); + static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient); + if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient); + + + static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL}; + static Handle_Standard_Type _aType = new Standard_Type("SMDS_VertexPosition", + sizeof(SMDS_VertexPosition), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMDS_VertexPosition) Handle(SMDS_VertexPosition)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMDS_VertexPosition) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMDS_VertexPosition))) { + _anOtherObject = Handle(SMDS_VertexPosition)((Handle(SMDS_VertexPosition)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMDS_VertexPosition::DynamicType() const +{ + return STANDARD_TYPE(SMDS_VertexPosition) ; +} +Standard_Boolean SMDS_VertexPosition::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMDS_VertexPosition) == AType || SMDS_Position::IsKind(AType)); +} +Handle_SMDS_VertexPosition::~Handle_SMDS_VertexPosition() {} + diff --git a/src/SMDS/SMDS_VertexPosition.jxx b/src/SMDS/SMDS_VertexPosition.jxx new file mode 100644 index 000000000..d05b7369e --- /dev/null +++ b/src/SMDS/SMDS_VertexPosition.jxx @@ -0,0 +1,6 @@ +#ifndef _gp_Pnt_HeaderFile +#include +#endif +#ifndef _SMDS_VertexPosition_HeaderFile +#include "SMDS_VertexPosition.hxx" +#endif -- 2.30.2