From 3a801f21b0ee28fafae89a51de489a08ac5b48f5 Mon Sep 17 00:00:00 2001 From: nri Date: Mon, 19 May 2003 13:25:06 +0000 Subject: [PATCH] NRI : First integration. --- src/SMESHDS/Handle_SMESHDS_Command.hxx | 89 +++ ...SHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx | 89 +++ ...MapNodeOfDataMapOfIntegerPtrHypothesis.hxx | 89 +++ ...S_DataMapNodeOfDataMapOfIntegerSubMesh.hxx | 89 +++ ...odeOfDataMapOfShapeListOfPtrHypothesis.hxx | 89 +++ ...HDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx | 89 +++ src/SMESHDS/Handle_SMESHDS_Document.hxx | 89 +++ ...le_SMESHDS_ListNodeOfListOfAsciiString.hxx | 89 +++ ...Handle_SMESHDS_ListNodeOfListOfCommand.hxx | 89 +++ ..._SMESHDS_ListNodeOfListOfPtrHypothesis.hxx | 89 +++ src/SMESHDS/Handle_SMESHDS_Mesh.hxx | 89 +++ src/SMESHDS/Handle_SMESHDS_Script.hxx | 89 +++ src/SMESHDS/Handle_SMESHDS_SubMesh.hxx | 89 +++ src/SMESHDS/Makefile.in | 117 ++++ src/SMESHDS/SMESHDS.cdl | 70 ++ src/SMESHDS/SMESHDS_Command.cdl | 62 ++ src/SMESHDS/SMESHDS_Command.cxx | 287 +++++++++ src/SMESHDS/SMESHDS_Command.hxx | 131 ++++ src/SMESHDS/SMESHDS_Command.ixx | 69 ++ src/SMESHDS/SMESHDS_Command.jxx | 9 + src/SMESHDS/SMESHDS_CommandType.hxx | 37 ++ ..._DataMapIteratorOfDataMapOfIntegerMesh.hxx | 106 +++ ...ataMapIteratorOfDataMapOfIntegerMesh_0.cxx | 50 ++ ...teratorOfDataMapOfIntegerPtrHypothesis.hxx | 105 +++ ...ratorOfDataMapOfIntegerPtrHypothesis_0.cxx | 47 ++ ...taMapIteratorOfDataMapOfIntegerSubMesh.hxx | 106 +++ ...MapIteratorOfDataMapOfIntegerSubMesh_0.cxx | 50 ++ ...torOfDataMapOfShapeListOfPtrHypothesis.hxx | 101 +++ ...rOfDataMapOfShapeListOfPtrHypothesis_0.cxx | 53 ++ ...DataMapIteratorOfDataMapOfShapeSubMesh.hxx | 104 +++ ...taMapIteratorOfDataMapOfShapeSubMesh_0.cxx | 53 ++ ...SHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx | 141 ++++ ...DS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx | 99 +++ ...MapNodeOfDataMapOfIntegerPtrHypothesis.hxx | 140 ++++ ...pNodeOfDataMapOfIntegerPtrHypothesis_0.cxx | 96 +++ ...S_DataMapNodeOfDataMapOfIntegerSubMesh.hxx | 141 ++++ ...DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx | 99 +++ ...odeOfDataMapOfShapeListOfPtrHypothesis.hxx | 142 +++++ ...eOfDataMapOfShapeListOfPtrHypothesis_0.cxx | 102 +++ ...HDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx | 142 +++++ ...S_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx | 102 +++ src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx | 135 ++++ .../SMESHDS_DataMapOfIntegerMesh_0.cxx | 53 ++ .../SMESHDS_DataMapOfIntegerPtrHypothesis.hxx | 134 ++++ ...MESHDS_DataMapOfIntegerPtrHypothesis_0.cxx | 50 ++ .../SMESHDS_DataMapOfIntegerSubMesh.hxx | 135 ++++ .../SMESHDS_DataMapOfIntegerSubMesh_0.cxx | 53 ++ ...SHDS_DataMapOfShapeListOfPtrHypothesis.hxx | 133 ++++ ...DS_DataMapOfShapeListOfPtrHypothesis_0.cxx | 56 ++ src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx | 136 ++++ .../SMESHDS_DataMapOfShapeSubMesh_0.cxx | 56 ++ src/SMESHDS/SMESHDS_Document.cdl | 66 ++ src/SMESHDS/SMESHDS_Document.cxx | 173 +++++ src/SMESHDS/SMESHDS_Document.hxx | 141 ++++ src/SMESHDS/SMESHDS_Document.ixx | 69 ++ src/SMESHDS/SMESHDS_Document.jxx | 6 + src/SMESHDS/SMESHDS_Hypothesis.cxx | 80 +++ src/SMESHDS/SMESHDS_Hypothesis.hxx | 47 ++ ...MESHDS_ListIteratorOfListOfAsciiString.hxx | 128 ++++ ...SHDS_ListIteratorOfListOfAsciiString_0.cxx | 43 ++ .../SMESHDS_ListIteratorOfListOfCommand.hxx | 131 ++++ .../SMESHDS_ListIteratorOfListOfCommand_0.cxx | 46 ++ ...SHDS_ListIteratorOfListOfPtrHypothesis.hxx | 130 ++++ ...DS_ListIteratorOfListOfPtrHypothesis_0.cxx | 43 ++ .../SMESHDS_ListNodeOfListOfAsciiString.hxx | 127 ++++ .../SMESHDS_ListNodeOfListOfAsciiString_0.cxx | 89 +++ .../SMESHDS_ListNodeOfListOfCommand.hxx | 127 ++++ .../SMESHDS_ListNodeOfListOfCommand_0.cxx | 92 +++ .../SMESHDS_ListNodeOfListOfPtrHypothesis.hxx | 126 ++++ ...MESHDS_ListNodeOfListOfPtrHypothesis_0.cxx | 89 +++ src/SMESHDS/SMESHDS_ListOfAsciiString.hxx | 152 +++++ src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx | 40 ++ src/SMESHDS/SMESHDS_ListOfCommand.hxx | 155 +++++ src/SMESHDS/SMESHDS_ListOfCommand_0.cxx | 43 ++ src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx | 154 +++++ src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx | 40 ++ src/SMESHDS/SMESHDS_Mesh.cdl | 157 +++++ src/SMESHDS/SMESHDS_Mesh.cxx | 601 ++++++++++++++++++ src/SMESHDS/SMESHDS_Mesh.hxx | 186 ++++++ src/SMESHDS/SMESHDS_Mesh.ixx | 73 +++ src/SMESHDS/SMESHDS_Mesh.jxx | 30 + src/SMESHDS/SMESHDS_PtrHypothesis.hxx | 22 + src/SMESHDS/SMESHDS_Script.cdl | 52 ++ src/SMESHDS/SMESHDS_Script.cxx | 304 +++++++++ src/SMESHDS/SMESHDS_Script.hxx | 118 ++++ src/SMESHDS/SMESHDS_Script.ixx | 69 ++ src/SMESHDS/SMESHDS_Script.jxx | 6 + src/SMESHDS/SMESHDS_SubMesh.cdl | 62 ++ src/SMESHDS/SMESHDS_SubMesh.cxx | 128 ++++ src/SMESHDS/SMESHDS_SubMesh.hxx | 138 ++++ src/SMESHDS/SMESHDS_SubMesh.ixx | 69 ++ src/SMESHDS/SMESHDS_SubMesh.jxx | 18 + 92 files changed, 9229 insertions(+) create mode 100644 src/SMESHDS/Handle_SMESHDS_Command.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_Document.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_Mesh.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_Script.hxx create mode 100644 src/SMESHDS/Handle_SMESHDS_SubMesh.hxx create mode 100644 src/SMESHDS/Makefile.in create mode 100644 src/SMESHDS/SMESHDS.cdl create mode 100644 src/SMESHDS/SMESHDS_Command.cdl create mode 100644 src/SMESHDS/SMESHDS_Command.cxx create mode 100644 src/SMESHDS/SMESHDS_Command.hxx create mode 100644 src/SMESHDS/SMESHDS_Command.ixx create mode 100644 src/SMESHDS/SMESHDS_Command.jxx create mode 100644 src/SMESHDS/SMESHDS_CommandType.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx create mode 100644 src/SMESHDS/SMESHDS_Document.cdl create mode 100644 src/SMESHDS/SMESHDS_Document.cxx create mode 100644 src/SMESHDS/SMESHDS_Document.hxx create mode 100644 src/SMESHDS/SMESHDS_Document.ixx create mode 100644 src/SMESHDS/SMESHDS_Document.jxx create mode 100644 src/SMESHDS/SMESHDS_Hypothesis.cxx create mode 100644 src/SMESHDS/SMESHDS_Hypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListOfAsciiString.hxx create mode 100644 src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListOfCommand.hxx create mode 100644 src/SMESHDS/SMESHDS_ListOfCommand_0.cxx create mode 100644 src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx create mode 100644 src/SMESHDS/SMESHDS_Mesh.cdl create mode 100644 src/SMESHDS/SMESHDS_Mesh.cxx create mode 100644 src/SMESHDS/SMESHDS_Mesh.hxx create mode 100644 src/SMESHDS/SMESHDS_Mesh.ixx create mode 100644 src/SMESHDS/SMESHDS_Mesh.jxx create mode 100644 src/SMESHDS/SMESHDS_PtrHypothesis.hxx create mode 100644 src/SMESHDS/SMESHDS_Script.cdl create mode 100644 src/SMESHDS/SMESHDS_Script.cxx create mode 100644 src/SMESHDS/SMESHDS_Script.hxx create mode 100644 src/SMESHDS/SMESHDS_Script.ixx create mode 100644 src/SMESHDS/SMESHDS_Script.jxx create mode 100644 src/SMESHDS/SMESHDS_SubMesh.cdl create mode 100644 src/SMESHDS/SMESHDS_SubMesh.cxx create mode 100644 src/SMESHDS/SMESHDS_SubMesh.hxx create mode 100644 src/SMESHDS/SMESHDS_SubMesh.ixx create mode 100644 src/SMESHDS/SMESHDS_SubMesh.jxx diff --git a/src/SMESHDS/Handle_SMESHDS_Command.hxx b/src/SMESHDS/Handle_SMESHDS_Command.hxx new file mode 100644 index 000000000..96129808e --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_Command.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_SMESHDS_Command_HeaderFile +#define _Handle_SMESHDS_Command_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 SMESHDS_Command; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_Command); + +class Handle(SMESHDS_Command) : 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(SMESHDS_Command)():Handle(MMgt_TShared)() {} + Handle(SMESHDS_Command)(const Handle(SMESHDS_Command)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMESHDS_Command)(const SMESHDS_Command* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMESHDS_Command)& operator=(const Handle(SMESHDS_Command)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_Command)& operator=(const SMESHDS_Command* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_Command* operator->() + { + return (SMESHDS_Command *)ControlAccess(); + } + + SMESHDS_Command* operator->() const + { + return (SMESHDS_Command *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_Command)(); + + Standard_EXPORT static const Handle(SMESHDS_Command) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx new file mode 100644 index 000000000..4bd66ea8a --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.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_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#define _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_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 SMESHDS_DataMapNodeOfDataMapOfIntegerMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh); + +class Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) : 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(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)(const SMESHDS_DataMapNodeOfDataMapOfIntegerMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)& operator=(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)& operator=(const SMESHDS_DataMapNodeOfDataMapOfIntegerMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerMesh* operator->() + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerMesh *)ControlAccess(); + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerMesh* operator->() const + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)(); + + Standard_EXPORT static const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx new file mode 100644 index 000000000..044b55ea7 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.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_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#define _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_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 SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis); + +class Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) : 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(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)(const SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)& operator=(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)& operator=(const SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis* operator->() + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis *)ControlAccess(); + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis* operator->() const + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)(); + + Standard_EXPORT static const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx new file mode 100644 index 000000000..80bd0dcbe --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.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_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#define _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_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 SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh); + +class Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) : 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(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)(const SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)& operator=(const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)& operator=(const SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh* operator->() + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh *)ControlAccess(); + } + + SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh* operator->() const + { + return (SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)(); + + Standard_EXPORT static const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx new file mode 100644 index 000000000..ce8e276ed --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.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_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#define _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_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 SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis); + +class Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) : 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(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)(const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)(const SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)& operator=(const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)& operator=(const SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis* operator->() + { + return (SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis *)ControlAccess(); + } + + SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis* operator->() const + { + return (SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)(); + + Standard_EXPORT static const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx new file mode 100644 index 000000000..3b056b925 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.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_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#define _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_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 SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh); + +class Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) : 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(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)(const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)(const SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)& operator=(const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)& operator=(const SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh* operator->() + { + return (SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh *)ControlAccess(); + } + + SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh* operator->() const + { + return (SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)(); + + Standard_EXPORT static const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_Document.hxx b/src/SMESHDS/Handle_SMESHDS_Document.hxx new file mode 100644 index 000000000..253c8fe8d --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_Document.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_SMESHDS_Document_HeaderFile +#define _Handle_SMESHDS_Document_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 SMESHDS_Document; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_Document); + +class Handle(SMESHDS_Document) : 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(SMESHDS_Document)():Handle(MMgt_TShared)() {} + Handle(SMESHDS_Document)(const Handle(SMESHDS_Document)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMESHDS_Document)(const SMESHDS_Document* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMESHDS_Document)& operator=(const Handle(SMESHDS_Document)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_Document)& operator=(const SMESHDS_Document* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_Document* operator->() + { + return (SMESHDS_Document *)ControlAccess(); + } + + SMESHDS_Document* operator->() const + { + return (SMESHDS_Document *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_Document)(); + + Standard_EXPORT static const Handle(SMESHDS_Document) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx new file mode 100644 index 000000000..b0a1a78c6 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.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_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#define _Handle_SMESHDS_ListNodeOfListOfAsciiString_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 SMESHDS_ListNodeOfListOfAsciiString; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_ListNodeOfListOfAsciiString); + +class Handle(SMESHDS_ListNodeOfListOfAsciiString) : 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(SMESHDS_ListNodeOfListOfAsciiString)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_ListNodeOfListOfAsciiString)(const Handle(SMESHDS_ListNodeOfListOfAsciiString)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_ListNodeOfListOfAsciiString)(const SMESHDS_ListNodeOfListOfAsciiString* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_ListNodeOfListOfAsciiString)& operator=(const Handle(SMESHDS_ListNodeOfListOfAsciiString)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_ListNodeOfListOfAsciiString)& operator=(const SMESHDS_ListNodeOfListOfAsciiString* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_ListNodeOfListOfAsciiString* operator->() + { + return (SMESHDS_ListNodeOfListOfAsciiString *)ControlAccess(); + } + + SMESHDS_ListNodeOfListOfAsciiString* operator->() const + { + return (SMESHDS_ListNodeOfListOfAsciiString *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_ListNodeOfListOfAsciiString)(); + + Standard_EXPORT static const Handle(SMESHDS_ListNodeOfListOfAsciiString) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx new file mode 100644 index 000000000..35ffd9f74 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.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_SMESHDS_ListNodeOfListOfCommand_HeaderFile +#define _Handle_SMESHDS_ListNodeOfListOfCommand_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 SMESHDS_ListNodeOfListOfCommand; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_ListNodeOfListOfCommand); + +class Handle(SMESHDS_ListNodeOfListOfCommand) : 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(SMESHDS_ListNodeOfListOfCommand)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_ListNodeOfListOfCommand)(const Handle(SMESHDS_ListNodeOfListOfCommand)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_ListNodeOfListOfCommand)(const SMESHDS_ListNodeOfListOfCommand* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_ListNodeOfListOfCommand)& operator=(const Handle(SMESHDS_ListNodeOfListOfCommand)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_ListNodeOfListOfCommand)& operator=(const SMESHDS_ListNodeOfListOfCommand* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_ListNodeOfListOfCommand* operator->() + { + return (SMESHDS_ListNodeOfListOfCommand *)ControlAccess(); + } + + SMESHDS_ListNodeOfListOfCommand* operator->() const + { + return (SMESHDS_ListNodeOfListOfCommand *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_ListNodeOfListOfCommand)(); + + Standard_EXPORT static const Handle(SMESHDS_ListNodeOfListOfCommand) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx new file mode 100644 index 000000000..215a8c5c6 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.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_SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#define _Handle_SMESHDS_ListNodeOfListOfPtrHypothesis_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 SMESHDS_ListNodeOfListOfPtrHypothesis; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_ListNodeOfListOfPtrHypothesis); + +class Handle(SMESHDS_ListNodeOfListOfPtrHypothesis) : 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(SMESHDS_ListNodeOfListOfPtrHypothesis)():Handle(TCollection_MapNode)() {} + Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)(const Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)& aHandle) : Handle(TCollection_MapNode)(aHandle) + { + } + + Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)(const SMESHDS_ListNodeOfListOfPtrHypothesis* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem) + { + } + + Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)& operator=(const Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)& operator=(const SMESHDS_ListNodeOfListOfPtrHypothesis* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_ListNodeOfListOfPtrHypothesis* operator->() + { + return (SMESHDS_ListNodeOfListOfPtrHypothesis *)ControlAccess(); + } + + SMESHDS_ListNodeOfListOfPtrHypothesis* operator->() const + { + return (SMESHDS_ListNodeOfListOfPtrHypothesis *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)(); + + Standard_EXPORT static const Handle(SMESHDS_ListNodeOfListOfPtrHypothesis) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_Mesh.hxx b/src/SMESHDS/Handle_SMESHDS_Mesh.hxx new file mode 100644 index 000000000..af2e5779e --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_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_SMESHDS_Mesh_HeaderFile +#define _Handle_SMESHDS_Mesh_HeaderFile + +#ifndef _Standard_Macro_HeaderFile +#include +#endif +#ifndef _Standard_HeaderFile +#include +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif + +class Standard_Transient; +class Handle_Standard_Type; +class Handle(SMDS_Mesh); +class SMESHDS_Mesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_Mesh); + +class Handle(SMESHDS_Mesh) : public Handle(SMDS_Mesh) { + 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(SMESHDS_Mesh)():Handle(SMDS_Mesh)() {} + Handle(SMESHDS_Mesh)(const Handle(SMESHDS_Mesh)& aHandle) : Handle(SMDS_Mesh)(aHandle) + { + } + + Handle(SMESHDS_Mesh)(const SMESHDS_Mesh* anItem) : Handle(SMDS_Mesh)((SMDS_Mesh *)anItem) + { + } + + Handle(SMESHDS_Mesh)& operator=(const Handle(SMESHDS_Mesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_Mesh)& operator=(const SMESHDS_Mesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_Mesh* operator->() + { + return (SMESHDS_Mesh *)ControlAccess(); + } + + SMESHDS_Mesh* operator->() const + { + return (SMESHDS_Mesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_Mesh)(); + + Standard_EXPORT static const Handle(SMESHDS_Mesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_Script.hxx b/src/SMESHDS/Handle_SMESHDS_Script.hxx new file mode 100644 index 000000000..e7486e138 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_Script.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_SMESHDS_Script_HeaderFile +#define _Handle_SMESHDS_Script_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 SMESHDS_Script; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_Script); + +class Handle(SMESHDS_Script) : 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(SMESHDS_Script)():Handle(MMgt_TShared)() {} + Handle(SMESHDS_Script)(const Handle(SMESHDS_Script)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMESHDS_Script)(const SMESHDS_Script* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMESHDS_Script)& operator=(const Handle(SMESHDS_Script)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_Script)& operator=(const SMESHDS_Script* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_Script* operator->() + { + return (SMESHDS_Script *)ControlAccess(); + } + + SMESHDS_Script* operator->() const + { + return (SMESHDS_Script *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_Script)(); + + Standard_EXPORT static const Handle(SMESHDS_Script) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Handle_SMESHDS_SubMesh.hxx b/src/SMESHDS/Handle_SMESHDS_SubMesh.hxx new file mode 100644 index 000000000..0c1dd4890 --- /dev/null +++ b/src/SMESHDS/Handle_SMESHDS_SubMesh.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_SMESHDS_SubMesh_HeaderFile +#define _Handle_SMESHDS_SubMesh_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 SMESHDS_SubMesh; +Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMESHDS_SubMesh); + +class Handle(SMESHDS_SubMesh) : 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(SMESHDS_SubMesh)():Handle(MMgt_TShared)() {} + Handle(SMESHDS_SubMesh)(const Handle(SMESHDS_SubMesh)& aHandle) : Handle(MMgt_TShared)(aHandle) + { + } + + Handle(SMESHDS_SubMesh)(const SMESHDS_SubMesh* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem) + { + } + + Handle(SMESHDS_SubMesh)& operator=(const Handle(SMESHDS_SubMesh)& aHandle) + { + Assign(aHandle.Access()); + return *this; + } + + Handle(SMESHDS_SubMesh)& operator=(const SMESHDS_SubMesh* anItem) + { + Assign((Standard_Transient *)anItem); + return *this; + } + + SMESHDS_SubMesh* operator->() + { + return (SMESHDS_SubMesh *)ControlAccess(); + } + + SMESHDS_SubMesh* operator->() const + { + return (SMESHDS_SubMesh *)ControlAccess(); + } + + Standard_EXPORT ~Handle(SMESHDS_SubMesh)(); + + Standard_EXPORT static const Handle(SMESHDS_SubMesh) DownCast(const Handle(Standard_Transient)& AnObject); +}; +#endif diff --git a/src/SMESHDS/Makefile.in b/src/SMESHDS/Makefile.in new file mode 100644 index 000000000..386f31ee7 --- /dev/null +++ b/src/SMESHDS/Makefile.in @@ -0,0 +1,117 @@ +# -* 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 = libSMESHDS.la +LIB_SRC = SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx \ + SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx \ + SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx \ + SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx \ + SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx \ + SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx \ + SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx \ + SMESHDS_DataMapOfIntegerMesh_0.cxx \ + SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx \ + SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx \ + SMESHDS_DataMapOfShapeSubMesh_0.cxx \ + SMESHDS_DataMapOfIntegerSubMesh_0.cxx \ + SMESHDS_Document.cxx \ + SMESHDS_Hypothesis.cxx \ + SMESHDS_ListIteratorOfListOfAsciiString_0.cxx \ + SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx \ + SMESHDS_ListIteratorOfListOfCommand_0.cxx \ + SMESHDS_ListNodeOfListOfAsciiString_0.cxx \ + SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx \ + SMESHDS_ListNodeOfListOfCommand_0.cxx \ + SMESHDS_ListOfAsciiString_0.cxx \ + SMESHDS_ListOfPtrHypothesis_0.cxx \ + SMESHDS_ListOfCommand_0.cxx \ + SMESHDS_Mesh.cxx \ + SMESHDS_Script.cxx \ + SMESHDS_Command.cxx \ + SMESHDS_SubMesh.cxx + +LIB_CLIENT_IDL = +LIB_SERVER_IDL = + +# Executables targets +BIN = +BIN_SRC = +BIN_CLIENT_IDL = +BIN_SERVER_IDL = + +# header files +EXPORT_HEADERS= Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx \ + Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx \ + Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx \ + Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx \ + Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx \ + Handle_SMESHDS_Document.hxx \ + Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx \ + Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx \ + Handle_SMESHDS_ListNodeOfListOfCommand.hxx \ + Handle_SMESHDS_Mesh.hxx \ + Handle_SMESHDS_Script.hxx \ + Handle_SMESHDS_Command.hxx \ + Handle_SMESHDS_SubMesh.hxx \ + SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx \ + SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx \ + SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx \ + SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx \ + SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx \ + SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx \ + SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx \ + SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx \ + SMESHDS_DataMapOfIntegerMesh.hxx \ + SMESHDS_DataMapOfIntegerPtrHypothesis.hxx \ + SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx \ + SMESHDS_DataMapOfShapeSubMesh.hxx \ + SMESHDS_DataMapOfIntegerSubMesh.hxx \ + SMESHDS_Document.hxx \ + SMESHDS_Hypothesis.hxx \ + SMESHDS_ListIteratorOfListOfAsciiString.hxx \ + SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx \ + SMESHDS_ListIteratorOfListOfCommand.hxx \ + SMESHDS_ListNodeOfListOfAsciiString.hxx \ + SMESHDS_ListNodeOfListOfPtrHypothesis.hxx \ + SMESHDS_ListNodeOfListOfCommand.hxx \ + SMESHDS_ListOfAsciiString.hxx \ + SMESHDS_ListOfPtrHypothesis.hxx \ + SMESHDS_ListOfCommand.hxx \ + SMESHDS_Mesh.hxx \ + SMESHDS_PtrHypothesis.hxx \ + SMESHDS_Script.hxx \ + SMESHDS_Command.hxx \ + SMESHDS_CommandType.hxx \ + SMESHDS_SubMesh.hxx + +# additionnal information to compil and link file +CPPFLAGS += $(OCC_INCLUDES) +CXXFLAGS += $(OCC_CXXFLAGS) +LDFLAGS += $(OCC_LIBS) + +# additional file to be cleaned +MOSTLYCLEAN = +CLEAN = +DISTCLEAN = + +@CONCLUDE@ + diff --git a/src/SMESHDS/SMESHDS.cdl b/src/SMESHDS/SMESHDS.cdl new file mode 100644 index 000000000..0b6d48aec --- /dev/null +++ b/src/SMESHDS/SMESHDS.cdl @@ -0,0 +1,70 @@ +-- File : SMESHDS.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + + +package SMESHDS + +uses + Standard, + TColStd, + SMDS, + TCollection, + TopoDS, + TopTools + +is + + enumeration + CommandType is AddNode, AddEdge, AddTriangle, AddQuadrangle, AddTetrahedron, AddPyramid, + AddPrism, AddHexahedron, RemoveNode, RemoveElement, MoveNode + end CommandType; + + class Document; + + class Mesh; + + class SubMesh; + + imported Hypothesis; + + pointer PtrHypothesis to Hypothesis from SMESHDS; + + class Script; + + class Command; + + + + class DataMapOfShapeSubMesh instantiates DataMap from TCollection (Shape from TopoDS, + SubMesh from SMESHDS, + ShapeMapHasher from TopTools); + + class DataMapOfIntegerSubMesh instantiates DataMap from TCollection (Integer from Standard, + SubMesh from SMESHDS, + MapIntegerHasher from TColStd); + + + class DataMapOfIntegerPtrHypothesis instantiates DataMap from TCollection (Integer from Standard, + PtrHypothesis from SMESHDS, + MapIntegerHasher from TColStd); + + class DataMapOfIntegerMesh instantiates DataMap from TCollection (Integer from Standard, + Mesh from SMESHDS, + MapIntegerHasher from TColStd); + + class ListOfPtrHypothesis instantiates List from TCollection (PtrHypothesis from SMESHDS); + + + class DataMapOfShapeListOfPtrHypothesis instantiates DataMap from TCollection (Shape from TopoDS, + ListOfPtrHypothesis from SMESHDS, + ShapeMapHasher from TopTools); + + class ListOfAsciiString instantiates List from TCollection (AsciiString from TCollection); + + class ListOfCommand instantiates List from TCollection (Command from SMESHDS); + + +end SMESHDS; \ No newline at end of file diff --git a/src/SMESHDS/SMESHDS_Command.cdl b/src/SMESHDS/SMESHDS_Command.cdl new file mode 100644 index 000000000..1291a5e48 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Command.cdl @@ -0,0 +1,62 @@ +-- File : SMESHDS_Script.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + +class Command from SMESHDS inherits TShared from MMgt + +uses + + Integer from Standard, + Real from Standard, + CommandType from SMESHDS, + ListOfReal from TColStd, + ListOfInteger from TColStd + +is + + Create (aType : CommandType from SMESHDS) returns Command from SMESHDS; + + AddNode(me: mutable; NewNodeID : Integer; x,y,z : Real); + + AddEdge(me: mutable; NewEdgeID : Integer; idnode1, idnode2 : Integer); + + AddFace(me: mutable; NewFaceID : Integer; idnode1, idnode2, idnode3 : Integer); + + AddFace(me: mutable; NewFaceID : Integer; idnode1, idnode2, idnode3, idnode4 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, idnode7, idnode8 : Integer); + + MoveNode(me: mutable; NewNodeID : Integer; x,y,z : Real); + + RemoveNode (me: mutable; NodeID : Integer); + + RemoveElement(me: mutable; ElementID : Integer); + + GetType (me: mutable) returns CommandType from SMESHDS; + + GetNumber (me: mutable) returns Integer from Standard; + + GetIndexes (me: mutable) + ---C++ :return const & + returns ListOfInteger from TColStd; + + GetCoords (me: mutable) + ---C++ :return const & + returns ListOfReal from TColStd; + + + +fields + myType : CommandType from SMESHDS; + myNumber : Integer from Standard; + myReals : ListOfReal from TColStd; + myIntegers : ListOfInteger from TColStd; +end Script; diff --git a/src/SMESHDS/SMESHDS_Command.cxx b/src/SMESHDS/SMESHDS_Command.cxx new file mode 100644 index 000000000..1f59cd502 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Command.cxx @@ -0,0 +1,287 @@ +using namespace std; +//============================================================================= +// File : SMESH_Command.cxx +// Created : +// Author : Yves FRICAUD, OCC +// Project : SALOME +// Copyright : OCC 2002 +// $Header: +//============================================================================= + +#include "SMESHDS_Command.ixx" +#include "SMESHDS_CommandType.hxx" +#include "utilities.h" + +//======================================================================= +//function : +//purpose : +//======================================================================= +SMESHDS_Command::SMESHDS_Command(const SMESHDS_CommandType aType) + : myType(aType), myNumber(0) +{} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddNode(const Standard_Integer NewNodeID, + const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + if (!myType == SMESHDS_AddNode) { + MESSAGE("SMESHDS_Command::AddNode : Bad Type"); + return; + } + myIntegers.Append(NewNodeID); + myReals.Append(x); + myReals.Append(y); + myReals.Append(z); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::MoveNode(const Standard_Integer NodeID, + const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + if (!myType == SMESHDS_MoveNode) { + MESSAGE("SMESHDS_Command::MoveNode : Bad Type"); + return; + } + myIntegers.Append(NodeID); + myReals.Append(x); + myReals.Append(y); + myReals.Append(z); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddEdge(const Standard_Integer NewEdgeID, + const Standard_Integer idnode1, + const Standard_Integer idnode2) +{ + if (!myType == SMESHDS_AddEdge) { + MESSAGE("SMESHDS_Command::AddEdge : Bad Type"); + return; + } + myIntegers.Append(NewEdgeID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddFace(const Standard_Integer NewFaceID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + if (!myType == SMESHDS_AddTriangle) { + MESSAGE("SMESHDS_Command::AddFace : Bad Type"); + return; + } + myIntegers.Append(NewFaceID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddFace(const Standard_Integer NewFaceID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + if (!myType == SMESHDS_AddQuadrangle) { + MESSAGE("SMESHDS_Command::AddFace : Bad Type"); + return; + } + myIntegers.Append(NewFaceID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myIntegers.Append(idnode4); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddVolume(const Standard_Integer NewVolID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + if (!myType == SMESHDS_AddTetrahedron) { + MESSAGE("SMESHDS_Command::AddVolume : Bad Type"); + return; + } + myIntegers.Append(NewVolID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myIntegers.Append(idnode4); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddVolume(const Standard_Integer NewVolID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5) +{ + if (!myType == SMESHDS_AddPyramid) { + MESSAGE("SMESHDS_Command::AddVolume : Bad Type"); + return; + } + myIntegers.Append(NewVolID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myIntegers.Append(idnode4); + myIntegers.Append(idnode5); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddVolume(const Standard_Integer NewVolID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5, + const Standard_Integer idnode6) +{ + if (!myType == SMESHDS_AddPrism) { + MESSAGE("SMESHDS_Command::AddVolume : Bad Type"); + return; + } + myIntegers.Append(NewVolID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myIntegers.Append(idnode4); + myIntegers.Append(idnode5); + myIntegers.Append(idnode6); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::AddVolume(const Standard_Integer NewVolID, + 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) +{ + if (!myType == SMESHDS_AddHexahedron) { + MESSAGE("SMESHDS_Command::AddVolume : Bad Type"); + return; + } + myIntegers.Append(NewVolID); + myIntegers.Append(idnode1); + myIntegers.Append(idnode2); + myIntegers.Append(idnode3); + myIntegers.Append(idnode4); + myIntegers.Append(idnode5); + myIntegers.Append(idnode6); + myIntegers.Append(idnode7); + myIntegers.Append(idnode8); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::RemoveNode(const Standard_Integer NodeID) +{ + if (!myType == SMESHDS_RemoveNode) { + MESSAGE("SMESHDS_Command::RemoveNode : Bad Type"); + return; + } + myIntegers.Append(NodeID); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Command::RemoveElement(const Standard_Integer ElementID) +{ + if (!myType == SMESHDS_RemoveElement) { + MESSAGE("SMESHDS_Command::RemoveElement : Bad Type"); + return; + } + myIntegers.Append(ElementID); + myNumber++; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +SMESHDS_CommandType SMESHDS_Command::GetType() +{ + return myType; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Command::GetNumber() +{ + return myNumber; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +const TColStd_ListOfInteger& SMESHDS_Command::GetIndexes() +{ + return myIntegers; +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +const TColStd_ListOfReal& SMESHDS_Command::GetCoords() +{ + return myReals; +} diff --git a/src/SMESHDS/SMESHDS_Command.hxx b/src/SMESHDS/SMESHDS_Command.hxx new file mode 100644 index 000000000..edfe89a2b --- /dev/null +++ b/src/SMESHDS/SMESHDS_Command.hxx @@ -0,0 +1,131 @@ +// 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 _SMESHDS_Command_HeaderFile +#define _SMESHDS_Command_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Command_HeaderFile +#include "Handle_SMESHDS_Command.hxx" +#endif + +#ifndef _SMESHDS_CommandType_HeaderFile +#include "SMESHDS_CommandType.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _TColStd_ListOfReal_HeaderFile +#include +#endif +#ifndef _TColStd_ListOfInteger_HeaderFile +#include +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +class TColStd_ListOfInteger; +class TColStd_ListOfReal; + + +class SMESHDS_Command : 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 SMESHDS_Command(const SMESHDS_CommandType aType); +Standard_EXPORT void AddNode(const Standard_Integer NewNodeID,const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT void AddEdge(const Standard_Integer NewEdgeID,const Standard_Integer idnode1,const Standard_Integer idnode2) ; +Standard_EXPORT void AddFace(const Standard_Integer NewFaceID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; +Standard_EXPORT void AddFace(const Standard_Integer NewFaceID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,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 AddVolume(const Standard_Integer NewVolID,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 MoveNode(const Standard_Integer NewNodeID,const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT void RemoveNode(const Standard_Integer NodeID) ; +Standard_EXPORT void RemoveElement(const Standard_Integer ElementID) ; +Standard_EXPORT SMESHDS_CommandType GetType() ; +Standard_EXPORT Standard_Integer GetNumber() ; +Standard_EXPORT const TColStd_ListOfInteger& GetIndexes() ; +Standard_EXPORT const TColStd_ListOfReal& GetCoords() ; +Standard_EXPORT ~SMESHDS_Command(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_Command_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 + // +SMESHDS_CommandType myType; +Standard_Integer myNumber; +TColStd_ListOfReal myReals; +TColStd_ListOfInteger myIntegers; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_Command.ixx b/src/SMESHDS/SMESHDS_Command.ixx new file mode 100644 index 000000000..b3a2f6558 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Command.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 "SMESHDS_Command.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMESHDS_Command::~SMESHDS_Command() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_Command_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("SMESHDS_Command", + sizeof(SMESHDS_Command), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_Command) Handle(SMESHDS_Command)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_Command) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_Command))) { + _anOtherObject = Handle(SMESHDS_Command)((Handle(SMESHDS_Command)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_Command::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_Command) ; +} +Standard_Boolean SMESHDS_Command::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_Command) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMESHDS_Command::~Handle_SMESHDS_Command() {} + diff --git a/src/SMESHDS/SMESHDS_Command.jxx b/src/SMESHDS/SMESHDS_Command.jxx new file mode 100644 index 000000000..0c3f436e3 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Command.jxx @@ -0,0 +1,9 @@ +#ifndef _TColStd_ListOfInteger_HeaderFile +#include +#endif +#ifndef _TColStd_ListOfReal_HeaderFile +#include +#endif +#ifndef _SMESHDS_Command_HeaderFile +#include "SMESHDS_Command.hxx" +#endif diff --git a/src/SMESHDS/SMESHDS_CommandType.hxx b/src/SMESHDS/SMESHDS_CommandType.hxx new file mode 100644 index 000000000..2cd0c2e70 --- /dev/null +++ b/src/SMESHDS/SMESHDS_CommandType.hxx @@ -0,0 +1,37 @@ +// 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 _SMESHDS_CommandType_HeaderFile +#define _SMESHDS_CommandType_HeaderFile + +enum SMESHDS_CommandType { + SMESHDS_AddNode, +SMESHDS_AddEdge, +SMESHDS_AddTriangle, +SMESHDS_AddQuadrangle, +SMESHDS_AddTetrahedron, +SMESHDS_AddPyramid, +SMESHDS_AddPrism, +SMESHDS_AddHexahedron, +SMESHDS_RemoveNode, +SMESHDS_RemoveElement, +SMESHDS_MoveNode +}; + + +#ifndef _Standard_PrimitiveTypes_HeaderFile +#include +#endif + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx new file mode 100644 index 000000000..4f55b0e99 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.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 _SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_HeaderFile +#define _SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Mesh_HeaderFile +#include "Handle_SMESHDS_Mesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" +#endif +class Standard_NoSuchObject; +class SMESHDS_Mesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerMesh; +class SMESHDS_DataMapNodeOfDataMapOfIntegerMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh : 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 SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh(); +Standard_EXPORT SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh(const SMESHDS_DataMapOfIntegerMesh& aMap); +Standard_EXPORT void Initialize(const SMESHDS_DataMapOfIntegerMesh& aMap) ; +Standard_EXPORT const Standard_Integer& Key() const; +Standard_EXPORT const Handle_SMESHDS_Mesh& 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/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx new file mode 100644 index 000000000..ae6f33089 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_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 "SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_Mesh_HeaderFile +#include "SMESHDS_Mesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_Mesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx new file mode 100644 index 000000000..381bffad8 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx @@ -0,0 +1,105 @@ +// 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 _SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" +#endif +class Standard_NoSuchObject; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerPtrHypothesis; +class SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis : 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 SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis(); +Standard_EXPORT SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis(const SMESHDS_DataMapOfIntegerPtrHypothesis& aMap); +Standard_EXPORT void Initialize(const SMESHDS_DataMapOfIntegerPtrHypothesis& aMap) ; +Standard_EXPORT const Standard_Integer& Key() const; +Standard_EXPORT const SMESHDS_PtrHypothesis& 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/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx new file mode 100644 index 000000000..9075c9e0c --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx @@ -0,0 +1,47 @@ +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 "SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem SMESHDS_PtrHypothesis +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx new file mode 100644 index 000000000..9aad9ddf1 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.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 _SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_HeaderFile +#define _SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" +#endif +class Standard_NoSuchObject; +class SMESHDS_SubMesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerSubMesh; +class SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh : 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 SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh(); +Standard_EXPORT SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh(const SMESHDS_DataMapOfIntegerSubMesh& aMap); +Standard_EXPORT void Initialize(const SMESHDS_DataMapOfIntegerSubMesh& aMap) ; +Standard_EXPORT const Standard_Integer& Key() const; +Standard_EXPORT const Handle_SMESHDS_SubMesh& 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/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx new file mode 100644 index 000000000..d1b37e769 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_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 "SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include "TColStd_MapIntegerHasher.hxx" +#endif +#ifndef _SMESHDS_DataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx new file mode 100644 index 000000000..1f4168f5c --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx @@ -0,0 +1,101 @@ +// 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 _SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif +class Standard_NoSuchObject; +class TopoDS_Shape; +class SMESHDS_ListOfPtrHypothesis; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapOfShapeListOfPtrHypothesis; +class SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis : 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 SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis(); +Standard_EXPORT SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis(const SMESHDS_DataMapOfShapeListOfPtrHypothesis& aMap); +Standard_EXPORT void Initialize(const SMESHDS_DataMapOfShapeListOfPtrHypothesis& aMap) ; +Standard_EXPORT const TopoDS_Shape& Key() const; +Standard_EXPORT const SMESHDS_ListOfPtrHypothesis& 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/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..84c6da0f4 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_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 "SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif + + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem SMESHDS_ListOfPtrHypothesis +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx new file mode 100644 index 000000000..97f76a5ee --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.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 _SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_HeaderFile +#define _SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_HeaderFile + +#ifndef _TCollection_BasicMapIterator_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" +#endif +class Standard_NoSuchObject; +class TopoDS_Shape; +class SMESHDS_SubMesh; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapOfShapeSubMesh; +class SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh : 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 SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh(); +Standard_EXPORT SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh(const SMESHDS_DataMapOfShapeSubMesh& aMap); +Standard_EXPORT void Initialize(const SMESHDS_DataMapOfShapeSubMesh& aMap) ; +Standard_EXPORT const TopoDS_Shape& Key() const; +Standard_EXPORT const Handle_SMESHDS_SubMesh& 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/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx new file mode 100644 index 000000000..7bc734d56 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_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 "SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapOfShapeSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" +#endif + + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx new file mode 100644 index 000000000..7dfbaf970 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.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 _SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#define _SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Mesh_HeaderFile +#include "Handle_SMESHDS_Mesh.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMESHDS_Mesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerMesh; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh; + + +class SMESHDS_DataMapNodeOfDataMapOfIntegerMesh : 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 SMESHDS_DataMapNodeOfDataMapOfIntegerMesh(const Standard_Integer& K,const Handle(SMESHDS_Mesh)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Standard_Integer& Key() const; +Standard_EXPORT inline Handle_SMESHDS_Mesh& Value() const; +Standard_EXPORT ~SMESHDS_DataMapNodeOfDataMapOfIntegerMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_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_SMESHDS_Mesh myValue; + + +}; + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_Mesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh +#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/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx new file mode 100644 index 000000000..adf13258f --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_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 "SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_Mesh_HeaderFile +#include "SMESHDS_Mesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx" +#endif +SMESHDS_DataMapNodeOfDataMapOfIntegerMesh::~SMESHDS_DataMapNodeOfDataMapOfIntegerMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_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("SMESHDS_DataMapNodeOfDataMapOfIntegerMesh", + sizeof(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh))) { + _anOtherObject = Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)((Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_DataMapNodeOfDataMapOfIntegerMesh::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) ; +} +Standard_Boolean SMESHDS_DataMapNodeOfDataMapOfIntegerMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerMesh) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh::~Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh() {} +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_Mesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx new file mode 100644 index 000000000..b767527ab --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx @@ -0,0 +1,140 @@ +// 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 _SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerPtrHypothesis; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis; + + +class SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis : 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 SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis(const Standard_Integer& K,const SMESHDS_PtrHypothesis& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Standard_Integer& Key() const; +Standard_EXPORT inline SMESHDS_PtrHypothesis& Value() const; +Standard_EXPORT ~SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_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; +SMESHDS_PtrHypothesis myValue; + + +}; + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem SMESHDS_PtrHypothesis +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis +#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/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx new file mode 100644 index 000000000..5d89d1b8e --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx @@ -0,0 +1,96 @@ +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 "SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx" +#endif +SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis::~SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_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("SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis", + sizeof(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis))) { + _anOtherObject = Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)((Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) ; +} +Standard_Boolean SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis::~Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis() {} +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem SMESHDS_PtrHypothesis +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx new file mode 100644 index 000000000..ad80d4535 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.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 _SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#define _SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMESHDS_SubMesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapOfIntegerSubMesh; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh; + + +class SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh : 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 SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh(const Standard_Integer& K,const Handle(SMESHDS_SubMesh)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Standard_Integer& Key() const; +Standard_EXPORT inline Handle_SMESHDS_SubMesh& Value() const; +Standard_EXPORT ~SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_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_SMESHDS_SubMesh myValue; + + +}; + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh +#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/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx new file mode 100644 index 000000000..eb70cce88 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_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 "SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx" +#endif +SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh::~SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_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("SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh", + sizeof(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh))) { + _anOtherObject = Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)((Handle(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) ; +} +Standard_Boolean SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh::~Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh() {} +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx new file mode 100644 index 000000000..3830a5669 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.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 _SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif + +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class TopoDS_Shape; +class SMESHDS_ListOfPtrHypothesis; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapOfShapeListOfPtrHypothesis; +class SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis; + + +class SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis : 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 SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis(const TopoDS_Shape& K,const SMESHDS_ListOfPtrHypothesis& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline TopoDS_Shape& Key() const; +Standard_EXPORT inline SMESHDS_ListOfPtrHypothesis& Value() const; +Standard_EXPORT ~SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_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 + // +TopoDS_Shape myKey; +SMESHDS_ListOfPtrHypothesis myValue; + + +}; + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem SMESHDS_ListOfPtrHypothesis +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis +#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/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..1d1e94509 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx @@ -0,0 +1,102 @@ +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 "SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif +SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis::~SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_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("SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis", + sizeof(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis))) { + _anOtherObject = Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)((Handle(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) ; +} +Standard_Boolean SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis::~Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis() {} +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem SMESHDS_ListOfPtrHypothesis +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx new file mode 100644 index 000000000..037d8212b --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.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 _SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#define _SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" +#endif + +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMESHDS_SubMesh; +class TopoDS_Shape; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapOfShapeSubMesh; +class SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh; + + +class SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh : 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 SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh(const TopoDS_Shape& K,const Handle(SMESHDS_SubMesh)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline TopoDS_Shape& Key() const; +Standard_EXPORT inline Handle_SMESHDS_SubMesh& Value() const; +Standard_EXPORT ~SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_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 + // +TopoDS_Shape myKey; +Handle_SMESHDS_SubMesh myValue; + + +}; + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh +#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/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx new file mode 100644 index 000000000..2fd79b987 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx @@ -0,0 +1,102 @@ +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 "SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapOfShapeSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx" +#endif +SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh::~SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_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("SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh", + sizeof(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh))) { + _anOtherObject = Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)((Handle(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) ; +} +Standard_Boolean SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh::~Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh() {} +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx new file mode 100644 index 000000000..a2be5aa8f --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.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 _SMESHDS_DataMapOfIntegerMesh_HeaderFile +#define _SMESHDS_DataMapOfIntegerMesh_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Mesh_HeaderFile +#include "Handle_SMESHDS_Mesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class SMESHDS_Mesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapNodeOfDataMapOfIntegerMesh; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapOfIntegerMesh : 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 SMESHDS_DataMapOfIntegerMesh(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMESHDS_DataMapOfIntegerMesh& Assign(const SMESHDS_DataMapOfIntegerMesh& Other) ; + SMESHDS_DataMapOfIntegerMesh& operator =(const SMESHDS_DataMapOfIntegerMesh& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMESHDS_DataMapOfIntegerMesh() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const Standard_Integer& K,const Handle(SMESHDS_Mesh)& I) ; +Standard_EXPORT Standard_Boolean IsBound(const Standard_Integer& K) const; +Standard_EXPORT Standard_Boolean UnBind(const Standard_Integer& K) ; +Standard_EXPORT const Handle_SMESHDS_Mesh& Find(const Standard_Integer& K) const; + const Handle_SMESHDS_Mesh& operator()(const Standard_Integer& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMESHDS_Mesh& ChangeFind(const Standard_Integer& K) ; + Handle_SMESHDS_Mesh& operator()(const Standard_Integer& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_DataMapOfIntegerMesh(const SMESHDS_DataMapOfIntegerMesh& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx new file mode 100644 index 000000000..f32f16850 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_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 "SMESHDS_DataMapOfIntegerMesh.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_Mesh_HeaderFile +#include "SMESHDS_Mesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_Mesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx new file mode 100644 index 000000000..35cfbe72b --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx @@ -0,0 +1,134 @@ +// 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 _SMESHDS_DataMapOfIntegerPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapOfIntegerPtrHypothesis_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapOfIntegerPtrHypothesis : 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 SMESHDS_DataMapOfIntegerPtrHypothesis(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMESHDS_DataMapOfIntegerPtrHypothesis& Assign(const SMESHDS_DataMapOfIntegerPtrHypothesis& Other) ; + SMESHDS_DataMapOfIntegerPtrHypothesis& operator =(const SMESHDS_DataMapOfIntegerPtrHypothesis& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMESHDS_DataMapOfIntegerPtrHypothesis() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const Standard_Integer& K,const SMESHDS_PtrHypothesis& I) ; +Standard_EXPORT Standard_Boolean IsBound(const Standard_Integer& K) const; +Standard_EXPORT Standard_Boolean UnBind(const Standard_Integer& K) ; +Standard_EXPORT const SMESHDS_PtrHypothesis& Find(const Standard_Integer& K) const; + const SMESHDS_PtrHypothesis& operator()(const Standard_Integer& K) const +{ + return Find(K); +} + +Standard_EXPORT SMESHDS_PtrHypothesis& ChangeFind(const Standard_Integer& K) ; + SMESHDS_PtrHypothesis& operator()(const Standard_Integer& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_DataMapOfIntegerPtrHypothesis(const SMESHDS_DataMapOfIntegerPtrHypothesis& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx new file mode 100644 index 000000000..3d0619e64 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_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 "SMESHDS_DataMapOfIntegerPtrHypothesis.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem SMESHDS_PtrHypothesis +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx new file mode 100644 index 000000000..b9d0c5763 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.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 _SMESHDS_DataMapOfIntegerSubMesh_HeaderFile +#define _SMESHDS_DataMapOfIntegerSubMesh_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class SMESHDS_SubMesh; +class TColStd_MapIntegerHasher; +class SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh; +class SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapOfIntegerSubMesh : 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 SMESHDS_DataMapOfIntegerSubMesh(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMESHDS_DataMapOfIntegerSubMesh& Assign(const SMESHDS_DataMapOfIntegerSubMesh& Other) ; + SMESHDS_DataMapOfIntegerSubMesh& operator =(const SMESHDS_DataMapOfIntegerSubMesh& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMESHDS_DataMapOfIntegerSubMesh() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const Standard_Integer& K,const Handle(SMESHDS_SubMesh)& I) ; +Standard_EXPORT Standard_Boolean IsBound(const Standard_Integer& K) const; +Standard_EXPORT Standard_Boolean UnBind(const Standard_Integer& K) ; +Standard_EXPORT const Handle_SMESHDS_SubMesh& Find(const Standard_Integer& K) const; + const Handle_SMESHDS_SubMesh& operator()(const Standard_Integer& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMESHDS_SubMesh& ChangeFind(const Standard_Integer& K) ; + Handle_SMESHDS_SubMesh& operator()(const Standard_Integer& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_DataMapOfIntegerSubMesh(const SMESHDS_DataMapOfIntegerSubMesh& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx new file mode 100644 index 000000000..c6ea23569 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_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 "SMESHDS_DataMapOfIntegerSubMesh.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TColStd_MapIntegerHasher_HeaderFile +#include "TColStd_MapIntegerHasher.hxx" +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx" +#endif + + +#define TheKey Standard_Integer +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TColStd_MapIntegerHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx new file mode 100644 index 000000000..ea840f863 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx @@ -0,0 +1,133 @@ +// 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 _SMESHDS_DataMapOfShapeListOfPtrHypothesis_HeaderFile +#define _SMESHDS_DataMapOfShapeListOfPtrHypothesis_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class TopoDS_Shape; +class SMESHDS_ListOfPtrHypothesis; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis; +class SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapOfShapeListOfPtrHypothesis : 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 SMESHDS_DataMapOfShapeListOfPtrHypothesis(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMESHDS_DataMapOfShapeListOfPtrHypothesis& Assign(const SMESHDS_DataMapOfShapeListOfPtrHypothesis& Other) ; + SMESHDS_DataMapOfShapeListOfPtrHypothesis& operator =(const SMESHDS_DataMapOfShapeListOfPtrHypothesis& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMESHDS_DataMapOfShapeListOfPtrHypothesis() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const TopoDS_Shape& K,const SMESHDS_ListOfPtrHypothesis& I) ; +Standard_EXPORT Standard_Boolean IsBound(const TopoDS_Shape& K) const; +Standard_EXPORT Standard_Boolean UnBind(const TopoDS_Shape& K) ; +Standard_EXPORT const SMESHDS_ListOfPtrHypothesis& Find(const TopoDS_Shape& K) const; + const SMESHDS_ListOfPtrHypothesis& operator()(const TopoDS_Shape& K) const +{ + return Find(K); +} + +Standard_EXPORT SMESHDS_ListOfPtrHypothesis& ChangeFind(const TopoDS_Shape& K) ; + SMESHDS_ListOfPtrHypothesis& operator()(const TopoDS_Shape& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_DataMapOfShapeListOfPtrHypothesis(const SMESHDS_DataMapOfShapeListOfPtrHypothesis& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..b14000b33 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx @@ -0,0 +1,56 @@ +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 "SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx" +#endif + + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem SMESHDS_ListOfPtrHypothesis +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx b/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx new file mode 100644 index 000000000..4de040e1e --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx @@ -0,0 +1,136 @@ +// 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 _SMESHDS_DataMapOfShapeSubMesh_HeaderFile +#define _SMESHDS_DataMapOfShapeSubMesh_HeaderFile + +#ifndef _TCollection_BasicMap_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_DomainError; +class Standard_NoSuchObject; +class TopoDS_Shape; +class SMESHDS_SubMesh; +class TopTools_ShapeMapHasher; +class SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh; +class SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_DataMapOfShapeSubMesh : 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 SMESHDS_DataMapOfShapeSubMesh(const Standard_Integer NbBuckets = 1); +Standard_EXPORT SMESHDS_DataMapOfShapeSubMesh& Assign(const SMESHDS_DataMapOfShapeSubMesh& Other) ; + SMESHDS_DataMapOfShapeSubMesh& operator =(const SMESHDS_DataMapOfShapeSubMesh& Other) +{ + return Assign(Other); +} + +Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ; +Standard_EXPORT void Clear() ; +~SMESHDS_DataMapOfShapeSubMesh() +{ + Clear(); +} + +Standard_EXPORT Standard_Boolean Bind(const TopoDS_Shape& K,const Handle(SMESHDS_SubMesh)& I) ; +Standard_EXPORT Standard_Boolean IsBound(const TopoDS_Shape& K) const; +Standard_EXPORT Standard_Boolean UnBind(const TopoDS_Shape& K) ; +Standard_EXPORT const Handle_SMESHDS_SubMesh& Find(const TopoDS_Shape& K) const; + const Handle_SMESHDS_SubMesh& operator()(const TopoDS_Shape& K) const +{ + return Find(K); +} + +Standard_EXPORT Handle_SMESHDS_SubMesh& ChangeFind(const TopoDS_Shape& K) ; + Handle_SMESHDS_SubMesh& operator()(const TopoDS_Shape& K) +{ + return ChangeFind(K); +} + + + + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_DataMapOfShapeSubMesh(const SMESHDS_DataMapOfShapeSubMesh& Other); + + + // Fields PRIVATE + // + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx b/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx new file mode 100644 index 000000000..cbde82037 --- /dev/null +++ b/src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx @@ -0,0 +1,56 @@ +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 "SMESHDS_DataMapOfShapeSubMesh.hxx" + +#ifndef _Standard_DomainError_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _TopTools_ShapeMapHasher_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx" +#endif + + +#define TheKey TopoDS_Shape +#define TheKey_hxx +#define TheItem Handle_SMESHDS_SubMesh +#define TheItem_hxx +#define Hasher TopTools_ShapeMapHasher +#define Hasher_hxx +#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_hxx +#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh +#define TCollection_DataMapIterator_hxx +#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh +#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_() +#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh +#define TCollection_DataMap_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_Document.cdl b/src/SMESHDS/SMESHDS_Document.cdl new file mode 100644 index 000000000..d40ff4de0 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Document.cdl @@ -0,0 +1,66 @@ +-- File : SMESHDS_Document.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + +class Document from SMESHDS inherits TShared from MMgt + +uses + Integer from Standard, + Mesh from SMESHDS, + PtrHypothesis from SMESHDS, + DataMapOfIntegerMesh from SMESHDS, + DataMapOfIntegerPtrHypothesis from SMESHDS, + DataMapIteratorOfDataMapOfIntegerMesh from SMESHDS, + DataMapIteratorOfDataMapOfIntegerPtrHypothesis from SMESHDS +is + + Create (UserID : Integer from Standard) returns mutable Document; + + NewMesh (me : mutable) returns Integer from Standard; + + RemoveMesh (me : mutable; MeshID : Integer from Standard); + + GetMesh (me : mutable; MeshID : Integer from Standard) returns Mesh from SMESHDS; + + + AddHypothesis (me : mutable; H : PtrHypothesis from SMESHDS); + + RemoveHypothesis (me : mutable; HypID : Integer from Standard); + + GetHypothesis (me : mutable; HypID : Integer from Standard) returns PtrHypothesis from SMESHDS; + + NbMeshes (me : mutable) returns Integer from Standard; + + NbHypothesis (me : mutable) returns Integer from Standard; + + -- Iterator on Meshes + InitMeshesIterator(me : mutable); + + NextMesh (me : mutable); + + MoreMesh (me : mutable) returns Boolean from Standard; + + CurrentMesh (me : mutable ) returns Mesh from SMESHDS; + + + --Iterator on Hypothesis + InitHypothesisIterator (me : mutable ); + + NextHypothesis (me : mutable ); + + MoreHypothesis (me : mutable ) returns Boolean from Standard; + + CurrentHypothesis (me : mutable) returns PtrHypothesis from SMESHDS; + +fields + myUserID : Integer from Standard; + myMeshes : DataMapOfIntegerMesh from SMESHDS; + myHypothesis : DataMapOfIntegerPtrHypothesis from SMESHDS; + + myMeshesIt : DataMapIteratorOfDataMapOfIntegerMesh from SMESHDS; + myHypothesisIt : DataMapIteratorOfDataMapOfIntegerPtrHypothesis from SMESHDS; + +end Document; + diff --git a/src/SMESHDS/SMESHDS_Document.cxx b/src/SMESHDS/SMESHDS_Document.cxx new file mode 100644 index 000000000..4b47835e4 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Document.cxx @@ -0,0 +1,173 @@ +using namespace std; +//============================================================================= +// File : SMESHDS_Document.cxx +// Created : +// Author : Yves FRICAUD, OCC +// Project : SALOME +// Copyright : OCC 2002 +// $Header: +//============================================================================= + +#include "SMESHDS_Document.ixx" +#include "SMESHDS_Hypothesis.hxx" + +#include + +//======================================================================= +//function : Create +//purpose : +//======================================================================= +SMESHDS_Document::SMESHDS_Document(const Standard_Integer UserID): myUserID(UserID) +{} + +//======================================================================= +//function : NewMesh +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Document::NewMesh() +{ + static Standard_Integer NewMeshID = 0; + NewMeshID++; + Handle (SMESHDS_Mesh) aNewMesh = new SMESHDS_Mesh (NewMeshID); + myMeshes.Bind(NewMeshID ,aNewMesh); + return NewMeshID; +} + +//======================================================================= +//function : GetMesh +//purpose : +//======================================================================= +Handle(SMESHDS_Mesh) SMESHDS_Document::GetMesh(const Standard_Integer MeshID) +{ + if (!myMeshes.IsBound(MeshID)) + Standard_OutOfRange::Raise("SMESHDS_Document::RemoveMesh"); + return myMeshes.Find(MeshID); +} + +//======================================================================= +//function : RemoveMesh +//purpose : +//======================================================================= +void SMESHDS_Document::RemoveMesh(const Standard_Integer MeshID) +{ + if (!myMeshes.IsBound(MeshID)) + Standard_OutOfRange::Raise("SMESHDS_Document::RemoveMesh"); + myMeshes.UnBind(MeshID); +} + +//======================================================================= +//function : AddHypothesis +//purpose : +//======================================================================= +void SMESHDS_Document::AddHypothesis(const SMESHDS_PtrHypothesis& H) +{ + myHypothesis.Bind (H->GetID(), H); +} + +//======================================================================= +//function : GetHypothesis +//purpose : +//======================================================================= +SMESHDS_PtrHypothesis SMESHDS_Document::GetHypothesis(const Standard_Integer HypID) +{ + if (!myHypothesis.IsBound(HypID)) + Standard_OutOfRange::Raise("SMESHDS_Document::GetHypothesis"); + return myHypothesis.Find(HypID); +} + +//======================================================================= +//function : RemoveHypothesis +//purpose : +//======================================================================= +void SMESHDS_Document::RemoveHypothesis(const Standard_Integer HypID) +{ + if (!myHypothesis.IsBound(HypID)) + Standard_OutOfRange::Raise("SMESHDS_Document::RemoveHypothesis"); + myMeshes.UnBind(HypID); +} + +//======================================================================= +//function : NbMeshes +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Document::NbMeshes() +{ + return myMeshes.Extent(); +} + +//======================================================================= +//function : NbHypothesis +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Document::NbHypothesis() +{ + return myHypothesis.Extent(); +} + +//======================================================================= +//function : InitMeshesIterator +//purpose : +//======================================================================= +void SMESHDS_Document::InitMeshesIterator() +{ + myMeshesIt.Initialize(myMeshes); +} +//======================================================================= +//function : NextMesh +//purpose : +//======================================================================= +void SMESHDS_Document::NextMesh() +{ + myMeshesIt.Next(); +} +//======================================================================= +//function : MoreMesh +//purpose : +//======================================================================= +Standard_Boolean SMESHDS_Document::MoreMesh() +{ + return myMeshesIt.More(); +} +//======================================================================= +//function : CurrentMesh +//purpose : +//======================================================================= +Handle_SMESHDS_Mesh SMESHDS_Document::CurrentMesh() +{ + return myMeshesIt.Value(); +} + +//======================================================================= +//function : InitHypothesisIterator +//purpose : +//======================================================================= +void SMESHDS_Document::InitHypothesisIterator() +{ + myHypothesisIt.Initialize(myHypothesis); +} +//======================================================================= +//function : NextMesh +//purpose : +//======================================================================= +void SMESHDS_Document::NextHypothesis() +{ + myHypothesisIt.Next(); +} +//======================================================================= +//function : MoreMesh +//purpose : +//======================================================================= +Standard_Boolean SMESHDS_Document::MoreHypothesis() +{ + return myHypothesisIt.More(); +} +//======================================================================= +//function : CurrentMesh +//purpose : +//======================================================================= +SMESHDS_PtrHypothesis SMESHDS_Document::CurrentHypothesis() +{ + return myHypothesisIt.Value(); +} + + diff --git a/src/SMESHDS/SMESHDS_Document.hxx b/src/SMESHDS/SMESHDS_Document.hxx new file mode 100644 index 000000000..3b1e79d01 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Document.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 _SMESHDS_Document_HeaderFile +#define _SMESHDS_Document_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Document_HeaderFile +#include "Handle_SMESHDS_Document.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx" +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Mesh_HeaderFile +#include "Handle_SMESHDS_Mesh.hxx" +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class SMESHDS_Mesh; + + +class SMESHDS_Document : 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 SMESHDS_Document(const Standard_Integer UserID); +Standard_EXPORT Standard_Integer NewMesh() ; +Standard_EXPORT void RemoveMesh(const Standard_Integer MeshID) ; +Standard_EXPORT Handle_SMESHDS_Mesh GetMesh(const Standard_Integer MeshID) ; +Standard_EXPORT void AddHypothesis(const SMESHDS_PtrHypothesis& H) ; +Standard_EXPORT void RemoveHypothesis(const Standard_Integer HypID) ; +Standard_EXPORT SMESHDS_PtrHypothesis GetHypothesis(const Standard_Integer HypID) ; +Standard_EXPORT Standard_Integer NbMeshes() ; +Standard_EXPORT Standard_Integer NbHypothesis() ; +Standard_EXPORT void InitMeshesIterator() ; +Standard_EXPORT void NextMesh() ; +Standard_EXPORT Standard_Boolean MoreMesh() ; +Standard_EXPORT Handle_SMESHDS_Mesh CurrentMesh() ; +Standard_EXPORT void InitHypothesisIterator() ; +Standard_EXPORT void NextHypothesis() ; +Standard_EXPORT Standard_Boolean MoreHypothesis() ; +Standard_EXPORT SMESHDS_PtrHypothesis CurrentHypothesis() ; +Standard_EXPORT ~SMESHDS_Document(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_Document_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 myUserID; +SMESHDS_DataMapOfIntegerMesh myMeshes; +SMESHDS_DataMapOfIntegerPtrHypothesis myHypothesis; +SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh myMeshesIt; +SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis myHypothesisIt; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_Document.ixx b/src/SMESHDS/SMESHDS_Document.ixx new file mode 100644 index 000000000..6f3088618 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Document.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 "SMESHDS_Document.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMESHDS_Document::~SMESHDS_Document() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_Document_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("SMESHDS_Document", + sizeof(SMESHDS_Document), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_Document) Handle(SMESHDS_Document)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_Document) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_Document))) { + _anOtherObject = Handle(SMESHDS_Document)((Handle(SMESHDS_Document)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_Document::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_Document) ; +} +Standard_Boolean SMESHDS_Document::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_Document) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMESHDS_Document::~Handle_SMESHDS_Document() {} + diff --git a/src/SMESHDS/SMESHDS_Document.jxx b/src/SMESHDS/SMESHDS_Document.jxx new file mode 100644 index 000000000..b95b653ef --- /dev/null +++ b/src/SMESHDS/SMESHDS_Document.jxx @@ -0,0 +1,6 @@ +#ifndef _SMESHDS_Mesh_HeaderFile +#include "SMESHDS_Mesh.hxx" +#endif +#ifndef _SMESHDS_Document_HeaderFile +#include "SMESHDS_Document.hxx" +#endif diff --git a/src/SMESHDS/SMESHDS_Hypothesis.cxx b/src/SMESHDS/SMESHDS_Hypothesis.cxx new file mode 100644 index 000000000..ac186cb10 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Hypothesis.cxx @@ -0,0 +1,80 @@ +using namespace std; +//============================================================================= +// File : SMESHDS_Hypothesis.cxx +// Created : sam mai 18 08:08:50 CEST 2002 +// Author : Paul RASCLE, EDF +// Project : SALOME +// Copyright : EDF 2002 +// $Header$ +//============================================================================= +using namespace std; + +#include "SMESHDS_Hypothesis.hxx" + + +//============================================================================= +/*! + * + */ +//============================================================================= + +SMESHDS_Hypothesis::SMESHDS_Hypothesis(int hypId) +{ +// MESSAGE("SMESHDS_Hypothesis::SMESHDS_Hypothesis"); + _hypId = hypId; + _name = "generic"; +// SCRUTE(_name); +// SCRUTE(_hypId); +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +SMESHDS_Hypothesis::~SMESHDS_Hypothesis() +{ +// MESSAGE("SMESHDS_Hypothesis::~SMESHDS_Hypothesis"); +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +const char* SMESHDS_Hypothesis::GetName() +{ +// MESSAGE("SMESHDS_Hypothesis::GetName"); +// SCRUTE(_name); +// SCRUTE(&_name); + return _name.c_str(); +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +int SMESHDS_Hypothesis::GetID() +{ +// MESSAGE("SMESHDS_Hypothesis::GetId"); +// SCRUTE(_hypId); + return _hypId; +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +int SMESHDS_Hypothesis::GetType() +{ +// MESSAGE("SMESHDS_Hypothesis::GetType"); +// SCRUTE(_type); + return _type; +} + diff --git a/src/SMESHDS/SMESHDS_Hypothesis.hxx b/src/SMESHDS/SMESHDS_Hypothesis.hxx new file mode 100644 index 000000000..878eb5468 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Hypothesis.hxx @@ -0,0 +1,47 @@ +//============================================================================= +// File : SMESHDS_Hypothesis.hxx +// Created : sam mai 18 08:07:54 CEST 2002 +// Author : Paul RASCLE, EDF +// Project : SALOME +// Copyright : EDF 2002 +// $Header$ +//============================================================================= + +#ifndef _SMESHDS_HYPOTHESIS_HXX_ +#define _SMESHDS_HYPOTHESIS_HXX_ + +#if (__GNUC__>2) +#include +#include +#include +#else +#include +#include +#include +#endif + +// class istream; +// class ostream; + +class SMESHDS_Hypothesis +{ +public: + SMESHDS_Hypothesis(int hypId); + virtual ~SMESHDS_Hypothesis(); + + const char* GetName(); + int GetID(); + int GetType(); + + virtual ostream & SaveTo(ostream & save)=0; + virtual istream & LoadFrom(istream & load)=0; + +enum hypothesis_type {PARAM_ALGO, ALGO, ALGO_1D, ALGO_2D, ALGO_3D}; + +protected: + string _name; + int _hypId; + int _type; +}; + +#endif diff --git a/src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx new file mode 100644 index 000000000..a55f538f3 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx @@ -0,0 +1,128 @@ +// 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 _SMESHDS_ListIteratorOfListOfAsciiString_HeaderFile +#define _SMESHDS_ListIteratorOfListOfAsciiString_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMESHDS_ListOfAsciiString; +class TCollection_AsciiString; +class SMESHDS_ListNodeOfListOfAsciiString; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListIteratorOfListOfAsciiString { + +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 SMESHDS_ListIteratorOfListOfAsciiString(); +Standard_EXPORT SMESHDS_ListIteratorOfListOfAsciiString(const SMESHDS_ListOfAsciiString& L); +Standard_EXPORT void Initialize(const SMESHDS_ListOfAsciiString& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT TCollection_AsciiString& Value() const; + + +friend class SMESHDS_ListOfAsciiString; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#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/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx new file mode 100644 index 000000000..bcdb4ce3c --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_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 "SMESHDS_ListIteratorOfListOfAsciiString.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfAsciiString_HeaderFile +#include "SMESHDS_ListOfAsciiString.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#include "SMESHDS_ListNodeOfListOfAsciiString.hxx" +#endif + + +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx new file mode 100644 index 000000000..4653e4abf --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.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 _SMESHDS_ListIteratorOfListOfCommand_HeaderFile +#define _SMESHDS_ListIteratorOfListOfCommand_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Command_HeaderFile +#include "Handle_SMESHDS_Command.hxx" +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfCommand_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfCommand.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMESHDS_ListOfCommand; +class SMESHDS_Command; +class SMESHDS_ListNodeOfListOfCommand; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListIteratorOfListOfCommand { + +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 SMESHDS_ListIteratorOfListOfCommand(); +Standard_EXPORT SMESHDS_ListIteratorOfListOfCommand(const SMESHDS_ListOfCommand& L); +Standard_EXPORT void Initialize(const SMESHDS_ListOfCommand& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT Handle_SMESHDS_Command& Value() const; + + +friend class SMESHDS_ListOfCommand; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#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/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx new file mode 100644 index 000000000..d8c6e5873 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_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 "SMESHDS_ListIteratorOfListOfCommand.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfCommand_HeaderFile +#include "SMESHDS_ListOfCommand.hxx" +#endif +#ifndef _SMESHDS_Command_HeaderFile +#include "SMESHDS_Command.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfCommand_HeaderFile +#include "SMESHDS_ListNodeOfListOfCommand.hxx" +#endif + + +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx new file mode 100644 index 000000000..78ce7f62e --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx @@ -0,0 +1,130 @@ +// 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 _SMESHDS_ListIteratorOfListOfPtrHypothesis_HeaderFile +#define _SMESHDS_ListIteratorOfListOfPtrHypothesis_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoMoreObject; +class Standard_NoSuchObject; +class SMESHDS_ListOfPtrHypothesis; +class SMESHDS_ListNodeOfListOfPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListIteratorOfListOfPtrHypothesis { + +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 SMESHDS_ListIteratorOfListOfPtrHypothesis(); +Standard_EXPORT SMESHDS_ListIteratorOfListOfPtrHypothesis(const SMESHDS_ListOfPtrHypothesis& L); +Standard_EXPORT void Initialize(const SMESHDS_ListOfPtrHypothesis& L) ; +Standard_EXPORT inline Standard_Boolean More() const; +Standard_EXPORT void Next() ; +Standard_EXPORT SMESHDS_PtrHypothesis& Value() const; + + +friend class SMESHDS_ListOfPtrHypothesis; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // + + + // Fields PRIVATE + // +Standard_Address current; +Standard_Address previous; + + +}; + +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#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/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..4fef95c17 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_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 "SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx" + +#ifndef _Standard_NoMoreObject_HeaderFile +#include +#endif +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" +#endif + + +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx new file mode 100644 index 000000000..c7faa8e8e --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.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 _SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#define _SMESHDS_ListNodeOfListOfAsciiString_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx" +#endif + +#ifndef _TCollection_AsciiString_HeaderFile +#include +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class TCollection_AsciiString; +class SMESHDS_ListOfAsciiString; +class SMESHDS_ListIteratorOfListOfAsciiString; + + +class SMESHDS_ListNodeOfListOfAsciiString : 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 SMESHDS_ListNodeOfListOfAsciiString(const TCollection_AsciiString& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline TCollection_AsciiString& Value() const; +Standard_EXPORT ~SMESHDS_ListNodeOfListOfAsciiString(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_ListNodeOfListOfAsciiString_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 + // +TCollection_AsciiString myValue; + + +}; + +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#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/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx new file mode 100644 index 000000000..be1d06ce7 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx @@ -0,0 +1,89 @@ +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 "SMESHDS_ListNodeOfListOfAsciiString.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_ListOfAsciiString_HeaderFile +#include "SMESHDS_ListOfAsciiString.hxx" +#endif +#ifndef _SMESHDS_ListIteratorOfListOfAsciiString_HeaderFile +#include "SMESHDS_ListIteratorOfListOfAsciiString.hxx" +#endif +SMESHDS_ListNodeOfListOfAsciiString::~SMESHDS_ListNodeOfListOfAsciiString() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_ListNodeOfListOfAsciiString_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("SMESHDS_ListNodeOfListOfAsciiString", + sizeof(SMESHDS_ListNodeOfListOfAsciiString), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_ListNodeOfListOfAsciiString) Handle(SMESHDS_ListNodeOfListOfAsciiString)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_ListNodeOfListOfAsciiString) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_ListNodeOfListOfAsciiString))) { + _anOtherObject = Handle(SMESHDS_ListNodeOfListOfAsciiString)((Handle(SMESHDS_ListNodeOfListOfAsciiString)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_ListNodeOfListOfAsciiString::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_ListNodeOfListOfAsciiString) ; +} +Standard_Boolean SMESHDS_ListNodeOfListOfAsciiString::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_ListNodeOfListOfAsciiString) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_ListNodeOfListOfAsciiString::~Handle_SMESHDS_ListNodeOfListOfAsciiString() {} +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx new file mode 100644 index 000000000..5b8101b40 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.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 _SMESHDS_ListNodeOfListOfCommand_HeaderFile +#define _SMESHDS_ListNodeOfListOfCommand_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfCommand_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfCommand.hxx" +#endif + +#ifndef _Handle_SMESHDS_Command_HeaderFile +#include "Handle_SMESHDS_Command.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMESHDS_Command; +class SMESHDS_ListOfCommand; +class SMESHDS_ListIteratorOfListOfCommand; + + +class SMESHDS_ListNodeOfListOfCommand : 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 SMESHDS_ListNodeOfListOfCommand(const Handle(SMESHDS_Command)& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline Handle_SMESHDS_Command& Value() const; +Standard_EXPORT ~SMESHDS_ListNodeOfListOfCommand(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_ListNodeOfListOfCommand_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_SMESHDS_Command myValue; + + +}; + +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#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/SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx new file mode 100644 index 000000000..087b064cf --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfCommand_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 "SMESHDS_ListNodeOfListOfCommand.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_Command_HeaderFile +#include "SMESHDS_Command.hxx" +#endif +#ifndef _SMESHDS_ListOfCommand_HeaderFile +#include "SMESHDS_ListOfCommand.hxx" +#endif +#ifndef _SMESHDS_ListIteratorOfListOfCommand_HeaderFile +#include "SMESHDS_ListIteratorOfListOfCommand.hxx" +#endif +SMESHDS_ListNodeOfListOfCommand::~SMESHDS_ListNodeOfListOfCommand() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_ListNodeOfListOfCommand_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("SMESHDS_ListNodeOfListOfCommand", + sizeof(SMESHDS_ListNodeOfListOfCommand), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_ListNodeOfListOfCommand) Handle(SMESHDS_ListNodeOfListOfCommand)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_ListNodeOfListOfCommand) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_ListNodeOfListOfCommand))) { + _anOtherObject = Handle(SMESHDS_ListNodeOfListOfCommand)((Handle(SMESHDS_ListNodeOfListOfCommand)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_ListNodeOfListOfCommand::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_ListNodeOfListOfCommand) ; +} +Standard_Boolean SMESHDS_ListNodeOfListOfCommand::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_ListNodeOfListOfCommand) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_ListNodeOfListOfCommand::~Handle_SMESHDS_ListNodeOfListOfCommand() {} +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx new file mode 100644 index 000000000..032c27848 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx @@ -0,0 +1,126 @@ +// 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 _SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#define _SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" +#endif + +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _TCollection_MapNode_HeaderFile +#include +#endif +#ifndef _TCollection_MapNodePtr_HeaderFile +#include +#endif +class SMESHDS_ListOfPtrHypothesis; +class SMESHDS_ListIteratorOfListOfPtrHypothesis; + + +class SMESHDS_ListNodeOfListOfPtrHypothesis : 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 SMESHDS_ListNodeOfListOfPtrHypothesis(const SMESHDS_PtrHypothesis& I,const TCollection_MapNodePtr& n); +Standard_EXPORT inline SMESHDS_PtrHypothesis& Value() const; +Standard_EXPORT ~SMESHDS_ListNodeOfListOfPtrHypothesis(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_ListNodeOfListOfPtrHypothesis_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 + // +SMESHDS_PtrHypothesis myValue; + + +}; + +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#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/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..4d47be60f --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx @@ -0,0 +1,89 @@ +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 "SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_ListIteratorOfListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx" +#endif +SMESHDS_ListNodeOfListOfPtrHypothesis::~SMESHDS_ListNodeOfListOfPtrHypothesis() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_ListNodeOfListOfPtrHypothesis_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("SMESHDS_ListNodeOfListOfPtrHypothesis", + sizeof(SMESHDS_ListNodeOfListOfPtrHypothesis), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_ListNodeOfListOfPtrHypothesis) Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_ListNodeOfListOfPtrHypothesis) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_ListNodeOfListOfPtrHypothesis))) { + _anOtherObject = Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)((Handle(SMESHDS_ListNodeOfListOfPtrHypothesis)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_ListNodeOfListOfPtrHypothesis::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_ListNodeOfListOfPtrHypothesis) ; +} +Standard_Boolean SMESHDS_ListNodeOfListOfPtrHypothesis::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_ListNodeOfListOfPtrHypothesis) == AType || TCollection_MapNode::IsKind(AType)); +} +Handle_SMESHDS_ListNodeOfListOfPtrHypothesis::~Handle_SMESHDS_ListNodeOfListOfPtrHypothesis() {} +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListOfAsciiString.hxx b/src/SMESHDS/SMESHDS_ListOfAsciiString.hxx new file mode 100644 index 000000000..189f3a925 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfAsciiString.hxx @@ -0,0 +1,152 @@ +// 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 _SMESHDS_ListOfAsciiString_HeaderFile +#define _SMESHDS_ListOfAsciiString_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMESHDS_ListIteratorOfListOfAsciiString; +class TCollection_AsciiString; +class SMESHDS_ListNodeOfListOfAsciiString; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListOfAsciiString { + +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 SMESHDS_ListOfAsciiString(); +Standard_EXPORT void Assign(const SMESHDS_ListOfAsciiString& Other) ; + void operator=(const SMESHDS_ListOfAsciiString& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMESHDS_ListOfAsciiString() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const TCollection_AsciiString& I) ; +Standard_EXPORT void Prepend(SMESHDS_ListOfAsciiString& Other) ; +Standard_EXPORT void Append(const TCollection_AsciiString& I) ; +Standard_EXPORT void Append(SMESHDS_ListOfAsciiString& Other) ; +Standard_EXPORT TCollection_AsciiString& First() const; +Standard_EXPORT TCollection_AsciiString& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMESHDS_ListIteratorOfListOfAsciiString& It) ; +Standard_EXPORT void InsertBefore(const TCollection_AsciiString& I,SMESHDS_ListIteratorOfListOfAsciiString& It) ; +Standard_EXPORT void InsertBefore(SMESHDS_ListOfAsciiString& Other,SMESHDS_ListIteratorOfListOfAsciiString& It) ; +Standard_EXPORT void InsertAfter(const TCollection_AsciiString& I,SMESHDS_ListIteratorOfListOfAsciiString& It) ; +Standard_EXPORT void InsertAfter(SMESHDS_ListOfAsciiString& Other,SMESHDS_ListIteratorOfListOfAsciiString& It) ; + + +friend class SMESHDS_ListIteratorOfListOfAsciiString; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_ListOfAsciiString(const SMESHDS_ListOfAsciiString& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#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/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx b/src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx new file mode 100644 index 000000000..85ab425f3 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx @@ -0,0 +1,40 @@ +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 "SMESHDS_ListOfAsciiString.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListIteratorOfListOfAsciiString_HeaderFile +#include "SMESHDS_ListIteratorOfListOfAsciiString.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfAsciiString_HeaderFile +#include "SMESHDS_ListNodeOfListOfAsciiString.hxx" +#endif + + +#define Item TCollection_AsciiString +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_() +#define TCollection_List SMESHDS_ListOfAsciiString +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListOfCommand.hxx b/src/SMESHDS/SMESHDS_ListOfCommand.hxx new file mode 100644 index 000000000..4cd94f3b1 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfCommand.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 _SMESHDS_ListOfCommand_HeaderFile +#define _SMESHDS_ListOfCommand_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Command_HeaderFile +#include "Handle_SMESHDS_Command.hxx" +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfCommand_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfCommand.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMESHDS_ListIteratorOfListOfCommand; +class SMESHDS_Command; +class SMESHDS_ListNodeOfListOfCommand; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListOfCommand { + +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 SMESHDS_ListOfCommand(); +Standard_EXPORT void Assign(const SMESHDS_ListOfCommand& Other) ; + void operator=(const SMESHDS_ListOfCommand& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMESHDS_ListOfCommand() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const Handle(SMESHDS_Command)& I) ; +Standard_EXPORT void Prepend(SMESHDS_ListOfCommand& Other) ; +Standard_EXPORT void Append(const Handle(SMESHDS_Command)& I) ; +Standard_EXPORT void Append(SMESHDS_ListOfCommand& Other) ; +Standard_EXPORT Handle_SMESHDS_Command& First() const; +Standard_EXPORT Handle_SMESHDS_Command& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMESHDS_ListIteratorOfListOfCommand& It) ; +Standard_EXPORT void InsertBefore(const Handle(SMESHDS_Command)& I,SMESHDS_ListIteratorOfListOfCommand& It) ; +Standard_EXPORT void InsertBefore(SMESHDS_ListOfCommand& Other,SMESHDS_ListIteratorOfListOfCommand& It) ; +Standard_EXPORT void InsertAfter(const Handle(SMESHDS_Command)& I,SMESHDS_ListIteratorOfListOfCommand& It) ; +Standard_EXPORT void InsertAfter(SMESHDS_ListOfCommand& Other,SMESHDS_ListIteratorOfListOfCommand& It) ; + + +friend class SMESHDS_ListIteratorOfListOfCommand; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_ListOfCommand(const SMESHDS_ListOfCommand& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#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/SMESHDS/SMESHDS_ListOfCommand_0.cxx b/src/SMESHDS/SMESHDS_ListOfCommand_0.cxx new file mode 100644 index 000000000..613b03cb6 --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfCommand_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 "SMESHDS_ListOfCommand.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListIteratorOfListOfCommand_HeaderFile +#include "SMESHDS_ListIteratorOfListOfCommand.hxx" +#endif +#ifndef _SMESHDS_Command_HeaderFile +#include "SMESHDS_Command.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfCommand_HeaderFile +#include "SMESHDS_ListNodeOfListOfCommand.hxx" +#endif + + +#define Item Handle_SMESHDS_Command +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_() +#define TCollection_List SMESHDS_ListOfCommand +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx b/src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx new file mode 100644 index 000000000..f303d07be --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx @@ -0,0 +1,154 @@ +// 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 _SMESHDS_ListOfPtrHypothesis_HeaderFile +#define _SMESHDS_ListOfPtrHypothesis_HeaderFile + +#ifndef _Standard_Address_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Handle_SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#include "Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +class Standard_NoSuchObject; +class SMESHDS_ListIteratorOfListOfPtrHypothesis; +class SMESHDS_ListNodeOfListOfPtrHypothesis; + + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Standard_Macro_HeaderFile +#include +#endif + +class SMESHDS_ListOfPtrHypothesis { + +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 SMESHDS_ListOfPtrHypothesis(); +Standard_EXPORT void Assign(const SMESHDS_ListOfPtrHypothesis& Other) ; + void operator=(const SMESHDS_ListOfPtrHypothesis& Other) +{ + Assign(Other); +} + +Standard_EXPORT Standard_Integer Extent() const; +Standard_EXPORT void Clear() ; +~SMESHDS_ListOfPtrHypothesis() +{ + Clear(); +} + +Standard_EXPORT inline Standard_Boolean IsEmpty() const; +Standard_EXPORT void Prepend(const SMESHDS_PtrHypothesis& I) ; +Standard_EXPORT void Prepend(SMESHDS_ListOfPtrHypothesis& Other) ; +Standard_EXPORT void Append(const SMESHDS_PtrHypothesis& I) ; +Standard_EXPORT void Append(SMESHDS_ListOfPtrHypothesis& Other) ; +Standard_EXPORT SMESHDS_PtrHypothesis& First() const; +Standard_EXPORT SMESHDS_PtrHypothesis& Last() const; +Standard_EXPORT void RemoveFirst() ; +Standard_EXPORT void Remove(SMESHDS_ListIteratorOfListOfPtrHypothesis& It) ; +Standard_EXPORT void InsertBefore(const SMESHDS_PtrHypothesis& I,SMESHDS_ListIteratorOfListOfPtrHypothesis& It) ; +Standard_EXPORT void InsertBefore(SMESHDS_ListOfPtrHypothesis& Other,SMESHDS_ListIteratorOfListOfPtrHypothesis& It) ; +Standard_EXPORT void InsertAfter(const SMESHDS_PtrHypothesis& I,SMESHDS_ListIteratorOfListOfPtrHypothesis& It) ; +Standard_EXPORT void InsertAfter(SMESHDS_ListOfPtrHypothesis& Other,SMESHDS_ListIteratorOfListOfPtrHypothesis& It) ; + + +friend class SMESHDS_ListIteratorOfListOfPtrHypothesis; + + + +protected: + + // Methods PROTECTED + // + + + // Fields PROTECTED + // + + +private: + + // Methods PRIVATE + // +Standard_EXPORT SMESHDS_ListOfPtrHypothesis(const SMESHDS_ListOfPtrHypothesis& Other); + + + // Fields PRIVATE + // +Standard_Address myFirst; +Standard_Address myLast; + + +}; + +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#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/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx b/src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx new file mode 100644 index 000000000..71753e1db --- /dev/null +++ b/src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx @@ -0,0 +1,40 @@ +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 "SMESHDS_ListOfPtrHypothesis.hxx" + +#ifndef _Standard_NoSuchObject_HeaderFile +#include +#endif +#ifndef _SMESHDS_ListIteratorOfListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_ListNodeOfListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListNodeOfListOfPtrHypothesis.hxx" +#endif + + +#define Item SMESHDS_PtrHypothesis +#define Item_hxx +#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_hxx +#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis +#define TCollection_ListIterator_hxx +#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis +#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_() +#define TCollection_List SMESHDS_ListOfPtrHypothesis +#define TCollection_List_hxx +#include + diff --git a/src/SMESHDS/SMESHDS_Mesh.cdl b/src/SMESHDS/SMESHDS_Mesh.cdl new file mode 100644 index 000000000..15959de8d --- /dev/null +++ b/src/SMESHDS/SMESHDS_Mesh.cdl @@ -0,0 +1,157 @@ +-- File : SMESHDS_Mesh.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + + +class Mesh from SMESHDS inherits Mesh from SMDS + +uses + Mesh from SMDS, + MeshNode from SMDS, + MeshEdge from SMDS, + MeshFace from SMDS, + MeshElement from SMDS, + Shell from TopoDS, + Shape from TopoDS, + Face from TopoDS, + Edge from TopoDS, + Vertex from TopoDS, + SubMesh from SMESHDS, + PtrHypothesis from SMESHDS, + ListOfPtrHypothesis from SMESHDS, + Script from SMESHDS, + IndexedMapOfShape from TopTools, + DataMapOfIntegerSubMesh from SMESHDS, + DataMapOfShapeListOfPtrHypothesis from SMESHDS + + +is + + Create (MeshID : Integer from Standard) returns mutable Mesh from SMESHDS; + +-- Building + + ShapeToMesh (me: mutable; S : Shape from TopoDS); + + AddHypothesis(me: mutable; SS : in Shape from TopoDS; H : PtrHypothesis from SMESHDS) + returns Boolean; + + RemoveHypothesis(me: mutable; S : in Shape from TopoDS; H : PtrHypothesis from SMESHDS) + returns Boolean; + + + -- Building Node + + AddNode(me: mutable; x,y,z : Real) returns Integer from Standard + is redefined; + + RemoveNode (me: mutable; ID: Integer) is redefined; + + MoveNode (me: mutable; ID: Integer; x,y,z: Real); + + + -- Building Edge + AddEdge(me: mutable; idnode1, idnode2 : Integer) returns Integer from Standard + is redefined; + + -- Building Face + AddFace(me: mutable; idnode1, idnode2, idnode3 : Integer) returns Integer from Standard + -- To build a Triangle + is redefined; + + + AddFace(me: mutable; idnode1, idnode2, idnode3 , idnode4 : Integer) returns Integer from Standard + -- To build a quadrangle + is redefined; + + -- Building Volume + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4 : Integer) returns Integer + -- To build a Tetrahedron + is redefined; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5 : Integer) returns Integer + -- To build a Pyramid + is redefined; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6 : Integer) returns Integer + -- To build a Prism + is redefined; + + AddVolume(me: mutable; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, idnode7, idnode8 : Integer) returns Integer + -- To build a Hexahedron + is redefined; + + + RemoveElement(me: mutable; IDelem : Integer) + is redefined; + + -- Binding BRep and MeshElements + + SetNodeInVolume (me: mutable; aNode : MeshNode from SMDS ; S : Shell from TopoDS); + + SetNodeOnFace (me: mutable; aNode : MeshNode from SMDS ; S : Face from TopoDS); + + SetNodeOnEdge (me: mutable; aNode : MeshNode from SMDS ; S : Edge from TopoDS); + + SetNodeOnVertex(me: mutable; aNode : MeshNode from SMDS ; S : Vertex from TopoDS); + + UnSetNodeOnShape (me: mutable; aNode : MeshNode from SMDS); + + SetMeshElementOnShape (me: mutable; anElt : MeshElement from SMDS ; S : Shape from TopoDS); + + UnSetMeshElementOnShape (me: mutable; anElt : MeshElement from SMDS ; S : Shape from TopoDS) ; + +-- Exploration + + ShapeToMesh (me: mutable) returns Shape from TopoDS; + + HasMeshElements (me: mutable; S : Shape from TopoDS) returns Boolean from Standard; + + MeshElements (me: mutable; S : Shape from TopoDS) returns SubMesh from SMESHDS; + + HasHypothesis (me: mutable; S : Shape from TopoDS) returns Boolean from Standard; + + GetHypothesis (me: mutable; S : Shape from TopoDS) + ---C++ : return const & + returns ListOfPtrHypothesis from SMESHDS; + +-- Historic of commands + + GetScript(me: mutable) returns Script from SMESHDS; + ---C++ : return const & + + + ClearScript(me: mutable); + +-- Methods for persitance + + ShapeToIndex (me : mutable; aShape : Shape from TopoDS) returns Integer from Standard; + + IndexToShape (me : mutable; ShapeIndex : Integer from Standard) returns Shape from TopoDS; + + NewSubMesh (me : mutable; Index : Integer from Standard); + + SetNodeInVolume (me: mutable; aNode : MeshNode from SMDS ; Index : Integer from Standard); + + SetNodeOnFace (me: mutable; aNode : MeshNode from SMDS ; Index : Integer from Standard); + + SetNodeOnEdge (me: mutable; aNode : MeshNode from SMDS ; Index : Integer from Standard); + + SetNodeOnVertex(me: mutable; aNode : MeshNode from SMDS ; Index : Integer from Standard); + + SetMeshElementOnShape (me: mutable; anElt : MeshElement from SMDS ; Index : Integer from Standard); + + +fields + + myMeshID : Integer from Standard; + myShape : Shape from TopoDS; + myIndexToShape : IndexedMapOfShape from TopTools; -- Gives Index from Shape and Shape from Index + myShapeIndexToSubMesh : DataMapOfIntegerSubMesh from SMESHDS ; + myShapeToHypothesis : DataMapOfShapeListOfPtrHypothesis from SMESHDS; + myScript : Script from SMESHDS; + +end Mesh; diff --git a/src/SMESHDS/SMESHDS_Mesh.cxx b/src/SMESHDS/SMESHDS_Mesh.cxx new file mode 100644 index 000000000..45b11c4b0 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Mesh.cxx @@ -0,0 +1,601 @@ +using namespace std; +//============================================================================= +// File : SMESH_Mesh.cxx +// Created : +// Author : Yves FRICAUD, OCC +// Project : SALOME +// Copyright : OCC 2002 +// $Header: +//============================================================================= + +#include "SMESHDS_Mesh.ixx" +#include "SMESHDS_Hypothesis.hxx" +#include "SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx" +#include "SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx" +#include "SMDS_VertexPosition.hxx" +#include "SMDS_EdgePosition.hxx" +#include "SMDS_FacePosition.hxx" +#include +#include + +#include +#include "utilities.h" + +//======================================================================= +//function : Create +//purpose : +//======================================================================= +SMESHDS_Mesh::SMESHDS_Mesh(const Standard_Integer MeshID) : myMeshID( MeshID) +{ + myScript = new SMESHDS_Script(); +} + +//======================================================================= +//function : ShapeToMesh +//purpose : +//======================================================================= +void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape& S) +{ + myShape = S; + TopExp::MapShapes(myShape,myIndexToShape); +} + + +//======================================================================= +//function : AddHypothesis +//purpose : +//======================================================================= + +Standard_Boolean SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape& SS, + const SMESHDS_PtrHypothesis& H) +{ + if (!myShapeToHypothesis.IsBound(SS)){ + SMESHDS_ListOfPtrHypothesis empty; + myShapeToHypothesis.Bind(SS,empty); + } + else { + //Check if the Hypothesis is still present + SMESHDS_ListOfPtrHypothesis& Hypos = myShapeToHypothesis.ChangeFind (SS); + + for (SMESHDS_ListIteratorOfListOfPtrHypothesis it(Hypos); it.More(); it.Next()) { + if (H == it.Value()) { + return Standard_False; + } + } + } + myShapeToHypothesis(SS).Append(H); + return Standard_True; +} + +//======================================================================= +//function : RemoveHypothesis +//purpose : +//======================================================================= + +Standard_Boolean SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape& S, + const SMESHDS_PtrHypothesis& H) +{ + if (myShapeToHypothesis.IsBound(S)){ + SMESHDS_ListOfPtrHypothesis& Hypos = myShapeToHypothesis.ChangeFind (S); + for (SMESHDS_ListIteratorOfListOfPtrHypothesis it(Hypos); it.More(); it.Next()) { + if (H == it.Value()) { + Hypos.Remove(it); + return Standard_True; + } + } + } + return Standard_False; +} + + +//======================================================================= +//function : AddNode +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::AddNode(const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + Standard_Integer NodeID = SMDS_Mesh::AddNode(x,y,z); + myScript->AddNode(NodeID,x,y,z); + return NodeID; +} + +//======================================================================= +//function : MoveNode +//purpose : +//======================================================================= +void SMESHDS_Mesh::MoveNode(const Standard_Integer ID, + const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + + Handle(SMDS_MeshNode) Node = Handle(SMDS_MeshNode)::DownCast(FindNode(ID)); + gp_Pnt P(x,y,z); + Node->SetPnt(P); + myScript->MoveNode(ID,x,y,z); +} + + + +//======================================================================= +//function : AddEdge +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::AddEdge(const Standard_Integer idnode1, + const Standard_Integer idnode2) +{ + Standard_Integer ID = SMDS_Mesh::AddEdge(idnode1,idnode2); + myScript->AddEdge (ID,idnode1,idnode2); + return ID; +} + + +//======================================================================= +//function :AddFace +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::AddFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + Standard_Integer ID = SMDS_Mesh::AddFace(idnode1,idnode2,idnode3); + myScript->AddFace (ID,idnode1,idnode2,idnode3); + return ID; +} + +//======================================================================= +//function :AddFace +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::AddFace(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Standard_Integer ID = SMDS_Mesh::AddFace(idnode1,idnode2,idnode3,idnode4); + myScript->AddFace (ID,idnode1,idnode2,idnode3,idnode4); + return ID; +} + + +//======================================================================= +//function :AddVolume +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::AddVolume(const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Standard_Integer ID = SMDS_Mesh::AddVolume(idnode1,idnode2,idnode3,idnode4); + myScript->AddVolume (ID,idnode1,idnode2,idnode3,idnode4); + return ID; +} + + +//======================================================================= +//function :AddVolume +//purpose : +//======================================================================= +Standard_Integer SMESHDS_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 = SMDS_Mesh::AddVolume(idnode1,idnode2,idnode3,idnode4,idnode5); + myScript->AddVolume (ID,idnode1,idnode2,idnode3,idnode4,idnode5); + return ID; +} + + +//======================================================================= +//function :AddVolume +//purpose : +//======================================================================= +Standard_Integer SMESHDS_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 = SMDS_Mesh::AddVolume(idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); + myScript->AddVolume (ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); + return ID; +} + +//======================================================================= +//function :AddVolume +//purpose : +//======================================================================= +Standard_Integer SMESHDS_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 = SMDS_Mesh::AddVolume(idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8); + myScript->AddVolume (ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6,idnode7,idnode8); + return ID; +} + + +//======================================================================= +//function : RemoveNode +//purpose : +//======================================================================= +void SMESHDS_Mesh::RemoveNode(const Standard_Integer ID) +{ + SMDS_Mesh::RemoveNode (ID); + myScript->RemoveNode (ID); +} + + + +//======================================================================= +//function : RemoveElement +//purpose : +//======================================================================== +void SMESHDS_Mesh::RemoveElement(const Standard_Integer ID) +{ + SMDS_Mesh::RemoveElement (ID); + myScript->RemoveElement (ID); +} + +//======================================================================= +//function : SetNodeOnVolume +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeInVolume (const Handle(SMDS_MeshNode)& aNode, + const TopoDS_Shell& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetNodeOnVolume"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + //Set Position on Node + //Handle (SMDS_FacePosition) aPos = new SMDS_FacePosition (myFaceToId(S),0.,0.);; + //aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + +//======================================================================= +//function : SetNodeOnFace +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnFace (const Handle(SMDS_MeshNode)& aNode, + const TopoDS_Face& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetNodeOnFace"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + //Set Position on Node + Handle (SMDS_FacePosition) aPos = new SMDS_FacePosition (Index,0.,0.);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + +//======================================================================= +//function : SetNodeOnEdge +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnEdge (const Handle(SMDS_MeshNode)& aNode, + const TopoDS_Edge& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetNodeOnEdge"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + //Set Position on Node + Handle (SMDS_EdgePosition) aPos = new SMDS_EdgePosition (Index,0.);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); + +} + +//======================================================================= +//function : SetNodeOnVertex +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnVertex (const Handle(SMDS_MeshNode)& aNode, + const TopoDS_Vertex& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetNodeOnVertex"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + //Set Position on Node + Handle (SMDS_VertexPosition) aPos = new SMDS_VertexPosition (Index);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + + +//======================================================================= +//function : UnSetNodeOnShape +//purpose : +//======================================================================= +void SMESHDS_Mesh::UnSetNodeOnShape(const Handle(SMDS_MeshNode)& aNode) +{ + MESSAGE("not implemented"); +} + + +//======================================================================= +//function : SetMeshElementOnShape +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetMeshElementOnShape (const Handle(SMDS_MeshElement)& anElement, + const TopoDS_Shape& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetMeshElementOnShape"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddElement (anElement); +} + +//======================================================================= +//function : UnSetMeshElementOnShape +//purpose : +//======================================================================= +void SMESHDS_Mesh::UnSetMeshElementOnShape (const Handle(SMDS_MeshElement)& anElement, + const TopoDS_Shape& S) + +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::UnSetMeshElementOnShape"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + if (myShapeIndexToSubMesh.IsBound(Index)) + myShapeIndexToSubMesh(Index)->RemoveElement (anElement); +} + +//======================================================================= +//function : ShapeToMesh +//purpose : +//======================================================================= +TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() +{ + return myShape; +} + +//======================================================================= +//function : MeshElements +//purpose : +//======================================================================= +Handle_SMESHDS_SubMesh SMESHDS_Mesh::MeshElements(const TopoDS_Shape& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::MeshElements"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + if (myShapeIndexToSubMesh.IsBound(Index)) + return myShapeIndexToSubMesh(Index); + Handle(SMESHDS_SubMesh) SM; + return SM; +} + +//======================================================================= +//function : GetHypothesis +//purpose : +//======================================================================= +const SMESHDS_ListOfPtrHypothesis& SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape& S) +{ + if (myShapeToHypothesis.IsBound(S)) + return myShapeToHypothesis(S); + + static SMESHDS_ListOfPtrHypothesis empty; + return empty; +} + +//======================================================================= +//function : GetScript +//purpose : +//======================================================================= +const Handle (SMESHDS_Script)& SMESHDS_Mesh::GetScript() +{ + return myScript; +} + +//======================================================================= +//function : ClearScript +//purpose : +//======================================================================= +void SMESHDS_Mesh::ClearScript() +{ + myScript->Clear(); +} + +//======================================================================= +//function : HasMeshElements +//purpose : +//======================================================================= +Standard_Boolean SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::MeshElements"); + + Standard_Integer Index = myIndexToShape.FindIndex(S); + + return myShapeIndexToSubMesh.IsBound(Index); +} + +//======================================================================= +//function : HasHypothesis +//purpose : +//======================================================================= +Standard_Boolean SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape& S) +{ + return myShapeToHypothesis.IsBound(S); +} + +//======================================================================= +//function : NewSubMesh +//purpose : +//======================================================================= +void SMESHDS_Mesh::NewSubMesh(const Standard_Integer Index) +{ + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } +} + +//======================================================================= +//function : IndexToShape +//purpose : +//======================================================================= +TopoDS_Shape SMESHDS_Mesh::IndexToShape(const Standard_Integer ShapeIndex) +{ + return myIndexToShape.FindKey(ShapeIndex); +} + +//======================================================================= +//function : ShapeToIndex +//purpose : +//======================================================================= +Standard_Integer SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape& S) +{ + if (myShape.IsNull()) + Standard_NullObject::Raise("SMESHDS_Mesh::SetNodeOnVolume"); + + return myIndexToShape.FindIndex(S); +} + +//======================================================================= +//function : SetNodeOnVolume +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeInVolume (const Handle(SMDS_MeshNode)& aNode, + const Standard_Integer Index) +{ + + //Set Position on Node + //Handle (SMDS_FacePosition) aPos = new SMDS_FacePosition (myFaceToId(S),0.,0.);; + //aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + +//======================================================================= +//function : SetNodeOnFace +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnFace (const Handle(SMDS_MeshNode)& aNode, + const Standard_Integer Index) +{ + + //Set Position on Node + Handle (SMDS_FacePosition) aPos = new SMDS_FacePosition (Index,0.,0.);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + +//======================================================================= +//function : SetNodeOnEdge +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnEdge (const Handle(SMDS_MeshNode)& aNode, + const Standard_Integer Index) +{ + + //Set Position on Node + Handle (SMDS_EdgePosition) aPos = new SMDS_EdgePosition (Index,0.);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); + +} + +//======================================================================= +//function : SetNodeOnVertex +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetNodeOnVertex (const Handle(SMDS_MeshNode)& aNode, + const Standard_Integer Index) +{ + //Set Position on Node + Handle (SMDS_VertexPosition) aPos = new SMDS_VertexPosition (Index);; + aNode->SetPosition(aPos); + + //Update or build submesh + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddNode (aNode); +} + +//======================================================================= +//function : SetMeshElementOnShape +//purpose : +//======================================================================= +void SMESHDS_Mesh::SetMeshElementOnShape (const Handle(SMDS_MeshElement)& anElement, + const Standard_Integer Index) +{ + if (!myShapeIndexToSubMesh.IsBound(Index)) { + Handle(SMESHDS_SubMesh) SM = new SMESHDS_SubMesh (this); + myShapeIndexToSubMesh.Bind(Index,SM); + } + myShapeIndexToSubMesh(Index)->AddElement (anElement); +} diff --git a/src/SMESHDS/SMESHDS_Mesh.hxx b/src/SMESHDS/SMESHDS_Mesh.hxx new file mode 100644 index 000000000..260d4ac7a --- /dev/null +++ b/src/SMESHDS/SMESHDS_Mesh.hxx @@ -0,0 +1,186 @@ +// 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 _SMESHDS_Mesh_HeaderFile +#define _SMESHDS_Mesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Mesh_HeaderFile +#include "Handle_SMESHDS_Mesh.hxx" +#endif + +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _TopoDS_Shell_HeaderFile +#include +#endif +#ifndef _TopTools_IndexedMapOfShape_HeaderFile +#include +#endif +#ifndef _SMESHDS_DataMapOfIntegerSubMesh_HeaderFile +#include "SMESHDS_DataMapOfIntegerSubMesh.hxx" +#endif +#ifndef _SMESHDS_DataMapOfShapeListOfPtrHypothesis_HeaderFile +#include "SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx" +#endif +#ifndef _Handle_SMESHDS_Script_HeaderFile +#include "Handle_SMESHDS_Script.hxx" +#endif +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +#ifndef _SMESHDS_PtrHypothesis_HeaderFile +#include "SMESHDS_PtrHypothesis.hxx" +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +#ifndef _Handle_SMDS_MeshNode_HeaderFile +#include "Handle_SMDS_MeshNode.hxx" +#endif +#ifndef _Handle_SMDS_MeshElement_HeaderFile +#include "Handle_SMDS_MeshElement.hxx" +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif +class SMESHDS_Script; +class TopoDS_Shape; +class SMDS_MeshNode; +class TopoDS_Shell; +class TopoDS_Face; +class TopoDS_Edge; +class TopoDS_Vertex; +class SMDS_MeshElement; +class SMESHDS_SubMesh; +class SMESHDS_ListOfPtrHypothesis; + + +class SMESHDS_Mesh : public SMDS_Mesh { + +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 SMESHDS_Mesh(const Standard_Integer MeshID); +Standard_EXPORT void ShapeToMesh(const TopoDS_Shape& S) ; +Standard_EXPORT Standard_Boolean AddHypothesis(const TopoDS_Shape& SS,const SMESHDS_PtrHypothesis& H) ; +Standard_EXPORT Standard_Boolean RemoveHypothesis(const TopoDS_Shape& S,const SMESHDS_PtrHypothesis& H) ; +Standard_EXPORT virtual Standard_Integer AddNode(const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT virtual void RemoveNode(const Standard_Integer ID) ; +Standard_EXPORT void MoveNode(const Standard_Integer ID,const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT virtual Standard_Integer AddEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) ; +Standard_EXPORT virtual Standard_Integer AddFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; +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_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; +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_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_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 void RemoveElement(const Standard_Integer IDelem) ; +Standard_EXPORT void SetNodeInVolume(const Handle(SMDS_MeshNode)& aNode,const TopoDS_Shell& S) ; +Standard_EXPORT void SetNodeOnFace(const Handle(SMDS_MeshNode)& aNode,const TopoDS_Face& S) ; +Standard_EXPORT void SetNodeOnEdge(const Handle(SMDS_MeshNode)& aNode,const TopoDS_Edge& S) ; +Standard_EXPORT void SetNodeOnVertex(const Handle(SMDS_MeshNode)& aNode,const TopoDS_Vertex& S) ; +Standard_EXPORT void UnSetNodeOnShape(const Handle(SMDS_MeshNode)& aNode) ; +Standard_EXPORT void SetMeshElementOnShape(const Handle(SMDS_MeshElement)& anElt,const TopoDS_Shape& S) ; +Standard_EXPORT void UnSetMeshElementOnShape(const Handle(SMDS_MeshElement)& anElt,const TopoDS_Shape& S) ; +Standard_EXPORT TopoDS_Shape ShapeToMesh() ; +Standard_EXPORT Standard_Boolean HasMeshElements(const TopoDS_Shape& S) ; +Standard_EXPORT Handle_SMESHDS_SubMesh MeshElements(const TopoDS_Shape& S) ; +Standard_EXPORT Standard_Boolean HasHypothesis(const TopoDS_Shape& S) ; +Standard_EXPORT const SMESHDS_ListOfPtrHypothesis& GetHypothesis(const TopoDS_Shape& S) ; +Standard_EXPORT const Handle_SMESHDS_Script& GetScript() ; +Standard_EXPORT void ClearScript() ; +Standard_EXPORT Standard_Integer ShapeToIndex(const TopoDS_Shape& aShape) ; +Standard_EXPORT TopoDS_Shape IndexToShape(const Standard_Integer ShapeIndex) ; +Standard_EXPORT void NewSubMesh(const Standard_Integer Index) ; +Standard_EXPORT void SetNodeInVolume(const Handle(SMDS_MeshNode)& aNode,const Standard_Integer Index) ; +Standard_EXPORT void SetNodeOnFace(const Handle(SMDS_MeshNode)& aNode,const Standard_Integer Index) ; +Standard_EXPORT void SetNodeOnEdge(const Handle(SMDS_MeshNode)& aNode,const Standard_Integer Index) ; +Standard_EXPORT void SetNodeOnVertex(const Handle(SMDS_MeshNode)& aNode,const Standard_Integer Index) ; +Standard_EXPORT void SetMeshElementOnShape(const Handle(SMDS_MeshElement)& anElt,const Standard_Integer Index) ; +Standard_EXPORT ~SMESHDS_Mesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_Mesh_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 myMeshID; +TopoDS_Shape myShape; +TopTools_IndexedMapOfShape myIndexToShape; +SMESHDS_DataMapOfIntegerSubMesh myShapeIndexToSubMesh; +SMESHDS_DataMapOfShapeListOfPtrHypothesis myShapeToHypothesis; +Handle_SMESHDS_Script myScript; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_Mesh.ixx b/src/SMESHDS/SMESHDS_Mesh.ixx new file mode 100644 index 000000000..865af0c29 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Mesh.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 "SMESHDS_Mesh.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMESHDS_Mesh::~SMESHDS_Mesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_Mesh_Type_() +{ + + static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Mesh); + if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Mesh); + 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("SMESHDS_Mesh", + sizeof(SMESHDS_Mesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_Mesh) Handle(SMESHDS_Mesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_Mesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_Mesh))) { + _anOtherObject = Handle(SMESHDS_Mesh)((Handle(SMESHDS_Mesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_Mesh::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_Mesh) ; +} +Standard_Boolean SMESHDS_Mesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_Mesh) == AType || SMDS_Mesh::IsKind(AType)); +} +Handle_SMESHDS_Mesh::~Handle_SMESHDS_Mesh() {} + diff --git a/src/SMESHDS/SMESHDS_Mesh.jxx b/src/SMESHDS/SMESHDS_Mesh.jxx new file mode 100644 index 000000000..395da02b8 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Mesh.jxx @@ -0,0 +1,30 @@ +#ifndef _SMESHDS_Script_HeaderFile +#include "SMESHDS_Script.hxx" +#endif +#ifndef _TopoDS_Shape_HeaderFile +#include +#endif +#ifndef _SMDS_MeshNode_HeaderFile +#include "SMDS_MeshNode.hxx" +#endif +#ifndef _TopoDS_Face_HeaderFile +#include +#endif +#ifndef _TopoDS_Edge_HeaderFile +#include +#endif +#ifndef _TopoDS_Vertex_HeaderFile +#include +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif +#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile +#include "SMESHDS_ListOfPtrHypothesis.hxx" +#endif +#ifndef _SMESHDS_Mesh_HeaderFile +#include "SMESHDS_Mesh.hxx" +#endif diff --git a/src/SMESHDS/SMESHDS_PtrHypothesis.hxx b/src/SMESHDS/SMESHDS_PtrHypothesis.hxx new file mode 100644 index 000000000..82ef45ff2 --- /dev/null +++ b/src/SMESHDS/SMESHDS_PtrHypothesis.hxx @@ -0,0 +1,22 @@ +// File generated by CPPExt (Pointer) +// 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 _SMESHDS_PtrHypothesis_HeaderFile +#define _SMESHDS_PtrHypothesis_HeaderFile + +class SMESHDS_Hypothesis; + +typedef SMESHDS_Hypothesis* SMESHDS_PtrHypothesis; + +#endif diff --git a/src/SMESHDS/SMESHDS_Script.cdl b/src/SMESHDS/SMESHDS_Script.cdl new file mode 100644 index 000000000..f224b21f3 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Script.cdl @@ -0,0 +1,52 @@ +-- File : SMESHDS_Script.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + +class Script from SMESHDS inherits TShared from MMgt + +uses + Integer from Standard, + Real from Standard, + CString from Standard, + ListOfCommand from SMESHDS + +is + + --Building + AddNode(me: mutable; NewNodeID : Integer; x,y,z : Real); + + AddEdge(me: mutable; NewEdgeID : Integer; idnode1, idnode2 : Integer); + + AddFace(me: mutable; NewFaceID : Integer; idnode1, idnode2, idnode3 : Integer); + + AddFace(me: mutable; NewFaceID : Integer; idnode1, idnode2, idnode3, idnode4 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6 : Integer); + + AddVolume(me: mutable; NewVolID : Integer; idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, idnode7, idnode8 : Integer); + + + MoveNode(me: mutable; NewNodeID : Integer; x,y,z : Real); + + RemoveNode (me: mutable; NodeID : Integer); + + RemoveElement(me: mutable; ElementID : Integer); + + Clear (me : mutable); + + -- Querry + + GetCommands (me : mutable) returns ListOfCommand from SMESHDS; + ---C++ :return const & +fields + + myCommands : ListOfCommand from SMESHDS; + + +end Script; diff --git a/src/SMESHDS/SMESHDS_Script.cxx b/src/SMESHDS/SMESHDS_Script.cxx new file mode 100644 index 000000000..6c702be56 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Script.cxx @@ -0,0 +1,304 @@ +using namespace std; +//============================================================================= +// File : SMESH_Script.cxx +// Created : +// Author : Yves FRICAUD, OCC +// Project : SALOME +// Copyright : OCC 2002 +// $Header: +//============================================================================= + +#include "SMESHDS_Script.ixx" +#include "SMESHDS_Command.hxx" +#include "SMESHDS_CommandType.hxx" +#include "SMESHDS_ListOfCommand.hxx" + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddNode(const Standard_Integer NewNodeID, + const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddNode); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddNode) { + com = new SMESHDS_Command(SMESHDS_AddNode); + myCommands.Append (com); + } + } + com->AddNode (NewNodeID,x,y,z); +} + + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddEdge(const Standard_Integer NewEdgeID, + const Standard_Integer idnode1, + const Standard_Integer idnode2) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddEdge); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddEdge) { + com = new SMESHDS_Command(SMESHDS_AddEdge); + myCommands.Append (com); + } + } + com->AddEdge (NewEdgeID,idnode1,idnode2); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddFace(const Standard_Integer NewFaceID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddTriangle); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddTriangle) { + com = new SMESHDS_Command(SMESHDS_AddTriangle); + myCommands.Append (com); + } + } + com->AddFace (NewFaceID,idnode1,idnode2,idnode3); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddFace(const Standard_Integer NewFaceID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddQuadrangle); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddQuadrangle) { + com = new SMESHDS_Command(SMESHDS_AddQuadrangle); + myCommands.Append (com); + } + } + com->AddFace (NewFaceID,idnode1,idnode2,idnode3,idnode4); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddVolume(const Standard_Integer NewID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddTetrahedron); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddQuadrangle) { + com = new SMESHDS_Command(SMESHDS_AddQuadrangle); + myCommands.Append (com); + } + } + com->AddVolume (NewID,idnode1,idnode2,idnode3,idnode4); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddVolume(const Standard_Integer NewID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddPyramid); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddPyramid) { + com = new SMESHDS_Command(SMESHDS_AddPyramid); + myCommands.Append (com); + } + } + com->AddVolume (NewID,idnode1,idnode2,idnode3,idnode4,idnode5); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddVolume(const Standard_Integer NewID, + const Standard_Integer idnode1, + const Standard_Integer idnode2, + const Standard_Integer idnode3, + const Standard_Integer idnode4, + const Standard_Integer idnode5, + const Standard_Integer idnode6) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddPrism); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddPrism) { + com = new SMESHDS_Command(SMESHDS_AddPrism); + myCommands.Append (com); + } + } + com->AddVolume (NewID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::AddVolume(const Standard_Integer NewID, + 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) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_AddHexahedron); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_AddHexahedron) { + com = new SMESHDS_Command(SMESHDS_AddHexahedron); + myCommands.Append (com); + } + } + com->AddVolume (NewID,idnode1,idnode2,idnode3,idnode4, + idnode5,idnode6,idnode7,idnode8); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::MoveNode(const Standard_Integer NewNodeID, + const Standard_Real x, + const Standard_Real y, + const Standard_Real z) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_MoveNode); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_MoveNode) { + com = new SMESHDS_Command(SMESHDS_MoveNode); + myCommands.Append (com); + } + } + com->MoveNode (NewNodeID,x,y,z); +} + + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::RemoveNode(const Standard_Integer ID) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_RemoveNode); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_RemoveNode) { + com = new SMESHDS_Command(SMESHDS_RemoveNode); + myCommands.Append (com); + } + } + com->RemoveNode (ID); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= + void SMESHDS_Script::RemoveElement(const Standard_Integer ElementID) +{ + Handle(SMESHDS_Command) com; + if (myCommands.IsEmpty()) { + com = new SMESHDS_Command(SMESHDS_RemoveElement); + myCommands.Append (com); + } + else { + com = myCommands.Last(); + if (com->GetType() != SMESHDS_RemoveElement) { + com = new SMESHDS_Command(SMESHDS_RemoveElement); + myCommands.Append (com); + } + } + com->RemoveElement (ElementID); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +void SMESHDS_Script::Clear() +{ + myCommands.Clear(); +} + +//======================================================================= +//function : +//purpose : +//======================================================================= +const SMESHDS_ListOfCommand& SMESHDS_Script::GetCommands() +{ + return myCommands; +} diff --git a/src/SMESHDS/SMESHDS_Script.hxx b/src/SMESHDS/SMESHDS_Script.hxx new file mode 100644 index 000000000..bfbedf52e --- /dev/null +++ b/src/SMESHDS/SMESHDS_Script.hxx @@ -0,0 +1,118 @@ +// 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 _SMESHDS_Script_HeaderFile +#define _SMESHDS_Script_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_Script_HeaderFile +#include "Handle_SMESHDS_Script.hxx" +#endif + +#ifndef _SMESHDS_ListOfCommand_HeaderFile +#include "SMESHDS_ListOfCommand.hxx" +#endif +#ifndef _MMgt_TShared_HeaderFile +#include +#endif +#ifndef _Standard_Integer_HeaderFile +#include +#endif +#ifndef _Standard_Real_HeaderFile +#include +#endif +class SMESHDS_ListOfCommand; + + +class SMESHDS_Script : 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 void AddNode(const Standard_Integer NewNodeID,const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT void AddEdge(const Standard_Integer NewEdgeID,const Standard_Integer idnode1,const Standard_Integer idnode2) ; +Standard_EXPORT void AddFace(const Standard_Integer NewFaceID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; +Standard_EXPORT void AddFace(const Standard_Integer NewFaceID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) ; +Standard_EXPORT void AddVolume(const Standard_Integer NewVolID,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 AddVolume(const Standard_Integer NewVolID,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 MoveNode(const Standard_Integer NewNodeID,const Standard_Real x,const Standard_Real y,const Standard_Real z) ; +Standard_EXPORT void RemoveNode(const Standard_Integer NodeID) ; +Standard_EXPORT void RemoveElement(const Standard_Integer ElementID) ; +Standard_EXPORT void Clear() ; +Standard_EXPORT const SMESHDS_ListOfCommand& GetCommands() ; +Standard_EXPORT ~SMESHDS_Script(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_Script_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 + // +SMESHDS_ListOfCommand myCommands; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_Script.ixx b/src/SMESHDS/SMESHDS_Script.ixx new file mode 100644 index 000000000..cbfb33e82 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Script.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 "SMESHDS_Script.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMESHDS_Script::~SMESHDS_Script() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_Script_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("SMESHDS_Script", + sizeof(SMESHDS_Script), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_Script) Handle(SMESHDS_Script)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_Script) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_Script))) { + _anOtherObject = Handle(SMESHDS_Script)((Handle(SMESHDS_Script)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_Script::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_Script) ; +} +Standard_Boolean SMESHDS_Script::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_Script) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMESHDS_Script::~Handle_SMESHDS_Script() {} + diff --git a/src/SMESHDS/SMESHDS_Script.jxx b/src/SMESHDS/SMESHDS_Script.jxx new file mode 100644 index 000000000..4cb5490c7 --- /dev/null +++ b/src/SMESHDS/SMESHDS_Script.jxx @@ -0,0 +1,6 @@ +#ifndef _SMESHDS_ListOfCommand_HeaderFile +#include "SMESHDS_ListOfCommand.hxx" +#endif +#ifndef _SMESHDS_Script_HeaderFile +#include "SMESHDS_Script.hxx" +#endif diff --git a/src/SMESHDS/SMESHDS_SubMesh.cdl b/src/SMESHDS/SMESHDS_SubMesh.cdl new file mode 100644 index 000000000..030e4e36d --- /dev/null +++ b/src/SMESHDS/SMESHDS_SubMesh.cdl @@ -0,0 +1,62 @@ +-- File : SMESHDS_SubMesh.cdl +-- Created : +-- Author : Yves FRICAUD, OCC +-- Project : SALOME +-- Copyright : OCC + +class SubMesh from SMESHDS inherits TShared from MMgt + +uses + Mesh from SMDS, + MeshElement from SMDS, + MeshNode from SMDS, + ListOfInteger from TColStd, + MapOfMeshElement from SMDS + +is + + Create (M : Mesh from SMDS) returns mutable SubMesh from SMESHDS; + + -- Build + + AddElement (me : mutable; ME : MeshElement from SMDS); + + RemoveElement (me: mutable; ME : MeshElement from SMDS); + + AddNode (me : mutable; ME : MeshNode from SMDS); + + RemoveNode (me: mutable; ME : MeshNode from SMDS); + + + -- Querry + + NbElements (me: mutable) returns Integer from Standard; + + GetElements (me: mutable ) returns MapOfMeshElement from SMDS; + ---C++ : return const & + + GetIDElements (me: mutable) returns ListOfInteger from TColStd; + ---C++ : return const & + + NbNodes (me: mutable) returns Integer from Standard; + + GetNodes (me: mutable ) returns MapOfMeshElement from SMDS; + ---C++ : return const & + + GetIDNodes (me: mutable) returns ListOfInteger from TColStd; + ---C++ : return const & + +fields + + myMesh : Mesh from SMDS; + myElements : MapOfMeshElement from SMDS; + myNodes : MapOfMeshElement from SMDS; + + myListOfEltIDIsUpdate : Boolean from Standard; + myListOfEltID : ListOfInteger from TColStd; + + myListOfNodeIDIsUpdate : Boolean from Standard; + myListOfNodeID : ListOfInteger from TColStd; + + +end SubMesh; diff --git a/src/SMESHDS/SMESHDS_SubMesh.cxx b/src/SMESHDS/SMESHDS_SubMesh.cxx new file mode 100644 index 000000000..fab9fba9c --- /dev/null +++ b/src/SMESHDS/SMESHDS_SubMesh.cxx @@ -0,0 +1,128 @@ +using namespace std; +//============================================================================= +// File : SMESH_SubMesh.cxx +// Created : +// Author : Yves FRICAUD, OCC +// Project : SALOME +// Copyright : OCC 2002 +// $Header: +//============================================================================= + +#include "SMESHDS_SubMesh.ixx" +#include "SMDS_MapIteratorOfExtendedMap.hxx" + +//======================================================================= +//function : SMESHDS_SubMesh +//purpose : +//======================================================================= +SMESHDS_SubMesh::SMESHDS_SubMesh(const Handle(SMDS_Mesh)& M) : myMesh(M) +{ + myListOfEltIDIsUpdate = Standard_False; + myListOfNodeIDIsUpdate = Standard_False; +} + +//======================================================================= +//function : AddElement +//purpose : +//======================================================================= +void SMESHDS_SubMesh::AddElement (const Handle(SMDS_MeshElement)& ME) +{ + myElements.Add(ME); + myListOfEltIDIsUpdate = Standard_False; +} + +//======================================================================= +//function : RemoveElement +//purpose : +//======================================================================= +void SMESHDS_SubMesh::RemoveElement(const Handle(SMDS_MeshElement)& ME) +{ + myElements.Remove(ME); + myListOfEltIDIsUpdate = Standard_False; +} +//======================================================================= +//function : AddNode +//purpose : +//======================================================================= +void SMESHDS_SubMesh::AddNode (const Handle(SMDS_MeshNode)& N) +{ + myNodes.Add(N); + myListOfNodeIDIsUpdate = Standard_False; +} + +//======================================================================= +//function : RemoveNode +//purpose : +//======================================================================= +void SMESHDS_SubMesh::RemoveNode (const Handle(SMDS_MeshNode)& N) +{ + myNodes.Remove(N); + myListOfNodeIDIsUpdate = Standard_False; +} + +//======================================================================= +//function : NbElements +//purpose : +//======================================================================= +Standard_Integer SMESHDS_SubMesh::NbElements() +{ + return myElements.Extent(); +} + +//======================================================================= +//function : GetElements +//purpose : +//======================================================================= +const SMDS_MapOfMeshElement& SMESHDS_SubMesh::GetElements() +{ + return myElements; +} +//======================================================================= +//function : NbNodes +//purpose : +//======================================================================= +Standard_Integer SMESHDS_SubMesh::NbNodes() +{ + return myNodes.Extent(); +} + +//======================================================================= +//function : GetNodes +//purpose : +//======================================================================= +const SMDS_MapOfMeshElement& SMESHDS_SubMesh::GetNodes() +{ + return myNodes; +} + +//======================================================================= +//function : GetIDElements +//purpose : +//======================================================================= +const TColStd_ListOfInteger& SMESHDS_SubMesh::GetIDElements() +{ + if (!myListOfEltIDIsUpdate) { + myListOfEltID.Clear(); + for (SMDS_MapIteratorOfExtendedMap it(myElements); it.More(); it.Next()) { + myListOfEltID.Append(it.Key()->GetID()); + } + myListOfEltIDIsUpdate = Standard_True; + } + return myListOfEltID; +} + +//======================================================================= +//function : GetIDNodes +//purpose : +//======================================================================= +const TColStd_ListOfInteger& SMESHDS_SubMesh::GetIDNodes() +{ + if (!myListOfNodeIDIsUpdate) { + myListOfNodeID.Clear(); + for (SMDS_MapIteratorOfExtendedMap it(myNodes); it.More(); it.Next()) { + myListOfNodeID.Append(it.Key()->GetID()); + } + myListOfNodeIDIsUpdate = Standard_True; + } + return myListOfNodeID; +} diff --git a/src/SMESHDS/SMESHDS_SubMesh.hxx b/src/SMESHDS/SMESHDS_SubMesh.hxx new file mode 100644 index 000000000..334965d89 --- /dev/null +++ b/src/SMESHDS/SMESHDS_SubMesh.hxx @@ -0,0 +1,138 @@ +// 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 _SMESHDS_SubMesh_HeaderFile +#define _SMESHDS_SubMesh_HeaderFile + +#ifndef _Standard_HeaderFile +#include +#endif +#ifndef _Handle_SMESHDS_SubMesh_HeaderFile +#include "Handle_SMESHDS_SubMesh.hxx" +#endif + +#ifndef _Handle_SMDS_Mesh_HeaderFile +#include "Handle_SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _Standard_Boolean_HeaderFile +#include +#endif +#ifndef _TColStd_ListOfInteger_HeaderFile +#include +#endif +#ifndef _MMgt_TShared_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 +#ifndef _Standard_Integer_HeaderFile +#include +#endif +class SMDS_Mesh; +class SMDS_MeshElement; +class SMDS_MeshNode; +class SMDS_MapOfMeshElement; +class TColStd_ListOfInteger; + + +class SMESHDS_SubMesh : 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 SMESHDS_SubMesh(const Handle(SMDS_Mesh)& M); +Standard_EXPORT void AddElement(const Handle(SMDS_MeshElement)& ME) ; +Standard_EXPORT void RemoveElement(const Handle(SMDS_MeshElement)& ME) ; +Standard_EXPORT void AddNode(const Handle(SMDS_MeshNode)& ME) ; +Standard_EXPORT void RemoveNode(const Handle(SMDS_MeshNode)& ME) ; +Standard_EXPORT Standard_Integer NbElements() ; +Standard_EXPORT const SMDS_MapOfMeshElement& GetElements() ; +Standard_EXPORT const TColStd_ListOfInteger& GetIDElements() ; +Standard_EXPORT Standard_Integer NbNodes() ; +Standard_EXPORT const SMDS_MapOfMeshElement& GetNodes() ; +Standard_EXPORT const TColStd_ListOfInteger& GetIDNodes() ; +Standard_EXPORT ~SMESHDS_SubMesh(); + + + + + // Type management + // + Standard_EXPORT friend Handle_Standard_Type& SMESHDS_SubMesh_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 myMesh; +SMDS_MapOfMeshElement myElements; +SMDS_MapOfMeshElement myNodes; +Standard_Boolean myListOfEltIDIsUpdate; +TColStd_ListOfInteger myListOfEltID; +Standard_Boolean myListOfNodeIDIsUpdate; +TColStd_ListOfInteger myListOfNodeID; + + +}; + + + + + +// other inline functions and methods (like "C++: function call" methods) +// + + +#endif diff --git a/src/SMESHDS/SMESHDS_SubMesh.ixx b/src/SMESHDS/SMESHDS_SubMesh.ixx new file mode 100644 index 000000000..7e85ef0ff --- /dev/null +++ b/src/SMESHDS/SMESHDS_SubMesh.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 "SMESHDS_SubMesh.jxx" + +#ifndef _Standard_TypeMismatch_HeaderFile +#include +#endif + +SMESHDS_SubMesh::~SMESHDS_SubMesh() {} + + + +Standard_EXPORT Handle_Standard_Type& SMESHDS_SubMesh_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("SMESHDS_SubMesh", + sizeof(SMESHDS_SubMesh), + 1, + (Standard_Address)_Ancestors, + (Standard_Address)NULL); + + return _aType; +} + + +// DownCast method +// allow safe downcasting +// +const Handle(SMESHDS_SubMesh) Handle(SMESHDS_SubMesh)::DownCast(const Handle(Standard_Transient)& AnObject) +{ + Handle(SMESHDS_SubMesh) _anOtherObject; + + if (!AnObject.IsNull()) { + if (AnObject->IsKind(STANDARD_TYPE(SMESHDS_SubMesh))) { + _anOtherObject = Handle(SMESHDS_SubMesh)((Handle(SMESHDS_SubMesh)&)AnObject); + } + } + + return _anOtherObject ; +} +const Handle(Standard_Type)& SMESHDS_SubMesh::DynamicType() const +{ + return STANDARD_TYPE(SMESHDS_SubMesh) ; +} +Standard_Boolean SMESHDS_SubMesh::IsKind(const Handle(Standard_Type)& AType) const +{ + return (STANDARD_TYPE(SMESHDS_SubMesh) == AType || MMgt_TShared::IsKind(AType)); +} +Handle_SMESHDS_SubMesh::~Handle_SMESHDS_SubMesh() {} + diff --git a/src/SMESHDS/SMESHDS_SubMesh.jxx b/src/SMESHDS/SMESHDS_SubMesh.jxx new file mode 100644 index 000000000..fc05b5a8b --- /dev/null +++ b/src/SMESHDS/SMESHDS_SubMesh.jxx @@ -0,0 +1,18 @@ +#ifndef _SMDS_Mesh_HeaderFile +#include "SMDS_Mesh.hxx" +#endif +#ifndef _SMDS_MeshElement_HeaderFile +#include "SMDS_MeshElement.hxx" +#endif +#ifndef _SMDS_MeshNode_HeaderFile +#include "SMDS_MeshNode.hxx" +#endif +#ifndef _SMDS_MapOfMeshElement_HeaderFile +#include "SMDS_MapOfMeshElement.hxx" +#endif +#ifndef _TColStd_ListOfInteger_HeaderFile +#include +#endif +#ifndef _SMESHDS_SubMesh_HeaderFile +#include "SMESHDS_SubMesh.hxx" +#endif -- 2.39.2