mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-11-11 16:19:16 +05:00
Remove no longer needed files
This commit is contained in:
jrt
parent
af3738fabc
commit
c914dd6b70
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDSControl_BoundaryEdges.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDSControl_BoundaryEdges_HeaderFile
|
||||
#define _Handle_SMDSControl_BoundaryEdges_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "Handle_SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDSControl_MeshBoundary);
|
||||
class SMDSControl_BoundaryEdges;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryEdges);
|
||||
|
||||
class Handle(SMDSControl_BoundaryEdges) : public Handle(SMDSControl_MeshBoundary) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_BoundaryEdges)():Handle(SMDSControl_MeshBoundary)() {}
|
||||
Handle(SMDSControl_BoundaryEdges)(const Handle(SMDSControl_BoundaryEdges)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)(const SMDSControl_BoundaryEdges* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)& operator=(const Handle(SMDSControl_BoundaryEdges)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)& operator=(const SMDSControl_BoundaryEdges* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryEdges* operator->()
|
||||
{
|
||||
return (SMDSControl_BoundaryEdges *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryEdges* operator->() const
|
||||
{
|
||||
return (SMDSControl_BoundaryEdges *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_BoundaryEdges)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_BoundaryEdges) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDSControl_BoundaryFaces.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDSControl_BoundaryFaces_HeaderFile
|
||||
#define _Handle_SMDSControl_BoundaryFaces_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "Handle_SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDSControl_MeshBoundary);
|
||||
class SMDSControl_BoundaryFaces;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryFaces);
|
||||
|
||||
class Handle(SMDSControl_BoundaryFaces) : public Handle(SMDSControl_MeshBoundary) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_BoundaryFaces)():Handle(SMDSControl_MeshBoundary)() {}
|
||||
Handle(SMDSControl_BoundaryFaces)(const Handle(SMDSControl_BoundaryFaces)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)(const SMDSControl_BoundaryFaces* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)& operator=(const Handle(SMDSControl_BoundaryFaces)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)& operator=(const SMDSControl_BoundaryFaces* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryFaces* operator->()
|
||||
{
|
||||
return (SMDSControl_BoundaryFaces *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryFaces* operator->() const
|
||||
{
|
||||
return (SMDSControl_BoundaryFaces *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_BoundaryFaces)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_BoundaryFaces) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDSControl_MeshBoundary.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#define _Handle_SMDSControl_MeshBoundary_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 SMDSControl_MeshBoundary;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
|
||||
class Handle(SMDSControl_MeshBoundary) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_MeshBoundary)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDSControl_MeshBoundary)(const Handle(SMDSControl_MeshBoundary)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)(const SMDSControl_MeshBoundary* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)& operator=(const Handle(SMDSControl_MeshBoundary)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)& operator=(const SMDSControl_MeshBoundary* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_MeshBoundary* operator->()
|
||||
{
|
||||
return (SMDSControl_MeshBoundary *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_MeshBoundary* operator->() const
|
||||
{
|
||||
return (SMDSControl_MeshBoundary *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_MeshBoundary)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_MeshBoundary) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#define _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_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 SMDS_DataMapNodeOfDataMapOfIntegerMeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement);
|
||||
|
||||
class Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->()
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#define _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_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 SMDS_DataMapNodeOfDataMapOfPntInteger;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger);
|
||||
|
||||
class Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger* operator->()
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger* operator->() const
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_EdgePosition.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_EdgePosition_HeaderFile
|
||||
#define _Handle_SMDS_EdgePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_EdgePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_EdgePosition);
|
||||
|
||||
class Handle(SMDS_EdgePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_EdgePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_EdgePosition)(const Handle(SMDS_EdgePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)(const SMDS_EdgePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)& operator=(const Handle(SMDS_EdgePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)& operator=(const SMDS_EdgePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_EdgePosition* operator->()
|
||||
{
|
||||
return (SMDS_EdgePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_EdgePosition* operator->() const
|
||||
{
|
||||
return (SMDS_EdgePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_EdgePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_EdgePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_FacePosition.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_FacePosition_HeaderFile
|
||||
#define _Handle_SMDS_FacePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_FacePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_FacePosition);
|
||||
|
||||
class Handle(SMDS_FacePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_FacePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_FacePosition)(const Handle(SMDS_FacePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)(const SMDS_FacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)& operator=(const Handle(SMDS_FacePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)& operator=(const SMDS_FacePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_FacePosition* operator->()
|
||||
{
|
||||
return (SMDS_FacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_FacePosition* operator->() const
|
||||
{
|
||||
return (SMDS_FacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_FacePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_FacePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDS_HSequenceOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_HSequenceOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_HSequenceOfMesh_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 SMDS_HSequenceOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_HSequenceOfMesh);
|
||||
|
||||
class Handle(SMDS_HSequenceOfMesh) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_HSequenceOfMesh)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_HSequenceOfMesh)(const Handle(SMDS_HSequenceOfMesh)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)(const SMDS_HSequenceOfMesh* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)& operator=(const Handle(SMDS_HSequenceOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)& operator=(const SMDS_HSequenceOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_HSequenceOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_HSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_HSequenceOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_HSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_HSequenceOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_HSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_ListNodeOfListOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMesh_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 SMDS_ListNodeOfListOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMesh);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMesh) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMesh)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMesh)(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)(const SMDS_ListNodeOfListOfMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)& operator=(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)& operator=(const SMDS_ListNodeOfListOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_ListNodeOfListOfMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMeshElement_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 SMDS_ListNodeOfListOfMeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMeshElement) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)(const SMDS_ListNodeOfListOfMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const SMDS_ListNodeOfListOfMeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshElement* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDS_ListNodeOfListOfMeshGroup.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMeshGroup_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 SMDS_ListNodeOfListOfMeshGroup;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMeshGroup) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)(const SMDS_ListNodeOfListOfMeshGroup* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const SMDS_ListNodeOfListOfMeshGroup* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshGroup* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshGroup* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshGroup)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshGroup) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_Mesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#define _Handle_SMDS_Mesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_Mesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Mesh);
|
||||
|
||||
class Handle(SMDS_Mesh) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_Mesh)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_Mesh)(const Handle(SMDS_Mesh)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)(const SMDS_Mesh* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)& operator=(const Handle(SMDS_Mesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)& operator=(const SMDS_Mesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_Mesh* operator->()
|
||||
{
|
||||
return (SMDS_Mesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_Mesh* operator->() const
|
||||
{
|
||||
return (SMDS_Mesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_Mesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_Mesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshEdge.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshEdge_HeaderFile
|
||||
#define _Handle_SMDS_MeshEdge_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshEdge;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshEdge);
|
||||
|
||||
class Handle(SMDS_MeshEdge) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshEdge)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshEdge)(const Handle(SMDS_MeshEdge)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)(const SMDS_MeshEdge* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)& operator=(const Handle(SMDS_MeshEdge)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)& operator=(const SMDS_MeshEdge* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshEdge* operator->()
|
||||
{
|
||||
return (SMDS_MeshEdge *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshEdge* operator->() const
|
||||
{
|
||||
return (SMDS_MeshEdge *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshEdge)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshEdge) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#define _Handle_SMDS_MeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElement);
|
||||
|
||||
class Handle(SMDS_MeshElement) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshElement)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshElement)(const Handle(SMDS_MeshElement)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)(const SMDS_MeshElement* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)& operator=(const Handle(SMDS_MeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)& operator=(const SMDS_MeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshElement* operator->()
|
||||
{
|
||||
return (SMDS_MeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_MeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshElementIDFactory.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshElementIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#include "Handle_SMDS_MeshIDFactory.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshIDFactory);
|
||||
class SMDS_MeshElementIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElementIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshElementIDFactory) : public Handle(SMDS_MeshIDFactory) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshElementIDFactory)():Handle(SMDS_MeshIDFactory)() {}
|
||||
Handle(SMDS_MeshElementIDFactory)(const Handle(SMDS_MeshElementIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)(const SMDS_MeshElementIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)& operator=(const Handle(SMDS_MeshElementIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)& operator=(const SMDS_MeshElementIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshElementIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshElementIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshElementIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshElementIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshElementIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshElementIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshFace.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#define _Handle_SMDS_MeshFace_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshFace;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshFace);
|
||||
|
||||
class Handle(SMDS_MeshFace) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshFace)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshFace)(const Handle(SMDS_MeshFace)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)(const SMDS_MeshFace* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)& operator=(const Handle(SMDS_MeshFace)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)& operator=(const SMDS_MeshFace* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshFace* operator->()
|
||||
{
|
||||
return (SMDS_MeshFace *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshFace* operator->() const
|
||||
{
|
||||
return (SMDS_MeshFace *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshFace)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshFace) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDS_MeshGroup.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshGroup_HeaderFile
|
||||
#define _Handle_SMDS_MeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshGroup;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshGroup);
|
||||
|
||||
class Handle(SMDS_MeshGroup) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshGroup)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshGroup)(const Handle(SMDS_MeshGroup)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)(const SMDS_MeshGroup* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)& operator=(const Handle(SMDS_MeshGroup)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)& operator=(const SMDS_MeshGroup* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshGroup* operator->()
|
||||
{
|
||||
return (SMDS_MeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshGroup* operator->() const
|
||||
{
|
||||
return (SMDS_MeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshGroup)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshGroup) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshHexahedron.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshHexahedron_HeaderFile
|
||||
#define _Handle_SMDS_MeshHexahedron_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshHexahedron;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshHexahedron);
|
||||
|
||||
class Handle(SMDS_MeshHexahedron) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshHexahedron)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshHexahedron)(const Handle(SMDS_MeshHexahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)(const SMDS_MeshHexahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)& operator=(const Handle(SMDS_MeshHexahedron)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)& operator=(const SMDS_MeshHexahedron* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshHexahedron* operator->()
|
||||
{
|
||||
return (SMDS_MeshHexahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshHexahedron* operator->() const
|
||||
{
|
||||
return (SMDS_MeshHexahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshHexahedron)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshHexahedron) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshIDFactory.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshIDFactory) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshIDFactory)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshIDFactory)(const Handle(SMDS_MeshIDFactory)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)(const SMDS_MeshIDFactory* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)& operator=(const Handle(SMDS_MeshIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)& operator=(const SMDS_MeshIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshNode.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshNode_HeaderFile
|
||||
#define _Handle_SMDS_MeshNode_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshNode;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNode);
|
||||
|
||||
class Handle(SMDS_MeshNode) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshNode)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshNode)(const Handle(SMDS_MeshNode)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)(const SMDS_MeshNode* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)& operator=(const Handle(SMDS_MeshNode)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)& operator=(const SMDS_MeshNode* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshNode* operator->()
|
||||
{
|
||||
return (SMDS_MeshNode *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshNode* operator->() const
|
||||
{
|
||||
return (SMDS_MeshNode *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshNode)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshNode) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshNodeIDFactory.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshNodeIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#include "Handle_SMDS_MeshIDFactory.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshIDFactory);
|
||||
class SMDS_MeshNodeIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNodeIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshNodeIDFactory) : public Handle(SMDS_MeshIDFactory) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshNodeIDFactory)():Handle(SMDS_MeshIDFactory)() {}
|
||||
Handle(SMDS_MeshNodeIDFactory)(const Handle(SMDS_MeshNodeIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)(const SMDS_MeshNodeIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)& operator=(const Handle(SMDS_MeshNodeIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)& operator=(const SMDS_MeshNodeIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshNodeIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshNodeIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshNodeIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshNodeIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshNodeIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshNodeIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshObject.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#define _Handle_SMDS_MeshObject_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 SMDS_MeshObject;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshObject);
|
||||
|
||||
class Handle(SMDS_MeshObject) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshObject)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_MeshObject)(const Handle(SMDS_MeshObject)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)(const SMDS_MeshObject* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)& operator=(const Handle(SMDS_MeshObject)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)& operator=(const SMDS_MeshObject* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshObject* operator->()
|
||||
{
|
||||
return (SMDS_MeshObject *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshObject* operator->() const
|
||||
{
|
||||
return (SMDS_MeshObject *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshObject)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshObject) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshPrism.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshPrism_HeaderFile
|
||||
#define _Handle_SMDS_MeshPrism_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshPrism;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPrism);
|
||||
|
||||
class Handle(SMDS_MeshPrism) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshPrism)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshPrism)(const Handle(SMDS_MeshPrism)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)(const SMDS_MeshPrism* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)& operator=(const Handle(SMDS_MeshPrism)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)& operator=(const SMDS_MeshPrism* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshPrism* operator->()
|
||||
{
|
||||
return (SMDS_MeshPrism *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshPrism* operator->() const
|
||||
{
|
||||
return (SMDS_MeshPrism *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshPrism)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshPrism) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshPyramid.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshPyramid_HeaderFile
|
||||
#define _Handle_SMDS_MeshPyramid_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshPyramid;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPyramid);
|
||||
|
||||
class Handle(SMDS_MeshPyramid) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshPyramid)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshPyramid)(const Handle(SMDS_MeshPyramid)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)(const SMDS_MeshPyramid* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)& operator=(const Handle(SMDS_MeshPyramid)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)& operator=(const SMDS_MeshPyramid* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshPyramid* operator->()
|
||||
{
|
||||
return (SMDS_MeshPyramid *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshPyramid* operator->() const
|
||||
{
|
||||
return (SMDS_MeshPyramid *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshPyramid)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshPyramid) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshQuadrangle.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshQuadrangle_HeaderFile
|
||||
#define _Handle_SMDS_MeshQuadrangle_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#include "Handle_SMDS_MeshFace.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshFace);
|
||||
class SMDS_MeshQuadrangle;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshQuadrangle);
|
||||
|
||||
class Handle(SMDS_MeshQuadrangle) : public Handle(SMDS_MeshFace) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshQuadrangle)():Handle(SMDS_MeshFace)() {}
|
||||
Handle(SMDS_MeshQuadrangle)(const Handle(SMDS_MeshQuadrangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)(const SMDS_MeshQuadrangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)& operator=(const Handle(SMDS_MeshQuadrangle)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)& operator=(const SMDS_MeshQuadrangle* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshQuadrangle* operator->()
|
||||
{
|
||||
return (SMDS_MeshQuadrangle *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshQuadrangle* operator->() const
|
||||
{
|
||||
return (SMDS_MeshQuadrangle *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshQuadrangle)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshQuadrangle) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshTetrahedron.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshTetrahedron_HeaderFile
|
||||
#define _Handle_SMDS_MeshTetrahedron_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshTetrahedron;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTetrahedron);
|
||||
|
||||
class Handle(SMDS_MeshTetrahedron) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshTetrahedron)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshTetrahedron)(const Handle(SMDS_MeshTetrahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)(const SMDS_MeshTetrahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)& operator=(const Handle(SMDS_MeshTetrahedron)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)& operator=(const SMDS_MeshTetrahedron* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshTetrahedron* operator->()
|
||||
{
|
||||
return (SMDS_MeshTetrahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshTetrahedron* operator->() const
|
||||
{
|
||||
return (SMDS_MeshTetrahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshTetrahedron)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshTetrahedron) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshTriangle.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshTriangle_HeaderFile
|
||||
#define _Handle_SMDS_MeshTriangle_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#include "Handle_SMDS_MeshFace.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshFace);
|
||||
class SMDS_MeshTriangle;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTriangle);
|
||||
|
||||
class Handle(SMDS_MeshTriangle) : public Handle(SMDS_MeshFace) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshTriangle)():Handle(SMDS_MeshFace)() {}
|
||||
Handle(SMDS_MeshTriangle)(const Handle(SMDS_MeshTriangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)(const SMDS_MeshTriangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)& operator=(const Handle(SMDS_MeshTriangle)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)& operator=(const SMDS_MeshTriangle* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshTriangle* operator->()
|
||||
{
|
||||
return (SMDS_MeshTriangle *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshTriangle* operator->() const
|
||||
{
|
||||
return (SMDS_MeshTriangle *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshTriangle)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshTriangle) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_MeshVolume.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#define _Handle_SMDS_MeshVolume_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshVolume;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshVolume);
|
||||
|
||||
class Handle(SMDS_MeshVolume) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshVolume)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshVolume)(const Handle(SMDS_MeshVolume)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)(const SMDS_MeshVolume* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)& operator=(const Handle(SMDS_MeshVolume)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)& operator=(const SMDS_MeshVolume* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshVolume* operator->()
|
||||
{
|
||||
return (SMDS_MeshVolume *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshVolume* operator->() const
|
||||
{
|
||||
return (SMDS_MeshVolume *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshVolume)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshVolume) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_Position.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#define _Handle_SMDS_Position_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 SMDS_Position;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Position);
|
||||
|
||||
class Handle(SMDS_Position) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_Position)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_Position)(const Handle(SMDS_Position)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)(const SMDS_Position* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)& operator=(const Handle(SMDS_Position)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)& operator=(const SMDS_Position* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_Position* operator->()
|
||||
{
|
||||
return (SMDS_Position *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_Position* operator->() const
|
||||
{
|
||||
return (SMDS_Position *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_Position)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_Position) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,99 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_SeqNode_HeaderFile
|
||||
#include <Handle_TCollection_SeqNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_SeqNode);
|
||||
class SMDS_SequenceNodeOfSequenceOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh);
|
||||
|
||||
class Handle(SMDS_SequenceNodeOfSequenceOfMesh) : public Handle(TCollection_SeqNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)():Handle(TCollection_SeqNode)() {}
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle) : Handle(TCollection_SeqNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const SMDS_SequenceNodeOfSequenceOfMesh* anItem) : Handle(TCollection_SeqNode)((TCollection_SeqNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const SMDS_SequenceNodeOfSequenceOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_SequenceNodeOfSequenceOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_SequenceNodeOfSequenceOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_SequenceNodeOfSequenceOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_SequenceNodeOfSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_SpacePosition.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_SpacePosition_HeaderFile
|
||||
#define _Handle_SMDS_SpacePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_SpacePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SpacePosition);
|
||||
|
||||
class Handle(SMDS_SpacePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_SpacePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_SpacePosition)(const Handle(SMDS_SpacePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)(const SMDS_SpacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)& operator=(const Handle(SMDS_SpacePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)& operator=(const SMDS_SpacePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_SpacePosition* operator->()
|
||||
{
|
||||
return (SMDS_SpacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_SpacePosition* operator->() const
|
||||
{
|
||||
return (SMDS_SpacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_SpacePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_SpacePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_StdMapNodeOfExtendedMap.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile
|
||||
#define _Handle_SMDS_StdMapNodeOfExtendedMap_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 SMDS_StdMapNodeOfExtendedMap;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap);
|
||||
|
||||
class Handle(SMDS_StdMapNodeOfExtendedMap) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)(const SMDS_StdMapNodeOfExtendedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const SMDS_StdMapNodeOfExtendedMap* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedMap* operator->()
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedMap* operator->() const
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedMap)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedMap) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_StdMapNodeOfExtendedOrientedMap.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile
|
||||
#define _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_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 SMDS_StdMapNodeOfExtendedOrientedMap;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap);
|
||||
|
||||
class Handle(SMDS_StdMapNodeOfExtendedOrientedMap) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap* operator->()
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap* operator->() const
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedOrientedMap)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedOrientedMap) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,100 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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_SMDS_VertexPosition.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _Handle_SMDS_VertexPosition_HeaderFile
|
||||
#define _Handle_SMDS_VertexPosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_VertexPosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_VertexPosition);
|
||||
|
||||
class Handle(SMDS_VertexPosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_VertexPosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_VertexPosition)(const Handle(SMDS_VertexPosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)(const SMDS_VertexPosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)& operator=(const Handle(SMDS_VertexPosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)& operator=(const SMDS_VertexPosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_VertexPosition* operator->()
|
||||
{
|
||||
return (SMDS_VertexPosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_VertexPosition* operator->() const
|
||||
{
|
||||
return (SMDS_VertexPosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_VertexPosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_VertexPosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -1,168 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- 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 : SMDS.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
package SMDS
|
||||
|
||||
---Purpose: This package provides the classes Mesh and MeshElement
|
||||
--
|
||||
-- class Mesh:
|
||||
-- - contains the main definition of the
|
||||
-- mesh and have access to the MeshElement objects
|
||||
--
|
||||
-- class MeshElement:
|
||||
-- - defines the topological constituants of the Mesh (i.e
|
||||
-- the Node, Edge, Face and Volume entities.
|
||||
--
|
||||
-- These two last classes inherits from an abstract
|
||||
-- class MeshObject.
|
||||
|
||||
uses
|
||||
SMDSAbs,
|
||||
MMgt,
|
||||
TCollection,
|
||||
TColStd,
|
||||
TColgp,
|
||||
gp
|
||||
|
||||
|
||||
is
|
||||
|
||||
---=================================
|
||||
---Category: enumerations
|
||||
--
|
||||
---=================================
|
||||
|
||||
enumeration TypeOfPosition is
|
||||
TOP_UNSPEC,
|
||||
TOP_3DSPACE,
|
||||
TOP_VERTEX,
|
||||
TOP_EDGE,
|
||||
TOP_FACE
|
||||
end TypeOfPosition;
|
||||
---Purpose: defines the type of position of a node (see SMDS_Position)
|
||||
-- TOP_UNSPEC : node position not specfied
|
||||
-- TOP_3DSPACE : just a 3d point in space not related
|
||||
-- to a CAD geometry
|
||||
-- TOP_VERTEX : to characterize a node with a CAD vertex
|
||||
-- TOP_EDGE : to characterize a node with a CAD edge
|
||||
-- TOP_FACE : to characterize a node with a CAD face
|
||||
|
||||
---=====================================
|
||||
---Category: public classes
|
||||
-- Mesh object related classes
|
||||
---=====================================
|
||||
|
||||
class MeshOrientedElementMapHasher;
|
||||
|
||||
class MeshElementMapHasher;
|
||||
|
||||
class PntHasher;
|
||||
|
||||
deferred class MeshObject;
|
||||
|
||||
class Mesh;
|
||||
|
||||
deferred class MeshElement;
|
||||
class MeshNode;
|
||||
class MeshEdge;
|
||||
deferred class MeshFace;
|
||||
class MeshTriangle;
|
||||
class MeshQuadrangle;
|
||||
deferred class MeshVolume;
|
||||
class MeshTetrahedron;
|
||||
class MeshPyramid;
|
||||
class MeshPrism;
|
||||
class MeshHexahedron;
|
||||
|
||||
private deferred class MeshIDFactory;
|
||||
private class MeshNodeIDFactory;
|
||||
private class MeshElementIDFactory;
|
||||
|
||||
deferred class MeshElementsIterator;
|
||||
class MeshVolumesIterator;
|
||||
class MeshFacesIterator;
|
||||
class MeshEdgesIterator;
|
||||
class MeshNodesIterator;
|
||||
|
||||
|
||||
deferred class Position;
|
||||
class SpacePosition;
|
||||
class VertexPosition;
|
||||
class EdgePosition;
|
||||
class FacePosition;
|
||||
|
||||
---=================================
|
||||
---Category: public classes
|
||||
-- Mesh group
|
||||
---=================================
|
||||
|
||||
class MeshGroup;
|
||||
|
||||
---=================================
|
||||
---Category: public classes
|
||||
-- Mesh collection classes
|
||||
---=================================
|
||||
|
||||
class ExtendedMap
|
||||
instantiates Map from TCollection (MeshElement from SMDS,
|
||||
MeshElementMapHasher from SMDS);
|
||||
|
||||
class ExtendedOrientedMap
|
||||
instantiates Map from TCollection (MeshElement from SMDS,
|
||||
MeshOrientedElementMapHasher from SMDS);
|
||||
|
||||
class DataMapOfPntInteger
|
||||
instantiates DataMap from TCollection (Pnt from gp,
|
||||
Integer,
|
||||
PntHasher from SMDS);
|
||||
class DataMapOfIntegerMeshElement instantiates
|
||||
DataMap from TCollection(Integer,MeshElement from SMDS,
|
||||
MapIntegerHasher from TColStd);
|
||||
|
||||
class ListOfMeshElement
|
||||
instantiates List from TCollection (MeshElement from SMDS);
|
||||
|
||||
class ListOfMesh
|
||||
instantiates List from TCollection (Mesh from SMDS);
|
||||
|
||||
class MapOfMeshElement;
|
||||
|
||||
class MapOfMeshOrientedElement;
|
||||
|
||||
class SequenceOfMesh
|
||||
instantiates Sequence from TCollection (Mesh from SMDS);
|
||||
|
||||
class HSequenceOfMesh
|
||||
instantiates HSequence from TCollection (Mesh from SMDS,
|
||||
SequenceOfMesh from SMDS);
|
||||
|
||||
|
||||
class ListOfMeshGroup
|
||||
instantiates List from TCollection(MeshGroup from SMDS);
|
||||
|
||||
end SMDS;
|
||||
|
||||
@ -1,43 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSAbs.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
package SMDSAbs
|
||||
|
||||
---Purpose: This package provides enumeration and resources
|
||||
-- for SMDS mesh
|
||||
is
|
||||
|
||||
enumeration ElementType is
|
||||
All,
|
||||
Node,
|
||||
Edge,
|
||||
Face,
|
||||
Volume
|
||||
end ElementType;
|
||||
---Purpose: type of mesh elements
|
||||
|
||||
|
||||
end SMDSAbs;
|
||||
@ -1,58 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSControl.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
package SMDSControl
|
||||
|
||||
---Purpose: provides classes for controlling the mesh
|
||||
-- according to several criteria
|
||||
|
||||
uses
|
||||
|
||||
SMDS
|
||||
|
||||
is
|
||||
|
||||
---Category: Classes
|
||||
--
|
||||
|
||||
deferred class MeshBoundary;
|
||||
class BoundaryEdges;
|
||||
|
||||
class BoundaryFaces;
|
||||
|
||||
---Category: Package methods
|
||||
--
|
||||
|
||||
ComputeNeighborFaces(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2: Integer)
|
||||
returns Integer;
|
||||
|
||||
ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3: Integer)
|
||||
returns Integer;
|
||||
|
||||
ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3,idnode4: Integer)
|
||||
returns Integer;
|
||||
|
||||
end SMDSControl;
|
||||
@ -1,30 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDSControl.jxx"
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,34 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_HeaderFile
|
||||
#include "SMDSControl.hxx"
|
||||
#endif
|
||||
@ -1,48 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSControl_BoundaryEdges.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
class BoundaryEdges from SMDSControl inherits MeshBoundary from SMDSControl
|
||||
|
||||
---Purpose: compute the boudary edges of a mesh that is the
|
||||
-- edges that are shared by only one face the result
|
||||
-- is a new mesh created in the same factory as the
|
||||
-- original mesh that contains only edges
|
||||
|
||||
uses
|
||||
|
||||
Mesh from SMDS,
|
||||
MapOfMeshElement from SMDS
|
||||
is
|
||||
|
||||
Create(M: Mesh from SMDS) returns BoundaryEdges from SMDSControl;
|
||||
|
||||
Compute(me: mutable) is redefined virtual;
|
||||
|
||||
fields
|
||||
|
||||
myBoundaryEdges : MapOfMeshElement from SMDS;
|
||||
|
||||
end BoundaryEdges;
|
||||
@ -1,82 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_BoundaryEdges.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include <SMDSControl_BoundaryEdges.jxx>
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
SMDSControl_BoundaryEdges::~SMDSControl_BoundaryEdges() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDSControl_BoundaryEdges_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_BoundaryEdges",
|
||||
sizeof(SMDSControl_BoundaryEdges),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDSControl_BoundaryEdges) Handle(SMDSControl_BoundaryEdges)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDSControl_BoundaryEdges) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_BoundaryEdges))) {
|
||||
_anOtherObject = Handle(SMDSControl_BoundaryEdges)((Handle(SMDSControl_BoundaryEdges)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDSControl_BoundaryEdges::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDSControl_BoundaryEdges) ;
|
||||
}
|
||||
Standard_Boolean SMDSControl_BoundaryEdges::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDSControl_BoundaryEdges) == AType || SMDSControl_MeshBoundary::IsKind(AType));
|
||||
}
|
||||
Handle_SMDSControl_BoundaryEdges::~Handle_SMDSControl_BoundaryEdges() {}
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_BoundaryEdges.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_BoundaryEdges_HeaderFile
|
||||
#include "SMDSControl_BoundaryEdges.hxx"
|
||||
#endif
|
||||
@ -1,50 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSControl_BoundaryFaces.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
class BoundaryFaces from SMDSControl inherits MeshBoundary from SMDSControl
|
||||
|
||||
---Purpose: compute the boudary faces of a mesh that is the
|
||||
-- faces that are shared by only one volume the result
|
||||
-- is a new mesh created in the same factory as the
|
||||
-- original mesh that contains only faces
|
||||
|
||||
uses
|
||||
|
||||
Mesh from SMDS,
|
||||
MapOfMeshElement from SMDS
|
||||
|
||||
is
|
||||
|
||||
Create(M: Mesh from SMDS) returns BoundaryFaces from SMDSControl;
|
||||
|
||||
Compute(me: mutable) is redefined virtual;
|
||||
|
||||
|
||||
fields
|
||||
|
||||
myBoundaryFaces : MapOfMeshElement from SMDS;
|
||||
|
||||
end BoundaryFaces;
|
||||
@ -1,82 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_BoundaryFaces.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDSControl_BoundaryFaces.jxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
SMDSControl_BoundaryFaces::~SMDSControl_BoundaryFaces() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDSControl_BoundaryFaces_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_BoundaryFaces",
|
||||
sizeof(SMDSControl_BoundaryFaces),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDSControl_BoundaryFaces) Handle(SMDSControl_BoundaryFaces)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDSControl_BoundaryFaces) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_BoundaryFaces))) {
|
||||
_anOtherObject = Handle(SMDSControl_BoundaryFaces)((Handle(SMDSControl_BoundaryFaces)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDSControl_BoundaryFaces::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDSControl_BoundaryFaces) ;
|
||||
}
|
||||
Standard_Boolean SMDSControl_BoundaryFaces::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDSControl_BoundaryFaces) == AType || SMDSControl_MeshBoundary::IsKind(AType));
|
||||
}
|
||||
Handle_SMDSControl_BoundaryFaces::~Handle_SMDSControl_BoundaryFaces() {}
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_BoundaryFaces.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_BoundaryFaces_HeaderFile
|
||||
#include "SMDSControl_BoundaryFaces.hxx"
|
||||
#endif
|
||||
@ -1,54 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSControl_MeshBoundary.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
deferred class MeshBoundary from SMDSControl inherits TShared from MMgt
|
||||
|
||||
---Purpose: common interface for classes which extract
|
||||
-- boundaries from a mesh
|
||||
|
||||
uses
|
||||
|
||||
Mesh from SMDS
|
||||
|
||||
is
|
||||
Initialize;
|
||||
---Purpose: Initialize an empty MeshBoundary
|
||||
|
||||
|
||||
Initialize (M : Mesh from SMDS);
|
||||
---Purpose: Initialize a MeshBoundary.
|
||||
|
||||
|
||||
Compute(me: mutable) is deferred;
|
||||
|
||||
ResultMesh(me: mutable) returns Mesh from SMDS;
|
||||
|
||||
|
||||
fields
|
||||
myMesh : Mesh from SMDS is protected;
|
||||
myBoundaryMesh : Mesh from SMDS is protected;
|
||||
|
||||
end MeshBoundary;
|
||||
@ -1,80 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_MeshBoundary.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDSControl_MeshBoundary.jxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include "Standard_TypeMismatch.hxx"
|
||||
#endif
|
||||
|
||||
SMDSControl_MeshBoundary::~SMDSControl_MeshBoundary() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDSControl_MeshBoundary_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDSControl_MeshBoundary",
|
||||
sizeof(SMDSControl_MeshBoundary),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDSControl_MeshBoundary) Handle(SMDSControl_MeshBoundary)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDSControl_MeshBoundary) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDSControl_MeshBoundary))) {
|
||||
_anOtherObject = Handle(SMDSControl_MeshBoundary)((Handle(SMDSControl_MeshBoundary)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDSControl_MeshBoundary::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDSControl_MeshBoundary) ;
|
||||
}
|
||||
Standard_Boolean SMDSControl_MeshBoundary::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDSControl_MeshBoundary) == AType || MMgt_TShared::IsKind(AType));
|
||||
}
|
||||
Handle_SMDSControl_MeshBoundary::~Handle_SMDSControl_MeshBoundary() {}
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSControl_MeshBoundary.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
@ -1,43 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSEdit.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
package SMDSEdit
|
||||
|
||||
---Level : Public.
|
||||
-- All methods of all classes will be public.
|
||||
|
||||
---Purpose: This package provides tool classes to edit or modify
|
||||
-- Meshes or MeshElements
|
||||
--
|
||||
|
||||
uses
|
||||
SMDS,
|
||||
gp
|
||||
is
|
||||
class Transform;
|
||||
---Purpose: tool class to modify a Mesh or MeshElements by a Transformation
|
||||
|
||||
end SMDSEdit;
|
||||
@ -1,66 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- Copyright (C) 2003 OPEN CASCADE
|
||||
--
|
||||
-- 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 or email : webmaster@opencascade.org
|
||||
--
|
||||
--
|
||||
--
|
||||
-- File : SMDSEdit_Transform.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
class Transform from SMDSEdit
|
||||
|
||||
---Purpose: tool to modify a Mesh or MeshElements by applying
|
||||
-- a transformation
|
||||
|
||||
uses
|
||||
Mesh from SMDS,
|
||||
ListOfMeshElement from SMDS,
|
||||
Trsf from gp
|
||||
|
||||
is
|
||||
Create (aMesh : Mesh from SMDS; aTrsf: Trsf from gp)
|
||||
returns Transform from SMDSEdit;
|
||||
---Purpose: create a transform tool on a whole mesh
|
||||
|
||||
Create (aMesh : Mesh from SMDS; aListOfME : ListOfMeshElement from SMDS;
|
||||
aTrsf : Trsf from gp)
|
||||
returns Transform from SMDSEdit;
|
||||
---Purpose: create a transform tool to be applied on a list of
|
||||
-- meshelements from the mesh aMesh. MeshElements from the
|
||||
-- list that do not belong to the mesh will not be treated
|
||||
|
||||
Perform (me: in out);
|
||||
---Purpose: Perform the current transformation on the Mesh or on
|
||||
-- the list of meshelements if it is not empty
|
||||
|
||||
SetTrsf(me: in out; aTrsf: Trsf from gp);
|
||||
---Purpose: replace the field myTrsf by the one given in argument
|
||||
-- This can be used to apply another transformation on a mesh
|
||||
-- without creating another instance of SMDSEdit_Transform
|
||||
|
||||
GetTrsf(me) returns Trsf from gp;
|
||||
---Purpose: returns the stored Trsf
|
||||
|
||||
|
||||
fields
|
||||
myMesh : Mesh from SMDS;
|
||||
myTrsf : Trsf from gp;
|
||||
myListOfME : ListOfMeshElement from SMDS;
|
||||
end Transform;
|
||||
@ -1,30 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSEdit_Transform.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDSEdit_Transform.jxx"
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,37 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDSEdit_Transform.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _gp_Trsf_HeaderFile
|
||||
#include <gp_Trsf.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSEdit_Transform_HeaderFile
|
||||
#include "SMDSEdit_Transform.hxx"
|
||||
#endif
|
||||
@ -1,27 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_BasicMap.lxx
|
||||
// Module : SMESH
|
||||
|
||||
#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_BasicMap.lxx has disappeared
|
||||
@ -1,27 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_BasicMapIterator.lxx
|
||||
// Module : SMESH
|
||||
|
||||
#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_BasicMapIterator.lxx has disappeared
|
||||
@ -1,118 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#define _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMapIterator_HeaderFile
|
||||
#include <TCollection_BasicMapIterator.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_MeshElement;
|
||||
class TColStd_MapIntegerHasher;
|
||||
class SMDS_DataMapOfIntegerMeshElement;
|
||||
class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement : public TCollection_BasicMapIterator {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement();
|
||||
Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement(const SMDS_DataMapOfIntegerMeshElement& aMap);
|
||||
Standard_EXPORT void Initialize(const SMDS_DataMapOfIntegerMeshElement& aMap) ;
|
||||
Standard_EXPORT const Standard_Integer& Key() const;
|
||||
Standard_EXPORT const Handle_SMDS_MeshElement& Value() const;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,62 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _TColStd_MapIntegerHasher_HeaderFile
|
||||
#include <TColStd_MapIntegerHasher.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey Standard_Integer
|
||||
#define TheKey_hxx <Standard_Integer.hxx>
|
||||
#define TheItem Handle_SMDS_MeshElement
|
||||
#define TheItem_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher TColStd_MapIntegerHasher
|
||||
#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfIntegerMeshElement.hxx>
|
||||
#include <TCollection_DataMapIterator.gxx>
|
||||
|
||||
@ -1,115 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile
|
||||
#define _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMapIterator_HeaderFile
|
||||
#include <TCollection_BasicMapIterator.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class gp_Pnt;
|
||||
class SMDS_PntHasher;
|
||||
class SMDS_DataMapOfPntInteger;
|
||||
class SMDS_DataMapNodeOfDataMapOfPntInteger;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_DataMapIteratorOfDataMapOfPntInteger : public TCollection_BasicMapIterator {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfPntInteger();
|
||||
Standard_EXPORT SMDS_DataMapIteratorOfDataMapOfPntInteger(const SMDS_DataMapOfPntInteger& aMap);
|
||||
Standard_EXPORT void Initialize(const SMDS_DataMapOfPntInteger& aMap) ;
|
||||
Standard_EXPORT const gp_Pnt& Key() const;
|
||||
Standard_EXPORT const Standard_Integer& Value() const;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,62 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx"
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_PntHasher_HeaderFile
|
||||
#include "SMDS_PntHasher.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey gp_Pnt
|
||||
#define TheKey_hxx <gp_Pnt.hxx>
|
||||
#define TheItem Standard_Integer
|
||||
#define TheItem_hxx <Standard_Integer.hxx>
|
||||
#define Hasher SMDS_PntHasher
|
||||
#define Hasher_hxx <SMDS_PntHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfPntInteger.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfPntInteger
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfPntInteger.hxx>
|
||||
#include <TCollection_DataMapIterator.gxx>
|
||||
|
||||
@ -1,152 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#define _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _TCollection_MapNode_HeaderFile
|
||||
#include <TCollection_MapNode.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNodePtr_HeaderFile
|
||||
#include <TCollection_MapNodePtr.hxx>
|
||||
#endif
|
||||
class SMDS_MeshElement;
|
||||
class TColStd_MapIntegerHasher;
|
||||
class SMDS_DataMapOfIntegerMeshElement;
|
||||
class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement;
|
||||
|
||||
|
||||
class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement : public TCollection_MapNode {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_DataMapNodeOfDataMapOfIntegerMeshElement(const Standard_Integer& K,const Handle(SMDS_MeshElement)& I,const TCollection_MapNodePtr& n);
|
||||
Standard_EXPORT inline Standard_Integer& Key() const;
|
||||
Standard_EXPORT inline Handle_SMDS_MeshElement& Value() const;
|
||||
Standard_EXPORT ~SMDS_DataMapNodeOfDataMapOfIntegerMeshElement();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Integer myKey;
|
||||
Handle_SMDS_MeshElement myValue;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define TheKey Standard_Integer
|
||||
#define TheKey_hxx <Standard_Integer.hxx>
|
||||
#define TheItem Handle_SMDS_MeshElement
|
||||
#define TheItem_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher TColStd_MapIntegerHasher
|
||||
#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfIntegerMeshElement.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
|
||||
@ -1,111 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _TColStd_MapIntegerHasher_HeaderFile
|
||||
#include <TColStd_MapIntegerHasher.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::~SMDS_DataMapNodeOfDataMapOfIntegerMeshElement() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_DataMapNodeOfDataMapOfIntegerMeshElement",
|
||||
sizeof(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement))) {
|
||||
_anOtherObject = Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)((Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) ;
|
||||
}
|
||||
Standard_Boolean SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) == AType || TCollection_MapNode::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement::~Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement() {}
|
||||
#define TheKey Standard_Integer
|
||||
#define TheKey_hxx <Standard_Integer.hxx>
|
||||
#define TheItem Handle_SMDS_MeshElement
|
||||
#define TheItem_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher TColStd_MapIntegerHasher
|
||||
#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfIntegerMeshElement.hxx>
|
||||
#include <TCollection_DataMapNode.gxx>
|
||||
|
||||
@ -1,152 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#define _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNode_HeaderFile
|
||||
#include <TCollection_MapNode.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNodePtr_HeaderFile
|
||||
#include <TCollection_MapNodePtr.hxx>
|
||||
#endif
|
||||
class gp_Pnt;
|
||||
class SMDS_PntHasher;
|
||||
class SMDS_DataMapOfPntInteger;
|
||||
class SMDS_DataMapIteratorOfDataMapOfPntInteger;
|
||||
|
||||
|
||||
class SMDS_DataMapNodeOfDataMapOfPntInteger : public TCollection_MapNode {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_DataMapNodeOfDataMapOfPntInteger(const gp_Pnt& K,const Standard_Integer& I,const TCollection_MapNodePtr& n);
|
||||
Standard_EXPORT inline gp_Pnt& Key() const;
|
||||
Standard_EXPORT inline Standard_Integer& Value() const;
|
||||
Standard_EXPORT ~SMDS_DataMapNodeOfDataMapOfPntInteger();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfPntInteger_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
gp_Pnt myKey;
|
||||
Standard_Integer myValue;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define TheKey gp_Pnt
|
||||
#define TheKey_hxx <gp_Pnt.hxx>
|
||||
#define TheItem Standard_Integer
|
||||
#define TheItem_hxx <Standard_Integer.hxx>
|
||||
#define Hasher SMDS_PntHasher
|
||||
#define Hasher_hxx <SMDS_PntHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfPntInteger.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfPntInteger
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfPntInteger.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
|
||||
@ -1,111 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_PntHasher_HeaderFile
|
||||
#include "SMDS_PntHasher.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger::~SMDS_DataMapNodeOfDataMapOfPntInteger() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_DataMapNodeOfDataMapOfPntInteger_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_DataMapNodeOfDataMapOfPntInteger",
|
||||
sizeof(SMDS_DataMapNodeOfDataMapOfPntInteger),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger))) {
|
||||
_anOtherObject = Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)((Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_DataMapNodeOfDataMapOfPntInteger::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger) ;
|
||||
}
|
||||
Standard_Boolean SMDS_DataMapNodeOfDataMapOfPntInteger::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger) == AType || TCollection_MapNode::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_DataMapNodeOfDataMapOfPntInteger::~Handle_SMDS_DataMapNodeOfDataMapOfPntInteger() {}
|
||||
#define TheKey gp_Pnt
|
||||
#define TheKey_hxx <gp_Pnt.hxx>
|
||||
#define TheItem Standard_Integer
|
||||
#define TheItem_hxx <Standard_Integer.hxx>
|
||||
#define Hasher SMDS_PntHasher
|
||||
#define Hasher_hxx <SMDS_PntHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfPntInteger.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfPntInteger
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfPntInteger.hxx>
|
||||
#include <TCollection_DataMapNode.gxx>
|
||||
|
||||
@ -1,147 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapOfIntegerMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapOfIntegerMeshElement_HeaderFile
|
||||
#define _SMDS_DataMapOfIntegerMeshElement_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMap_HeaderFile
|
||||
#include <TCollection_BasicMap.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_DomainError;
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_MeshElement;
|
||||
class TColStd_MapIntegerHasher;
|
||||
class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement;
|
||||
class SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_DataMapOfIntegerMeshElement : public TCollection_BasicMap {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapOfIntegerMeshElement(const Standard_Integer NbBuckets = 1);
|
||||
Standard_EXPORT SMDS_DataMapOfIntegerMeshElement& Assign(const SMDS_DataMapOfIntegerMeshElement& Other) ;
|
||||
SMDS_DataMapOfIntegerMeshElement& operator =(const SMDS_DataMapOfIntegerMeshElement& Other)
|
||||
{
|
||||
return Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_DataMapOfIntegerMeshElement()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Boolean Bind(const Standard_Integer& K,const Handle(SMDS_MeshElement)& I) ;
|
||||
Standard_EXPORT Standard_Boolean IsBound(const Standard_Integer& K) const;
|
||||
Standard_EXPORT Standard_Boolean UnBind(const Standard_Integer& K) ;
|
||||
Standard_EXPORT const Handle_SMDS_MeshElement& Find(const Standard_Integer& K) const;
|
||||
const Handle_SMDS_MeshElement& operator()(const Standard_Integer& K) const
|
||||
{
|
||||
return Find(K);
|
||||
}
|
||||
|
||||
Standard_EXPORT Handle_SMDS_MeshElement& ChangeFind(const Standard_Integer& K) ;
|
||||
Handle_SMDS_MeshElement& operator()(const Standard_Integer& K)
|
||||
{
|
||||
return ChangeFind(K);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapOfIntegerMeshElement(const SMDS_DataMapOfIntegerMeshElement& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,65 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapOfIntegerMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapOfIntegerMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_DomainError_HeaderFile
|
||||
#include <Standard_DomainError.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _TColStd_MapIntegerHasher_HeaderFile
|
||||
#include <TColStd_MapIntegerHasher.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey Standard_Integer
|
||||
#define TheKey_hxx <Standard_Integer.hxx>
|
||||
#define TheItem Handle_SMDS_MeshElement
|
||||
#define TheItem_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher TColStd_MapIntegerHasher
|
||||
#define Hasher_hxx <TColStd_MapIntegerHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfIntegerMeshElement
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfIntegerMeshElement.hxx>
|
||||
#include <TCollection_DataMap.gxx>
|
||||
|
||||
@ -1,144 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapOfPntInteger.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_DataMapOfPntInteger_HeaderFile
|
||||
#define _SMDS_DataMapOfPntInteger_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMap_HeaderFile
|
||||
#include <TCollection_BasicMap.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#include "Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_DomainError;
|
||||
class Standard_NoSuchObject;
|
||||
class gp_Pnt;
|
||||
class SMDS_PntHasher;
|
||||
class SMDS_DataMapNodeOfDataMapOfPntInteger;
|
||||
class SMDS_DataMapIteratorOfDataMapOfPntInteger;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_DataMapOfPntInteger : public TCollection_BasicMap {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapOfPntInteger(const Standard_Integer NbBuckets = 1);
|
||||
Standard_EXPORT SMDS_DataMapOfPntInteger& Assign(const SMDS_DataMapOfPntInteger& Other) ;
|
||||
SMDS_DataMapOfPntInteger& operator =(const SMDS_DataMapOfPntInteger& Other)
|
||||
{
|
||||
return Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_DataMapOfPntInteger()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Boolean Bind(const gp_Pnt& K,const Standard_Integer& I) ;
|
||||
Standard_EXPORT Standard_Boolean IsBound(const gp_Pnt& K) const;
|
||||
Standard_EXPORT Standard_Boolean UnBind(const gp_Pnt& K) ;
|
||||
Standard_EXPORT const Standard_Integer& Find(const gp_Pnt& K) const;
|
||||
const Standard_Integer& operator()(const gp_Pnt& K) const
|
||||
{
|
||||
return Find(K);
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Integer& ChangeFind(const gp_Pnt& K) ;
|
||||
Standard_Integer& operator()(const gp_Pnt& K)
|
||||
{
|
||||
return ChangeFind(K);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_DataMapOfPntInteger(const SMDS_DataMapOfPntInteger& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,65 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_DataMapOfPntInteger_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_DataMapOfPntInteger.hxx"
|
||||
|
||||
#ifndef _Standard_DomainError_HeaderFile
|
||||
#include <Standard_DomainError.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_PntHasher_HeaderFile
|
||||
#include "SMDS_PntHasher.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapNodeOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_DataMapIteratorOfDataMapOfPntInteger_HeaderFile
|
||||
#include "SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey gp_Pnt
|
||||
#define TheKey_hxx <gp_Pnt.hxx>
|
||||
#define TheItem Standard_Integer
|
||||
#define TheItem_hxx <Standard_Integer.hxx>
|
||||
#define Hasher SMDS_PntHasher
|
||||
#define Hasher_hxx <SMDS_PntHasher.hxx>
|
||||
#define TCollection_DataMapNode SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_hxx <SMDS_DataMapNodeOfDataMapOfPntInteger.hxx>
|
||||
#define TCollection_DataMapIterator SMDS_DataMapIteratorOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapIterator_hxx <SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx>
|
||||
#define Handle_TCollection_DataMapNode Handle_SMDS_DataMapNodeOfDataMapOfPntInteger
|
||||
#define TCollection_DataMapNode_Type_() SMDS_DataMapNodeOfDataMapOfPntInteger_Type_()
|
||||
#define TCollection_DataMap SMDS_DataMapOfPntInteger
|
||||
#define TCollection_DataMap_hxx <SMDS_DataMapOfPntInteger.hxx>
|
||||
#include <TCollection_DataMap.gxx>
|
||||
|
||||
@ -1,56 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- 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 : SMDS_EdgePosition.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
class EdgePosition from SMDS inherits Position from SMDS
|
||||
|
||||
---Purpose: used to characterize a MeshNode with a CAD edge
|
||||
|
||||
uses
|
||||
Pnt from gp
|
||||
|
||||
is
|
||||
|
||||
Create returns mutable EdgePosition;
|
||||
---Purpose: empty constructor. the edge is not set
|
||||
|
||||
Create(aEdgeId : Integer; aUParam : Real) returns mutable EdgePosition;
|
||||
|
||||
Coords(me) returns Pnt from gp is redefined virtual;
|
||||
---Purpose: returns the resulting 3d point to be set
|
||||
-- in the MeshNode instance
|
||||
|
||||
SetUParameter(me: mutable; aUparam : Real);
|
||||
---C++: inline
|
||||
|
||||
GetUParameter(me) returns Real;
|
||||
---C++: inline
|
||||
|
||||
fields
|
||||
|
||||
myUParameter : Real;
|
||||
|
||||
end EdgePosition;
|
||||
@ -1,83 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_EdgePosition.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDS_EdgePosition.jxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
SMDS_EdgePosition::~SMDS_EdgePosition() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_EdgePosition_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_EdgePosition",
|
||||
sizeof(SMDS_EdgePosition),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_EdgePosition) Handle(SMDS_EdgePosition)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_EdgePosition) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_EdgePosition))) {
|
||||
_anOtherObject = Handle(SMDS_EdgePosition)((Handle(SMDS_EdgePosition)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_EdgePosition::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_EdgePosition) ;
|
||||
}
|
||||
Standard_Boolean SMDS_EdgePosition::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_EdgePosition) == AType || SMDS_Position::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_EdgePosition::~Handle_SMDS_EdgePosition() {}
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_EdgePosition.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_EdgePosition_HeaderFile
|
||||
#include "SMDS_EdgePosition.hxx"
|
||||
#endif
|
||||
@ -1,41 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_EdgePosition.lxx
|
||||
// Author : Jean-Michel BOULCOURT
|
||||
// Module : SMESH
|
||||
|
||||
inline void SMDS_EdgePosition::SetUParameter(const Standard_Real aUparam)
|
||||
{
|
||||
myUParameter = aUparam;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : GetUParameter
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
inline Standard_Real SMDS_EdgePosition::GetUParameter() const
|
||||
{
|
||||
return myUParameter;
|
||||
}
|
||||
@ -1,134 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ExtendedMap.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ExtendedMap_HeaderFile
|
||||
#define _SMDS_ExtendedMap_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMap_HeaderFile
|
||||
#include <TCollection_BasicMap.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile
|
||||
#include "Handle_SMDS_StdMapNodeOfExtendedMap.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_DomainError;
|
||||
class SMDS_MeshElement;
|
||||
class SMDS_MeshElementMapHasher;
|
||||
class SMDS_StdMapNodeOfExtendedMap;
|
||||
class SMDS_MapIteratorOfExtendedMap;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ExtendedMap : public TCollection_BasicMap {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ExtendedMap(const Standard_Integer NbBuckets = 1);
|
||||
Standard_EXPORT SMDS_ExtendedMap& Assign(const SMDS_ExtendedMap& Other) ;
|
||||
SMDS_ExtendedMap& operator =(const SMDS_ExtendedMap& Other)
|
||||
{
|
||||
return Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_ExtendedMap()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Boolean Add(const Handle(SMDS_MeshElement)& aKey) ;
|
||||
Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& aKey) const;
|
||||
Standard_EXPORT Standard_Boolean Remove(const Handle(SMDS_MeshElement)& aKey) ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_ExtendedMap(const SMDS_ExtendedMap& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,60 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ExtendedMap_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ExtendedMap.hxx"
|
||||
|
||||
#ifndef _Standard_DomainError_HeaderFile
|
||||
#include <Standard_DomainError.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElementMapHasher_HeaderFile
|
||||
#include "SMDS_MeshElementMapHasher.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_StdMapNodeOfExtendedMap_HeaderFile
|
||||
#include "SMDS_StdMapNodeOfExtendedMap.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MapIteratorOfExtendedMap_HeaderFile
|
||||
#include "SMDS_MapIteratorOfExtendedMap.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey Handle_SMDS_MeshElement
|
||||
#define TheKey_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher SMDS_MeshElementMapHasher
|
||||
#define Hasher_hxx <SMDS_MeshElementMapHasher.hxx>
|
||||
#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedMap
|
||||
#define TCollection_StdMapNode_hxx <SMDS_StdMapNodeOfExtendedMap.hxx>
|
||||
#define TCollection_MapIterator SMDS_MapIteratorOfExtendedMap
|
||||
#define TCollection_MapIterator_hxx <SMDS_MapIteratorOfExtendedMap.hxx>
|
||||
#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedMap
|
||||
#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedMap_Type_()
|
||||
#define TCollection_Map SMDS_ExtendedMap
|
||||
#define TCollection_Map_hxx <SMDS_ExtendedMap.hxx>
|
||||
#include <TCollection_Map.gxx>
|
||||
|
||||
@ -1,134 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ExtendedOrientedMap.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ExtendedOrientedMap_HeaderFile
|
||||
#define _SMDS_ExtendedOrientedMap_HeaderFile
|
||||
|
||||
#ifndef _TCollection_BasicMap_HeaderFile
|
||||
#include <TCollection_BasicMap.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile
|
||||
#include "Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_DomainError;
|
||||
class SMDS_MeshElement;
|
||||
class SMDS_MeshOrientedElementMapHasher;
|
||||
class SMDS_StdMapNodeOfExtendedOrientedMap;
|
||||
class SMDS_MapIteratorOfExtendedOrientedMap;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ExtendedOrientedMap : public TCollection_BasicMap {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ExtendedOrientedMap(const Standard_Integer NbBuckets = 1);
|
||||
Standard_EXPORT SMDS_ExtendedOrientedMap& Assign(const SMDS_ExtendedOrientedMap& Other) ;
|
||||
SMDS_ExtendedOrientedMap& operator =(const SMDS_ExtendedOrientedMap& Other)
|
||||
{
|
||||
return Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT void ReSize(const Standard_Integer NbBuckets) ;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_ExtendedOrientedMap()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Boolean Add(const Handle(SMDS_MeshElement)& aKey) ;
|
||||
Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& aKey) const;
|
||||
Standard_EXPORT Standard_Boolean Remove(const Handle(SMDS_MeshElement)& aKey) ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_ExtendedOrientedMap(const SMDS_ExtendedOrientedMap& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,60 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ExtendedOrientedMap_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ExtendedOrientedMap.hxx"
|
||||
|
||||
#ifndef _Standard_DomainError_HeaderFile
|
||||
#include <Standard_DomainError.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshOrientedElementMapHasher_HeaderFile
|
||||
#include "SMDS_MeshOrientedElementMapHasher.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile
|
||||
#include "SMDS_StdMapNodeOfExtendedOrientedMap.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MapIteratorOfExtendedOrientedMap_HeaderFile
|
||||
#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define TheKey Handle_SMDS_MeshElement
|
||||
#define TheKey_hxx <SMDS_MeshElement.hxx>
|
||||
#define Hasher SMDS_MeshOrientedElementMapHasher
|
||||
#define Hasher_hxx <SMDS_MeshOrientedElementMapHasher.hxx>
|
||||
#define TCollection_StdMapNode SMDS_StdMapNodeOfExtendedOrientedMap
|
||||
#define TCollection_StdMapNode_hxx <SMDS_StdMapNodeOfExtendedOrientedMap.hxx>
|
||||
#define TCollection_MapIterator SMDS_MapIteratorOfExtendedOrientedMap
|
||||
#define TCollection_MapIterator_hxx <SMDS_MapIteratorOfExtendedOrientedMap.hxx>
|
||||
#define Handle_TCollection_StdMapNode Handle_SMDS_StdMapNodeOfExtendedOrientedMap
|
||||
#define TCollection_StdMapNode_Type_() SMDS_StdMapNodeOfExtendedOrientedMap_Type_()
|
||||
#define TCollection_Map SMDS_ExtendedOrientedMap
|
||||
#define TCollection_Map_hxx <SMDS_ExtendedOrientedMap.hxx>
|
||||
#include <TCollection_Map.gxx>
|
||||
|
||||
@ -1,64 +0,0 @@
|
||||
-- SMESH SMDS : implementaion of Salome mesh data structure
|
||||
--
|
||||
-- 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 : SMDS_FacePosition.cdl
|
||||
-- Author : Jean-Michel BOULCOURT
|
||||
-- Module : SMESH
|
||||
|
||||
class FacePosition from SMDS inherits Position from SMDS
|
||||
|
||||
---Purpose: used to characterize a MeshNode with a CAD face
|
||||
|
||||
uses
|
||||
Pnt from gp
|
||||
|
||||
is
|
||||
|
||||
Create returns mutable FacePosition;
|
||||
---Purpose: empty constructor. the face is not set
|
||||
|
||||
Create(aFaceId : Integer; aUParam,aVParam : Real)
|
||||
returns mutable FacePosition;
|
||||
|
||||
Coords(me) returns Pnt from gp is redefined virtual;
|
||||
---Purpose: returns the resulting 3d point to be set
|
||||
-- in the MeshNode instance
|
||||
|
||||
SetUParameter(me: mutable; aUparam : Real);
|
||||
---C++: inline
|
||||
|
||||
SetVParameter(me: mutable; aVparam : Real);
|
||||
---C++: inline
|
||||
|
||||
GetUParameter(me) returns Real;
|
||||
---C++: inline
|
||||
|
||||
GetVParameter(me) returns Real;
|
||||
---C++: inline
|
||||
|
||||
fields
|
||||
|
||||
myUParameter : Real;
|
||||
myVParameter : Real;
|
||||
|
||||
end FacePosition;
|
||||
@ -1,83 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_FacePosition.ixx
|
||||
// Module : SMESH
|
||||
|
||||
#include "SMDS_FacePosition.jxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
SMDS_FacePosition::~SMDS_FacePosition() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_FacePosition_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(SMDS_Position);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(SMDS_Position);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_FacePosition",
|
||||
sizeof(SMDS_FacePosition),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_FacePosition) Handle(SMDS_FacePosition)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_FacePosition) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_FacePosition))) {
|
||||
_anOtherObject = Handle(SMDS_FacePosition)((Handle(SMDS_FacePosition)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_FacePosition::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_FacePosition) ;
|
||||
}
|
||||
Standard_Boolean SMDS_FacePosition::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_FacePosition) == AType || SMDS_Position::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_FacePosition::~Handle_SMDS_FacePosition() {}
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_FacePosition.jxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _gp_Pnt_HeaderFile
|
||||
#include <gp_Pnt.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_FacePosition_HeaderFile
|
||||
#include "SMDS_FacePosition.hxx"
|
||||
#endif
|
||||
@ -1,61 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_FacePosition.lxx
|
||||
// Author : Jean-Michel BOULCOURT
|
||||
// Module : SMESH
|
||||
|
||||
inline void SMDS_FacePosition::SetUParameter(const Standard_Real aUparam)
|
||||
{
|
||||
myUParameter = aUparam;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : SetVParameter
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
inline void SMDS_FacePosition::SetVParameter(const Standard_Real aVparam)
|
||||
{
|
||||
myVParameter = aVparam;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : GetUParameter
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
inline Standard_Real SMDS_FacePosition::GetUParameter() const
|
||||
{
|
||||
return myUParameter;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : GetVParameter
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
inline Standard_Real SMDS_FacePosition::GetVParameter() const
|
||||
{
|
||||
return myVParameter;
|
||||
}
|
||||
@ -1,165 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_HSequenceOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_HSequenceOfMesh_HeaderFile
|
||||
#define _SMDS_HSequenceOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_HSequenceOfMesh_HeaderFile
|
||||
#include "Handle_SMDS_HSequenceOfMesh.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_SequenceOfMesh_HeaderFile
|
||||
#include "SMDS_SequenceOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _MMgt_TShared_HeaderFile
|
||||
#include <MMgt_TShared.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class Standard_OutOfRange;
|
||||
class SMDS_Mesh;
|
||||
class SMDS_SequenceOfMesh;
|
||||
|
||||
|
||||
class SMDS_HSequenceOfMesh : public MMgt_TShared {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_HSequenceOfMesh();
|
||||
Standard_EXPORT inline Standard_Boolean IsEmpty() const;
|
||||
Standard_EXPORT inline Standard_Integer Length() const;
|
||||
Standard_EXPORT void Clear() ;
|
||||
Standard_EXPORT void Append(const Handle(SMDS_Mesh)& anItem) ;
|
||||
Standard_EXPORT void Append(const Handle(SMDS_HSequenceOfMesh)& aSequence) ;
|
||||
Standard_EXPORT void Prepend(const Handle(SMDS_Mesh)& anItem) ;
|
||||
Standard_EXPORT void Prepend(const Handle(SMDS_HSequenceOfMesh)& aSequence) ;
|
||||
Standard_EXPORT void Reverse() ;
|
||||
Standard_EXPORT void InsertBefore(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ;
|
||||
Standard_EXPORT void InsertBefore(const Standard_Integer anIndex,const Handle(SMDS_HSequenceOfMesh)& aSequence) ;
|
||||
Standard_EXPORT void InsertAfter(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ;
|
||||
Standard_EXPORT void InsertAfter(const Standard_Integer anIndex,const Handle(SMDS_HSequenceOfMesh)& aSequence) ;
|
||||
Standard_EXPORT void Exchange(const Standard_Integer anIndex,const Standard_Integer anOtherIndex) ;
|
||||
Standard_EXPORT Handle_SMDS_HSequenceOfMesh Split(const Standard_Integer anIndex) ;
|
||||
Standard_EXPORT void SetValue(const Standard_Integer anIndex,const Handle(SMDS_Mesh)& anItem) ;
|
||||
Standard_EXPORT const Handle_SMDS_Mesh& Value(const Standard_Integer anIndex) const;
|
||||
Standard_EXPORT Handle_SMDS_Mesh& ChangeValue(const Standard_Integer anIndex) ;
|
||||
Standard_EXPORT void Remove(const Standard_Integer anIndex) ;
|
||||
Standard_EXPORT void Remove(const Standard_Integer fromIndex,const Standard_Integer toIndex) ;
|
||||
Standard_EXPORT inline const SMDS_SequenceOfMesh& Sequence() const;
|
||||
Standard_EXPORT inline SMDS_SequenceOfMesh& ChangeSequence() ;
|
||||
Standard_EXPORT Handle_SMDS_HSequenceOfMesh ShallowCopy() const;
|
||||
Standard_EXPORT ~SMDS_HSequenceOfMesh();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_HSequenceOfMesh_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
SMDS_SequenceOfMesh mySequence;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx "SMDS_Mesh.hxx"
|
||||
#define TheSequence SMDS_SequenceOfMesh
|
||||
#define TheSequence_hxx "SMDS_SequenceOfMesh.hxx"
|
||||
#define TCollection_HSequence SMDS_HSequenceOfMesh
|
||||
#define TCollection_HSequence_hxx "SMDS_HSequenceOfMesh.hxx"
|
||||
#define Handle_TCollection_HSequence Handle_SMDS_HSequenceOfMesh
|
||||
#define TCollection_HSequence_Type_() SMDS_HSequenceOfMesh_Type_()
|
||||
|
||||
#include <TCollection_HSequence.lxx>
|
||||
|
||||
#undef Item
|
||||
#undef Item_hxx
|
||||
#undef TheSequence
|
||||
#undef TheSequence_hxx
|
||||
#undef TCollection_HSequence
|
||||
#undef TCollection_HSequence_hxx
|
||||
#undef Handle_TCollection_HSequence
|
||||
#undef TCollection_HSequence_Type_
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
inline Handle_SMDS_HSequenceOfMesh ShallowCopy(const Handle_SMDS_HSequenceOfMesh& me) {
|
||||
return me->ShallowCopy();
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,102 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_HSequenceOfMesh_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_HSequenceOfMesh.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_OutOfRange_HeaderFile
|
||||
#include <Standard_OutOfRange.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_SequenceOfMesh_HeaderFile
|
||||
#include "SMDS_SequenceOfMesh.hxx"
|
||||
#endif
|
||||
SMDS_HSequenceOfMesh::~SMDS_HSequenceOfMesh() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_HSequenceOfMesh_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_HSequenceOfMesh",
|
||||
sizeof(SMDS_HSequenceOfMesh),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_HSequenceOfMesh) Handle(SMDS_HSequenceOfMesh)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_HSequenceOfMesh) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_HSequenceOfMesh))) {
|
||||
_anOtherObject = Handle(SMDS_HSequenceOfMesh)((Handle(SMDS_HSequenceOfMesh)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_HSequenceOfMesh::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_HSequenceOfMesh) ;
|
||||
}
|
||||
Standard_Boolean SMDS_HSequenceOfMesh::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_HSequenceOfMesh) == AType || MMgt_TShared::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_HSequenceOfMesh::~Handle_SMDS_HSequenceOfMesh() {}
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx "SMDS_Mesh.hxx"
|
||||
#define TheSequence SMDS_SequenceOfMesh
|
||||
#define TheSequence_hxx "SMDS_SequenceOfMesh.hxx"
|
||||
#define TCollection_HSequence SMDS_HSequenceOfMesh
|
||||
#define TCollection_HSequence_hxx "SMDS_HSequenceOfMesh.hxx"
|
||||
#define Handle_TCollection_HSequence Handle_SMDS_HSequenceOfMesh
|
||||
#define TCollection_HSequence_Type_() SMDS_HSequenceOfMesh_Type_()
|
||||
#include <TCollection_HSequence.gxx>
|
||||
|
||||
@ -1,143 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListIteratorOfListOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile
|
||||
#define _SMDS_ListIteratorOfListOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoMoreObject;
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListOfMesh;
|
||||
class SMDS_Mesh;
|
||||
class SMDS_ListNodeOfListOfMesh;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListIteratorOfListOfMesh {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMesh();
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMesh(const SMDS_ListOfMesh& L);
|
||||
Standard_EXPORT void Initialize(const SMDS_ListOfMesh& L) ;
|
||||
Standard_EXPORT inline Standard_Boolean More() const;
|
||||
Standard_EXPORT void Next() ;
|
||||
Standard_EXPORT Handle_SMDS_Mesh& Value() const;
|
||||
|
||||
|
||||
friend class SMDS_ListOfMesh;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address current;
|
||||
Standard_Address previous;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.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
|
||||
@ -1,143 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListIteratorOfListOfMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile
|
||||
#define _SMDS_ListIteratorOfListOfMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoMoreObject;
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListOfMeshElement;
|
||||
class SMDS_MeshElement;
|
||||
class SMDS_ListNodeOfListOfMeshElement;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListIteratorOfListOfMeshElement {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMeshElement();
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMeshElement(const SMDS_ListOfMeshElement& L);
|
||||
Standard_EXPORT void Initialize(const SMDS_ListOfMeshElement& L) ;
|
||||
Standard_EXPORT inline Standard_Boolean More() const;
|
||||
Standard_EXPORT void Next() ;
|
||||
Standard_EXPORT Handle_SMDS_MeshElement& Value() const;
|
||||
|
||||
|
||||
friend class SMDS_ListOfMeshElement;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address current;
|
||||
Standard_Address previous;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.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
|
||||
@ -1,58 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListIteratorOfListOfMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_NoMoreObject_HeaderFile
|
||||
#include <Standard_NoMoreObject.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.hxx>
|
||||
#include <TCollection_ListIterator.gxx>
|
||||
|
||||
@ -1,142 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListIteratorOfListOfMeshGroup.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile
|
||||
#define _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoMoreObject;
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListOfMeshGroup;
|
||||
class SMDS_MeshGroup;
|
||||
class SMDS_ListNodeOfListOfMeshGroup;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListIteratorOfListOfMeshGroup {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMeshGroup();
|
||||
Standard_EXPORT SMDS_ListIteratorOfListOfMeshGroup(const SMDS_ListOfMeshGroup& L);
|
||||
Standard_EXPORT void Initialize(const SMDS_ListOfMeshGroup& L) ;
|
||||
Standard_EXPORT inline Standard_Boolean More() const;
|
||||
Standard_EXPORT void Next() ;
|
||||
Standard_EXPORT Handle_SMDS_MeshGroup& Value() const;
|
||||
|
||||
|
||||
friend class SMDS_ListOfMeshGroup;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address current;
|
||||
Standard_Address previous;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
|
||||
#include <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
|
||||
@ -1,57 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListIteratorOfListOfMeshGroup_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
|
||||
#ifndef _Standard_NoMoreObject_HeaderFile
|
||||
#include <Standard_NoMoreObject.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListOfMeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshGroup_HeaderFile
|
||||
#include "SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
#include <TCollection_ListIterator.gxx>
|
||||
|
||||
@ -1,58 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListIteratorOfListOfMesh_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListIteratorOfListOfMesh.hxx"
|
||||
|
||||
#ifndef _Standard_NoMoreObject_HeaderFile
|
||||
#include <Standard_NoMoreObject.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMesh_HeaderFile
|
||||
#include "SMDS_ListOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMesh.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.hxx>
|
||||
#include <TCollection_ListIterator.gxx>
|
||||
|
||||
@ -1,138 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListNodeOfListOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#define _SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMesh.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _TCollection_MapNode_HeaderFile
|
||||
#include <TCollection_MapNode.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNodePtr_HeaderFile
|
||||
#include <TCollection_MapNodePtr.hxx>
|
||||
#endif
|
||||
class SMDS_Mesh;
|
||||
class SMDS_ListOfMesh;
|
||||
class SMDS_ListIteratorOfListOfMesh;
|
||||
|
||||
|
||||
class SMDS_ListNodeOfListOfMesh : public TCollection_MapNode {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_ListNodeOfListOfMesh(const Handle(SMDS_Mesh)& I,const TCollection_MapNodePtr& n);
|
||||
Standard_EXPORT inline Handle_SMDS_Mesh& Value() const;
|
||||
Standard_EXPORT ~SMDS_ListNodeOfListOfMesh();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMesh_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Handle_SMDS_Mesh myValue;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.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
|
||||
@ -1,138 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListNodeOfListOfMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#define _SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _TCollection_MapNode_HeaderFile
|
||||
#include <TCollection_MapNode.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNodePtr_HeaderFile
|
||||
#include <TCollection_MapNodePtr.hxx>
|
||||
#endif
|
||||
class SMDS_MeshElement;
|
||||
class SMDS_ListOfMeshElement;
|
||||
class SMDS_ListIteratorOfListOfMeshElement;
|
||||
|
||||
|
||||
class SMDS_ListNodeOfListOfMeshElement : public TCollection_MapNode {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_ListNodeOfListOfMeshElement(const Handle(SMDS_MeshElement)& I,const TCollection_MapNodePtr& n);
|
||||
Standard_EXPORT inline Handle_SMDS_MeshElement& Value() const;
|
||||
Standard_EXPORT ~SMDS_ListNodeOfListOfMeshElement();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMeshElement_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Handle_SMDS_MeshElement myValue;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.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
|
||||
@ -1,104 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListNodeOfListOfMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
SMDS_ListNodeOfListOfMeshElement::~SMDS_ListNodeOfListOfMeshElement() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMeshElement",
|
||||
sizeof(SMDS_ListNodeOfListOfMeshElement),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_ListNodeOfListOfMeshElement) Handle(SMDS_ListNodeOfListOfMeshElement)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement))) {
|
||||
_anOtherObject = Handle(SMDS_ListNodeOfListOfMeshElement)((Handle(SMDS_ListNodeOfListOfMeshElement)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_ListNodeOfListOfMeshElement::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement) ;
|
||||
}
|
||||
Standard_Boolean SMDS_ListNodeOfListOfMeshElement::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement) == AType || TCollection_MapNode::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_ListNodeOfListOfMeshElement::~Handle_SMDS_ListNodeOfListOfMeshElement() {}
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.hxx>
|
||||
#include <TCollection_ListNode.gxx>
|
||||
|
||||
@ -1,137 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListNodeOfListOfMeshGroup.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#define _SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _TCollection_MapNode_HeaderFile
|
||||
#include <TCollection_MapNode.hxx>
|
||||
#endif
|
||||
#ifndef _TCollection_MapNodePtr_HeaderFile
|
||||
#include <TCollection_MapNodePtr.hxx>
|
||||
#endif
|
||||
class SMDS_MeshGroup;
|
||||
class SMDS_ListOfMeshGroup;
|
||||
class SMDS_ListIteratorOfListOfMeshGroup;
|
||||
|
||||
|
||||
class SMDS_ListNodeOfListOfMeshGroup : public TCollection_MapNode {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT inline SMDS_ListNodeOfListOfMeshGroup(const Handle(SMDS_MeshGroup)& I,const TCollection_MapNodePtr& n);
|
||||
Standard_EXPORT inline Handle_SMDS_MeshGroup& Value() const;
|
||||
Standard_EXPORT ~SMDS_ListNodeOfListOfMeshGroup();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDS_ListNodeOfListOfMeshGroup_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Handle_SMDS_MeshGroup myValue;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
|
||||
#include <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
|
||||
@ -1,103 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListNodeOfListOfMeshGroup_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_MeshGroup_HeaderFile
|
||||
#include "SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListOfMeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
SMDS_ListNodeOfListOfMeshGroup::~SMDS_ListNodeOfListOfMeshGroup() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMeshGroup",
|
||||
sizeof(SMDS_ListNodeOfListOfMeshGroup),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_ListNodeOfListOfMeshGroup) Handle(SMDS_ListNodeOfListOfMeshGroup)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup))) {
|
||||
_anOtherObject = Handle(SMDS_ListNodeOfListOfMeshGroup)((Handle(SMDS_ListNodeOfListOfMeshGroup)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_ListNodeOfListOfMeshGroup::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup) ;
|
||||
}
|
||||
Standard_Boolean SMDS_ListNodeOfListOfMeshGroup::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup) == AType || TCollection_MapNode::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_ListNodeOfListOfMeshGroup::~Handle_SMDS_ListNodeOfListOfMeshGroup() {}
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
#include <TCollection_ListNode.gxx>
|
||||
|
||||
@ -1,104 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListNodeOfListOfMesh_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListNodeOfListOfMesh.hxx"
|
||||
|
||||
#ifndef _Standard_TypeMismatch_HeaderFile
|
||||
#include <Standard_TypeMismatch.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListOfMesh_HeaderFile
|
||||
#include "SMDS_ListOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMesh.hxx"
|
||||
#endif
|
||||
SMDS_ListNodeOfListOfMesh::~SMDS_ListNodeOfListOfMesh() {}
|
||||
|
||||
|
||||
|
||||
Standard_EXPORT Handle_Standard_Type& SMDS_ListNodeOfListOfMesh_Type_()
|
||||
{
|
||||
|
||||
static Handle_Standard_Type aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
if ( aType1.IsNull()) aType1 = STANDARD_TYPE(TCollection_MapNode);
|
||||
static Handle_Standard_Type aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
if ( aType2.IsNull()) aType2 = STANDARD_TYPE(MMgt_TShared);
|
||||
static Handle_Standard_Type aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
if ( aType3.IsNull()) aType3 = STANDARD_TYPE(Standard_Transient);
|
||||
|
||||
|
||||
static Handle_Standard_Transient _Ancestors[]= {aType1,aType2,aType3,NULL};
|
||||
static Handle_Standard_Type _aType = new Standard_Type("SMDS_ListNodeOfListOfMesh",
|
||||
sizeof(SMDS_ListNodeOfListOfMesh),
|
||||
1,
|
||||
(Standard_Address)_Ancestors,
|
||||
(Standard_Address)NULL);
|
||||
|
||||
return _aType;
|
||||
}
|
||||
|
||||
|
||||
// DownCast method
|
||||
// allow safe downcasting
|
||||
//
|
||||
const Handle(SMDS_ListNodeOfListOfMesh) Handle(SMDS_ListNodeOfListOfMesh)::DownCast(const Handle(Standard_Transient)& AnObject)
|
||||
{
|
||||
Handle(SMDS_ListNodeOfListOfMesh) _anOtherObject;
|
||||
|
||||
if (!AnObject.IsNull()) {
|
||||
if (AnObject->IsKind(STANDARD_TYPE(SMDS_ListNodeOfListOfMesh))) {
|
||||
_anOtherObject = Handle(SMDS_ListNodeOfListOfMesh)((Handle(SMDS_ListNodeOfListOfMesh)&)AnObject);
|
||||
}
|
||||
}
|
||||
|
||||
return _anOtherObject ;
|
||||
}
|
||||
const Handle(Standard_Type)& SMDS_ListNodeOfListOfMesh::DynamicType() const
|
||||
{
|
||||
return STANDARD_TYPE(SMDS_ListNodeOfListOfMesh) ;
|
||||
}
|
||||
Standard_Boolean SMDS_ListNodeOfListOfMesh::IsKind(const Handle(Standard_Type)& AType) const
|
||||
{
|
||||
return (STANDARD_TYPE(SMDS_ListNodeOfListOfMesh) == AType || TCollection_MapNode::IsKind(AType));
|
||||
}
|
||||
Handle_SMDS_ListNodeOfListOfMesh::~Handle_SMDS_ListNodeOfListOfMesh() {}
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.hxx>
|
||||
#include <TCollection_ListNode.gxx>
|
||||
|
||||
@ -1,167 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListOfMesh.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListOfMesh_HeaderFile
|
||||
#define _SMDS_ListOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListIteratorOfListOfMesh;
|
||||
class SMDS_Mesh;
|
||||
class SMDS_ListNodeOfListOfMesh;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListOfMesh {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMesh();
|
||||
Standard_EXPORT void Assign(const SMDS_ListOfMesh& Other) ;
|
||||
void operator=(const SMDS_ListOfMesh& Other)
|
||||
{
|
||||
Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Integer Extent() const;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_ListOfMesh()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT inline Standard_Boolean IsEmpty() const;
|
||||
Standard_EXPORT void Prepend(const Handle(SMDS_Mesh)& I) ;
|
||||
Standard_EXPORT void Prepend(SMDS_ListOfMesh& Other) ;
|
||||
Standard_EXPORT void Append(const Handle(SMDS_Mesh)& I) ;
|
||||
Standard_EXPORT void Append(SMDS_ListOfMesh& Other) ;
|
||||
Standard_EXPORT Handle_SMDS_Mesh& First() const;
|
||||
Standard_EXPORT Handle_SMDS_Mesh& Last() const;
|
||||
Standard_EXPORT void RemoveFirst() ;
|
||||
Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMesh& It) ;
|
||||
Standard_EXPORT void InsertBefore(const Handle(SMDS_Mesh)& I,SMDS_ListIteratorOfListOfMesh& It) ;
|
||||
Standard_EXPORT void InsertBefore(SMDS_ListOfMesh& Other,SMDS_ListIteratorOfListOfMesh& It) ;
|
||||
Standard_EXPORT void InsertAfter(const Handle(SMDS_Mesh)& I,SMDS_ListIteratorOfListOfMesh& It) ;
|
||||
Standard_EXPORT void InsertAfter(SMDS_ListOfMesh& Other,SMDS_ListIteratorOfListOfMesh& It) ;
|
||||
|
||||
|
||||
friend class SMDS_ListIteratorOfListOfMesh;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMesh(const SMDS_ListOfMesh& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address myFirst;
|
||||
Standard_Address myLast;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.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
|
||||
@ -1,167 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListOfMeshElement.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListOfMeshElement_HeaderFile
|
||||
#define _SMDS_ListOfMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListIteratorOfListOfMeshElement;
|
||||
class SMDS_MeshElement;
|
||||
class SMDS_ListNodeOfListOfMeshElement;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListOfMeshElement {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMeshElement();
|
||||
Standard_EXPORT void Assign(const SMDS_ListOfMeshElement& Other) ;
|
||||
void operator=(const SMDS_ListOfMeshElement& Other)
|
||||
{
|
||||
Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Integer Extent() const;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_ListOfMeshElement()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT inline Standard_Boolean IsEmpty() const;
|
||||
Standard_EXPORT void Prepend(const Handle(SMDS_MeshElement)& I) ;
|
||||
Standard_EXPORT void Prepend(SMDS_ListOfMeshElement& Other) ;
|
||||
Standard_EXPORT void Append(const Handle(SMDS_MeshElement)& I) ;
|
||||
Standard_EXPORT void Append(SMDS_ListOfMeshElement& Other) ;
|
||||
Standard_EXPORT Handle_SMDS_MeshElement& First() const;
|
||||
Standard_EXPORT Handle_SMDS_MeshElement& Last() const;
|
||||
Standard_EXPORT void RemoveFirst() ;
|
||||
Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMeshElement& It) ;
|
||||
Standard_EXPORT void InsertBefore(const Handle(SMDS_MeshElement)& I,SMDS_ListIteratorOfListOfMeshElement& It) ;
|
||||
Standard_EXPORT void InsertBefore(SMDS_ListOfMeshElement& Other,SMDS_ListIteratorOfListOfMeshElement& It) ;
|
||||
Standard_EXPORT void InsertAfter(const Handle(SMDS_MeshElement)& I,SMDS_ListIteratorOfListOfMeshElement& It) ;
|
||||
Standard_EXPORT void InsertAfter(SMDS_ListOfMeshElement& Other,SMDS_ListIteratorOfListOfMeshElement& It) ;
|
||||
|
||||
|
||||
friend class SMDS_ListIteratorOfListOfMeshElement;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMeshElement(const SMDS_ListOfMeshElement& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address myFirst;
|
||||
Standard_Address myLast;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.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
|
||||
@ -1,55 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListOfMeshElement_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListOfMeshElement.hxx"
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMeshElement.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_MeshElement
|
||||
#define Item_hxx <SMDS_MeshElement.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMeshElement.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshElement
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMeshElement.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshElement
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshElement_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshElement
|
||||
#define TCollection_List_hxx <SMDS_ListOfMeshElement.hxx>
|
||||
#include <TCollection_List.gxx>
|
||||
|
||||
@ -1,166 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListOfMeshGroup.hxx
|
||||
// Module : SMESH
|
||||
|
||||
#ifndef _SMDS_ListOfMeshGroup_HeaderFile
|
||||
#define _SMDS_ListOfMeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_Address_HeaderFile
|
||||
#include <Standard_Address.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#include "Handle_SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Boolean_HeaderFile
|
||||
#include <Standard_Boolean.hxx>
|
||||
#endif
|
||||
class Standard_NoSuchObject;
|
||||
class SMDS_ListIteratorOfListOfMeshGroup;
|
||||
class SMDS_MeshGroup;
|
||||
class SMDS_ListNodeOfListOfMeshGroup;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDS_ListOfMeshGroup {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMeshGroup();
|
||||
Standard_EXPORT void Assign(const SMDS_ListOfMeshGroup& Other) ;
|
||||
void operator=(const SMDS_ListOfMeshGroup& Other)
|
||||
{
|
||||
Assign(Other);
|
||||
}
|
||||
|
||||
Standard_EXPORT Standard_Integer Extent() const;
|
||||
Standard_EXPORT void Clear() ;
|
||||
~SMDS_ListOfMeshGroup()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
Standard_EXPORT inline Standard_Boolean IsEmpty() const;
|
||||
Standard_EXPORT void Prepend(const Handle(SMDS_MeshGroup)& I) ;
|
||||
Standard_EXPORT void Prepend(SMDS_ListOfMeshGroup& Other) ;
|
||||
Standard_EXPORT void Append(const Handle(SMDS_MeshGroup)& I) ;
|
||||
Standard_EXPORT void Append(SMDS_ListOfMeshGroup& Other) ;
|
||||
Standard_EXPORT Handle_SMDS_MeshGroup& First() const;
|
||||
Standard_EXPORT Handle_SMDS_MeshGroup& Last() const;
|
||||
Standard_EXPORT void RemoveFirst() ;
|
||||
Standard_EXPORT void Remove(SMDS_ListIteratorOfListOfMeshGroup& It) ;
|
||||
Standard_EXPORT void InsertBefore(const Handle(SMDS_MeshGroup)& I,SMDS_ListIteratorOfListOfMeshGroup& It) ;
|
||||
Standard_EXPORT void InsertBefore(SMDS_ListOfMeshGroup& Other,SMDS_ListIteratorOfListOfMeshGroup& It) ;
|
||||
Standard_EXPORT void InsertAfter(const Handle(SMDS_MeshGroup)& I,SMDS_ListIteratorOfListOfMeshGroup& It) ;
|
||||
Standard_EXPORT void InsertAfter(SMDS_ListOfMeshGroup& Other,SMDS_ListIteratorOfListOfMeshGroup& It) ;
|
||||
|
||||
|
||||
friend class SMDS_ListIteratorOfListOfMeshGroup;
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
Standard_EXPORT SMDS_ListOfMeshGroup(const SMDS_ListOfMeshGroup& Other);
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
Standard_Address myFirst;
|
||||
Standard_Address myLast;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
|
||||
#include <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
|
||||
@ -1,54 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// Copyright (C) 2003 OPEN CASCADE
|
||||
//
|
||||
// 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 or email : webmaster@opencascade.org
|
||||
//
|
||||
//
|
||||
//
|
||||
// File : SMDS_ListOfMeshGroup_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListOfMeshGroup.hxx"
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshGroup_HeaderFile
|
||||
#include "SMDS_MeshGroup.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_MeshGroup
|
||||
#define Item_hxx "SMDS_MeshGroup.hxx"
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_hxx "SMDS_ListNodeOfListOfMeshGroup.hxx"
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMeshGroup
|
||||
#define TCollection_ListIterator_hxx "SMDS_ListIteratorOfListOfMeshGroup.hxx"
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMeshGroup
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMeshGroup_Type_()
|
||||
#define TCollection_List SMDS_ListOfMeshGroup
|
||||
#define TCollection_List_hxx "SMDS_ListOfMeshGroup.hxx"
|
||||
#include <TCollection_List.gxx>
|
||||
|
||||
@ -1,55 +0,0 @@
|
||||
// SMESH SMDS : implementaion of Salome mesh data structure
|
||||
//
|
||||
// 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 : SMDS_ListOfMesh_0.cxx
|
||||
// Module : SMESH
|
||||
|
||||
using namespace std;
|
||||
#include "SMDS_ListOfMesh.hxx"
|
||||
|
||||
#ifndef _Standard_NoSuchObject_HeaderFile
|
||||
#include <Standard_NoSuchObject.hxx>
|
||||
#endif
|
||||
#ifndef _SMDS_ListIteratorOfListOfMesh_HeaderFile
|
||||
#include "SMDS_ListIteratorOfListOfMesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#include "SMDS_ListNodeOfListOfMesh.hxx"
|
||||
#endif
|
||||
|
||||
|
||||
#define Item Handle_SMDS_Mesh
|
||||
#define Item_hxx <SMDS_Mesh.hxx>
|
||||
#define TCollection_ListNode SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_hxx <SMDS_ListNodeOfListOfMesh.hxx>
|
||||
#define TCollection_ListIterator SMDS_ListIteratorOfListOfMesh
|
||||
#define TCollection_ListIterator_hxx <SMDS_ListIteratorOfListOfMesh.hxx>
|
||||
#define Handle_TCollection_ListNode Handle_SMDS_ListNodeOfListOfMesh
|
||||
#define TCollection_ListNode_Type_() SMDS_ListNodeOfListOfMesh_Type_()
|
||||
#define TCollection_List SMDS_ListOfMesh
|
||||
#define TCollection_List_hxx <SMDS_ListOfMesh.hxx>
|
||||
#include <TCollection_List.gxx>
|
||||
|
||||
@ -1 +0,0 @@
|
||||
#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_Map.gxx has disappeared
|
||||
@ -1 +0,0 @@
|
||||
#error /adv_21/KAS/C40/jmbsmds/inc/SMDS_MapHasher.gxx has disappeared
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user