ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-26 01:10:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

Remove no longer needed files

Browse Source
This commit is contained in:
jrt 2003-09-04 15:04:26 +00:00
parent c914dd6b70
commit 24761f97d2
78 changed files with 0 additions and 7778 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
src/SMESHDS/Handle_SMESHDS_Command.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_Command.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_Document.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_Document.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_ListNodeOfListOfCommand.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_Mesh.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_Mesh.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_Script.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_Script.hxx
// Module : SMESH
#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

100
src/SMESHDS/Handle_SMESHDS_SubMesh.hxx
View File

@ -1,100 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : Handle_SMESHDS_SubMesh.hxx
// Module : SMESH
#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

90
src/SMESHDS/SMESHDS.cdl
View File

@ -1,90 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

83
src/SMESHDS/SMESHDS_Command.cdl
View File

@ -1,83 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS_Script.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

81
src/SMESHDS/SMESHDS_Command.ixx
View File

@ -1,81 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Command.ixx
// Module : SMESH
#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() {}

35
src/SMESHDS/SMESHDS_Command.jxx
View File

@ -1,35 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Command.jxx
// Module : SMESH
#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

118
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx
View File

@ -1,118 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx
// Module : SMESH
#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

62
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx
View File

@ -1,62 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

117
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx
View File

@ -1,117 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx
// Module : SMESH
#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

59
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx
View File

@ -1,59 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

118
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx
View File

@ -1,118 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx
// Module : SMESH
#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

62
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx
View File

@ -1,62 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

113
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx
View File

@ -1,113 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx
// Module : SMESH
#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

65
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx
View File

@ -1,65 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

116
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx
View File

@ -1,116 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx
// Module : SMESH
#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

65
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx
View File

@ -1,65 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

152
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
View File

@ -1,152 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
// Module : SMESH
#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

111
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx
View File

@ -1,111 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

151
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
View File

@ -1,151 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
// Module : SMESH
#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

108
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx
View File

@ -1,108 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

152
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
View File

@ -1,152 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
// Module : SMESH
#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

111
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx
View File

@ -1,111 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

153
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
View File

@ -1,153 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
// Module : SMESH
#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

114
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx
View File

@ -1,114 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

153
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
View File

@ -1,153 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
// Module : SMESH
#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

114
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx
View File

@ -1,114 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

147
src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx
View File

@ -1,147 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerMesh.hxx
// Module : SMESH
#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

65
src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx
View File

@ -1,65 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

146
src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx
View File

@ -1,146 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerPtrHypothesis.hxx
// Module : SMESH
#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

62
src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx
View File

@ -1,62 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

147
src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx
View File

@ -1,147 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerSubMesh.hxx
// Module : SMESH
#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

65
src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx
View File

@ -1,65 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfIntegerSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

145
src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx
View File

@ -1,145 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx
// Module : SMESH
#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

68
src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx
View File

@ -1,68 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

148
src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx
View File

@ -1,148 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfShapeSubMesh.hxx
// Module : SMESH
#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

68
src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx
View File

@ -1,68 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_DataMapOfShapeSubMesh_0.cxx
// Module : SMESH
using namespace std;
#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>

87
src/SMESHDS/SMESHDS_Document.cdl
View File

@ -1,87 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS_Document.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

81
src/SMESHDS/SMESHDS_Document.ixx
View File

@ -1,81 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Document.ixx
// Module : SMESH
#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() {}

32
src/SMESHDS/SMESHDS_Document.jxx
View File

@ -1,32 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Document.jxx
// Module : SMESH
#ifndef _SMESHDS_Mesh_HeaderFile
#include "SMESHDS_Mesh.hxx"
#endif
#ifndef _SMESHDS_Document_HeaderFile
#include "SMESHDS_Document.hxx"
#endif

140
src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx
View File

@ -1,140 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfAsciiString.hxx
// Module : SMESH
#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

55
src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx
View File

@ -1,55 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfAsciiString_0.cxx
// Module : SMESH
using namespace std;
#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>

143
src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx
View File

@ -1,143 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfCommand.hxx
// Module : SMESH
#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

58
src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx
View File

@ -1,58 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfCommand_0.cxx
// Module : SMESH
using namespace std;
#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>

142
src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx
View File

@ -1,142 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx
// Module : SMESH
#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

55
src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx
View File

@ -1,55 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

138
src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx
View File

@ -1,138 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfAsciiString.hxx
// Module : SMESH
#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

101
src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx
View File

@ -1,101 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfAsciiString_0.cxx
// Module : SMESH
using namespace std;
#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>

138
src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx
View File

@ -1,138 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfCommand.hxx
// Module : SMESH
#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

104
src/SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx
View File

@ -1,104 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfCommand_0.cxx
// Module : SMESH
using namespace std;
#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>

137
src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
View File

@ -1,137 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
// Module : SMESH
#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

101
src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx
View File

@ -1,101 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

164
src/SMESHDS/SMESHDS_ListOfAsciiString.hxx
View File

@ -1,164 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfAsciiString.hxx
// Module : SMESH
#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

52
src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx
View File

@ -1,52 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfAsciiString_0.cxx
// Module : SMESH
using namespace std;
#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>

167
src/SMESHDS/SMESHDS_ListOfCommand.hxx
View File

@ -1,167 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfCommand.hxx
// Module : SMESH
#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

55
src/SMESHDS/SMESHDS_ListOfCommand_0.cxx
View File

@ -1,55 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfCommand_0.cxx
// Module : SMESH
using namespace std;
#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>

166
src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx
View File

@ -1,166 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfPtrHypothesis.hxx
// Module : SMESH
#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

52
src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx
View File

@ -1,52 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_ListOfPtrHypothesis_0.cxx
// Module : SMESH
using namespace std;
#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>

177
src/SMESHDS/SMESHDS_Mesh.cdl
View File

@ -1,177 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS_Mesh.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

85
src/SMESHDS/SMESHDS_Mesh.ixx
View File

@ -1,85 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Mesh.ixx
// Module : SMESH
#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() {}

56
src/SMESHDS/SMESHDS_Mesh.jxx
View File

@ -1,56 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Mesh.jxx
// Module : SMESH
#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

34
src/SMESHDS/SMESHDS_PtrHypothesis.hxx
View File

@ -1,34 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_PtrHypothesis.hxx
// Module : SMESH
#ifndef _SMESHDS_PtrHypothesis_HeaderFile
#define _SMESHDS_PtrHypothesis_HeaderFile
class SMESHDS_Hypothesis;
typedef SMESHDS_Hypothesis* SMESHDS_PtrHypothesis;
#endif

73
src/SMESHDS/SMESHDS_Script.cdl
View File

@ -1,73 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS_Script.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

81
src/SMESHDS/SMESHDS_Script.ixx
View File

@ -1,81 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Script.ixx
// Module : SMESH
#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() {}

32
src/SMESHDS/SMESHDS_Script.jxx
View File

@ -1,32 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_Script.jxx
// Module : SMESH
#ifndef _SMESHDS_ListOfCommand_HeaderFile
#include "SMESHDS_ListOfCommand.hxx"
#endif
#ifndef _SMESHDS_Script_HeaderFile
#include "SMESHDS_Script.hxx"
#endif

83
src/SMESHDS/SMESHDS_SubMesh.cdl
View File

@ -1,83 +0,0 @@
-- SMESH SMESHDS : management of mesh data and SMESH document
--
-- Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-- CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- You should have received a copy of the GNU Lesser General Public
-- License along with this library; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
-- See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
--
--
--
-- File : SMESHDS_SubMesh.cdl
-- Author : Yves FRICAUD, OCC
-- Module : SMESH
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;

81
src/SMESHDS/SMESHDS_SubMesh.ixx
View File

@ -1,81 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_SubMesh.ixx
// Module : SMESH
#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() {}

44
src/SMESHDS/SMESHDS_SubMesh.jxx
View File

@ -1,44 +0,0 @@
// SMESH SMESHDS : management of mesh data and SMESH document
//
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
//
//
//
// File : SMESHDS_SubMesh.jxx
// Module : SMESH
#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