NRI : First integration.

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_MMgt_TShared_HeaderFile
+#include <Handle_MMgt_TShared.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_MMgt_TShared_HeaderFile
+#include <Handle_MMgt_TShared.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_TCollection_MapNode_HeaderFile
+#include <Handle_TCollection_MapNode.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_MMgt_TShared_HeaderFile
+#include <Handle_MMgt_TShared.hxx>
+#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

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 <Standard_Macro.hxx>
+#endif
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+
+#ifndef _Handle_MMgt_TShared_HeaderFile
+#include <Handle_MMgt_TShared.hxx>
+#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

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@
+

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;

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;

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;
+}

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 <Standard.hxx>
+#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 <Standard_Integer.hxx>
+#endif
+#ifndef _TColStd_ListOfReal_HeaderFile
+#include <TColStd_ListOfReal.hxx>
+#endif
+#ifndef _TColStd_ListOfInteger_HeaderFile
+#include <TColStd_ListOfInteger.hxx>
+#endif
+#ifndef _MMgt_TShared_HeaderFile
+#include <MMgt_TShared.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#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

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 <Standard_TypeMismatch.hxx>
+#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() {}
+

src/SMESHDS/SMESHDS_Command.jxx

@@ -0,0 +1,9 @@
+#ifndef _TColStd_ListOfInteger_HeaderFile
+#include <TColStd_ListOfInteger.hxx>
+#endif
+#ifndef _TColStd_ListOfReal_HeaderFile
+#include <TColStd_ListOfReal.hxx>
+#endif
+#ifndef _SMESHDS_Command_HeaderFile
+#include "SMESHDS_Command.hxx"
+#endif

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 <Standard_PrimitiveTypes.hxx>
+#endif
+
+#endif

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 <TCollection_BasicMapIterator.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _SMESHDS_Mesh_HeaderFile
+#include "SMESHDS_Mesh.hxx"
+#endif
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_Mesh
+#define TheItem_hxx <SMESHDS_Mesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerMesh.hxx>
+#include <TCollection_DataMapIterator.gxx>
+

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 <TCollection_BasicMapIterator.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem SMESHDS_PtrHypothesis
+#define TheItem_hxx <SMESHDS_PtrHypothesis.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerPtrHypothesis.hxx>
+#include <TCollection_DataMapIterator.gxx>
+

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 <TCollection_BasicMapIterator.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_NoSuchObject.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerSubMesh.hxx>
+#include <TCollection_DataMapIterator.gxx>
+

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 <TCollection_BasicMapIterator.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile
+#include "SMESHDS_ListOfPtrHypothesis.hxx"
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem SMESHDS_ListOfPtrHypothesis
+#define TheItem_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx>
+#include <TCollection_DataMapIterator.gxx>
+

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 <TCollection_BasicMapIterator.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_SubMesh_HeaderFile
+#include "SMESHDS_SubMesh.hxx"
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeSubMesh.hxx>
+#include <TCollection_DataMapIterator.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx"
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Handle_SMESHDS_Mesh_HeaderFile
+#include "Handle_SMESHDS_Mesh.hxx"
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_Mesh
+#define TheItem_hxx <SMESHDS_Mesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerMesh.hxx>
+
+#include <TCollection_DataMapNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#endif
+
+#ifndef _SMESHDS_Mesh_HeaderFile
+#include "SMESHDS_Mesh.hxx"
+#endif
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_Mesh
+#define TheItem_hxx <SMESHDS_Mesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerMesh.hxx>
+#include <TCollection_DataMapNode.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx"
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _SMESHDS_PtrHypothesis_HeaderFile
+#include "SMESHDS_PtrHypothesis.hxx"
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem SMESHDS_PtrHypothesis
+#define TheItem_hxx <SMESHDS_PtrHypothesis.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerPtrHypothesis.hxx>
+
+#include <TCollection_DataMapNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#endif
+
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem SMESHDS_PtrHypothesis
+#define TheItem_hxx <SMESHDS_PtrHypothesis.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerPtrHypothesis.hxx>
+#include <TCollection_DataMapNode.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx"
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Handle_SMESHDS_SubMesh_HeaderFile
+#include "Handle_SMESHDS_SubMesh.hxx"
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerSubMesh.hxx>
+
+#include <TCollection_DataMapNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#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_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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerSubMesh.hxx>
+#include <TCollection_DataMapNode.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx"
+#endif
+
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile
+#include "SMESHDS_ListOfPtrHypothesis.hxx"
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem SMESHDS_ListOfPtrHypothesis
+#define TheItem_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx>
+
+#include <TCollection_DataMapNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#endif
+
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile
+#include "SMESHDS_ListOfPtrHypothesis.hxx"
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem SMESHDS_ListOfPtrHypothesis
+#define TheItem_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx>
+#include <TCollection_DataMapNode.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx"
+#endif
+
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _Handle_SMESHDS_SubMesh_HeaderFile
+#include "Handle_SMESHDS_SubMesh.hxx"
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeSubMesh.hxx>
+
+#include <TCollection_DataMapNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#endif
+
+#ifndef _SMESHDS_SubMesh_HeaderFile
+#include "SMESHDS_SubMesh.hxx"
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeSubMesh.hxx>
+#include <TCollection_DataMapNode.gxx>
+

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 <TCollection_BasicMap.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+class Standard_DomainError;
+class Standard_NoSuchObject;
+class SMESHDS_Mesh;
+class TColStd_MapIntegerHasher;
+class SMESHDS_DataMapNodeOfDataMapOfIntegerMesh;
+class SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_DomainError.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _SMESHDS_Mesh_HeaderFile
+#include "SMESHDS_Mesh.hxx"
+#endif
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_Mesh
+#define TheItem_hxx <SMESHDS_Mesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerMesh.hxx>
+#include <TCollection_DataMap.gxx>
+

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 <TCollection_BasicMap.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+class Standard_DomainError;
+class Standard_NoSuchObject;
+class TColStd_MapIntegerHasher;
+class SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis;
+class SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_DomainError.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TColStd_MapIntegerHasher_HeaderFile
+#include <TColStd_MapIntegerHasher.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem SMESHDS_PtrHypothesis
+#define TheItem_hxx <SMESHDS_PtrHypothesis.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerPtrHypothesis.hxx>
+#include <TCollection_DataMap.gxx>
+

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 <TCollection_BasicMap.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+class Standard_DomainError;
+class Standard_NoSuchObject;
+class SMESHDS_SubMesh;
+class TColStd_MapIntegerHasher;
+class SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh;
+class SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_DomainError.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#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 <Standard_Integer.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TColStd_MapIntegerHasher
+#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfIntegerSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfIntegerSubMesh.hxx>
+#include <TCollection_DataMap.gxx>
+

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 <TCollection_BasicMap.hxx>
+#endif
+#ifndef _Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_HeaderFile
+#include "Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx"
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_DomainError.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_ListOfPtrHypothesis_HeaderFile
+#include "SMESHDS_ListOfPtrHypothesis.hxx"
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem SMESHDS_ListOfPtrHypothesis
+#define TheItem_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeListOfPtrHypothesis
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx>
+#include <TCollection_DataMap.gxx>
+

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 <TCollection_BasicMap.hxx>
+#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 <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#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 <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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

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 <Standard_DomainError.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMESHDS_SubMesh_HeaderFile
+#include "SMESHDS_SubMesh.hxx"
+#endif
+#ifndef _TopTools_ShapeMapHasher_HeaderFile
+#include <TopTools_ShapeMapHasher.hxx>
+#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 <TopoDS_Shape.hxx>
+#define TheItem Handle_SMESHDS_SubMesh
+#define TheItem_hxx <SMESHDS_SubMesh.hxx>
+#define Hasher TopTools_ShapeMapHasher
+#define Hasher_hxx <TopTools_ShapeMapHasher.hxx>
+#define TCollection_DataMapNode SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_hxx <SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx>
+#define TCollection_DataMapIterator SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh
+#define TCollection_DataMapIterator_hxx <SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx>
+#define Handle_TCollection_DataMapNode Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh
+#define TCollection_DataMapNode_Type_() SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_Type_()
+#define TCollection_DataMap SMESHDS_DataMapOfShapeSubMesh
+#define TCollection_DataMap_hxx <SMESHDS_DataMapOfShapeSubMesh.hxx>
+#include <TCollection_DataMap.gxx>
+

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;
+

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 <Standard_OutOfRange.hxx>
+
+//=======================================================================
+//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();
+}
+
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_Document_HeaderFile
+#include "Handle_SMESHDS_Document.hxx"
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#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 <MMgt_TShared.hxx>
+#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 <Standard_Boolean.hxx>
+#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

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 <Standard_TypeMismatch.hxx>
+#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() {}
+

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

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;
+}
+

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 <string>
+#include <istream>
+#include <ostream>
+#else 
+#include <string>
+#include <istream.h>
+#include <ostream.h>
+#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

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 <Standard_Address.hxx>
+#endif
+#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile
+#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx"
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+class Standard_NoMoreObject;
+class Standard_NoSuchObject;
+class SMESHDS_ListOfAsciiString;
+class TCollection_AsciiString;
+class SMESHDS_ListNodeOfListOfAsciiString;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+
+#include <TCollection_ListIterator.lxx>
+
+#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

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 <Standard_NoMoreObject.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+#include <TCollection_ListIterator.gxx>
+

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 <Standard_Address.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+class Standard_NoMoreObject;
+class Standard_NoSuchObject;
+class SMESHDS_ListOfCommand;
+class SMESHDS_Command;
+class SMESHDS_ListNodeOfListOfCommand;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+
+#include <TCollection_ListIterator.lxx>
+
+#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

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 <Standard_NoMoreObject.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+#include <TCollection_ListIterator.gxx>
+

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 <Standard_Address.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+class Standard_NoMoreObject;
+class Standard_NoSuchObject;
+class SMESHDS_ListOfPtrHypothesis;
+class SMESHDS_ListNodeOfListOfPtrHypothesis;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+
+#include <TCollection_ListIterator.lxx>
+
+#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

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 <Standard_NoMoreObject.hxx>
+#endif
+#ifndef _Standard_NoSuchObject_HeaderFile
+#include <Standard_NoSuchObject.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#include <TCollection_ListIterator.gxx>
+

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile
+#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx"
+#endif
+
+#ifndef _TCollection_AsciiString_HeaderFile
+#include <TCollection_AsciiString.hxx>
+#endif
+#ifndef _TCollection_MapNode_HeaderFile
+#include <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+
+#include <TCollection_ListNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+#include <TCollection_ListNode.gxx>
+

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 <Standard.hxx>
+#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 <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+
+#include <TCollection_ListNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+#include <TCollection_ListNode.gxx>
+

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 <Standard.hxx>
+#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 <TCollection_MapNode.hxx>
+#endif
+#ifndef _TCollection_MapNodePtr_HeaderFile
+#include <TCollection_MapNodePtr.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+
+#include <TCollection_ListNode.lxx>
+
+#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

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 <Standard_TypeMismatch.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#include <TCollection_ListNode.gxx>
+

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 <Standard_Address.hxx>
+#endif
+#ifndef _Handle_SMESHDS_ListNodeOfListOfAsciiString_HeaderFile
+#include "Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx"
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+class Standard_NoSuchObject;
+class SMESHDS_ListIteratorOfListOfAsciiString;
+class TCollection_AsciiString;
+class SMESHDS_ListNodeOfListOfAsciiString;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+
+#include <TCollection_List.lxx>
+
+#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

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 <Standard_NoSuchObject.hxx>
+#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 <TCollection_AsciiString.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfAsciiString.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfAsciiString
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfAsciiString.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfAsciiString
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfAsciiString_Type_()
+#define TCollection_List SMESHDS_ListOfAsciiString
+#define TCollection_List_hxx <SMESHDS_ListOfAsciiString.hxx>
+#include <TCollection_List.gxx>
+

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 <Standard_Address.hxx>
+#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 <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+class Standard_NoSuchObject;
+class SMESHDS_ListIteratorOfListOfCommand;
+class SMESHDS_Command;
+class SMESHDS_ListNodeOfListOfCommand;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+
+#include <TCollection_List.lxx>
+
+#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

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 <Standard_NoSuchObject.hxx>
+#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 <SMESHDS_Command.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfCommand.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfCommand
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfCommand.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfCommand
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfCommand_Type_()
+#define TCollection_List SMESHDS_ListOfCommand
+#define TCollection_List_hxx <SMESHDS_ListOfCommand.hxx>
+#include <TCollection_List.gxx>
+

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 <Standard_Address.hxx>
+#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 <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Boolean_HeaderFile
+#include <Standard_Boolean.hxx>
+#endif
+class Standard_NoSuchObject;
+class SMESHDS_ListIteratorOfListOfPtrHypothesis;
+class SMESHDS_ListNodeOfListOfPtrHypothesis;
+
+
+#ifndef _Standard_HeaderFile
+#include <Standard.hxx>
+#endif
+#ifndef _Standard_Macro_HeaderFile
+#include <Standard_Macro.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+
+#include <TCollection_List.lxx>
+
+#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

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 <Standard_NoSuchObject.hxx>
+#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 <SMESHDS_PtrHypothesis.hxx>
+#define TCollection_ListNode SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_hxx <SMESHDS_ListNodeOfListOfPtrHypothesis.hxx>
+#define TCollection_ListIterator SMESHDS_ListIteratorOfListOfPtrHypothesis
+#define TCollection_ListIterator_hxx <SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx>
+#define Handle_TCollection_ListNode Handle_SMESHDS_ListNodeOfListOfPtrHypothesis
+#define TCollection_ListNode_Type_() SMESHDS_ListNodeOfListOfPtrHypothesis_Type_()
+#define TCollection_List SMESHDS_ListOfPtrHypothesis
+#define TCollection_List_hxx <SMESHDS_ListOfPtrHypothesis.hxx>
+#include <TCollection_List.gxx>
+

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;

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 <TopExp_Explorer.hxx>
+#include <TopExp.hxx>
+
+#include <Standard_NullObject.hxx>
+#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);
+}

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 <Standard.hxx>
+#endif
+#ifndef _Handle_SMESHDS_Mesh_HeaderFile
+#include "Handle_SMESHDS_Mesh.hxx"
+#endif
+
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _TopoDS_Shell_HeaderFile
+#include <TopoDS_Shell.hxx>
+#endif
+#ifndef _TopTools_IndexedMapOfShape_HeaderFile
+#include <TopTools_IndexedMapOfShape.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+#ifndef _SMESHDS_PtrHypothesis_HeaderFile
+#include "SMESHDS_PtrHypothesis.hxx"
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#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

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 <Standard_TypeMismatch.hxx>
+#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() {}
+

src/SMESHDS/SMESHDS_Mesh.jxx

@@ -0,0 +1,30 @@
+#ifndef _SMESHDS_Script_HeaderFile
+#include "SMESHDS_Script.hxx"
+#endif
+#ifndef _TopoDS_Shape_HeaderFile
+#include <TopoDS_Shape.hxx>
+#endif
+#ifndef _SMDS_MeshNode_HeaderFile
+#include "SMDS_MeshNode.hxx"
+#endif
+#ifndef _TopoDS_Face_HeaderFile
+#include <TopoDS_Face.hxx>
+#endif
+#ifndef _TopoDS_Edge_HeaderFile
+#include <TopoDS_Edge.hxx>
+#endif
+#ifndef _TopoDS_Vertex_HeaderFile
+#include <TopoDS_Vertex.hxx>
+#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

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

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;

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;
+}

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 <Standard.hxx>
+#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 <MMgt_TShared.hxx>
+#endif
+#ifndef _Standard_Integer_HeaderFile
+#include <Standard_Integer.hxx>
+#endif
+#ifndef _Standard_Real_HeaderFile
+#include <Standard_Real.hxx>
+#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

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 <Standard_TypeMismatch.hxx>
+#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() {}
+

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

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;

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;
+}

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 <Standard.hxx>
+#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 <Standard_Boolean.hxx>
+#endif
+#ifndef _TColStd_ListOfInteger_HeaderFile
+#include <TColStd_ListOfInteger.hxx>
+#endif
+#ifndef _MMgt_TShared_HeaderFile
+#include <MMgt_TShared.hxx>
+#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 <Standard_Integer.hxx>
+#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

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 <Standard_TypeMismatch.hxx>
+#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() {}
+

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 <TColStd_ListOfInteger.hxx>
+#endif
+#ifndef _SMESHDS_SubMesh_HeaderFile
+#include "SMESHDS_SubMesh.hxx"
+#endif